Game/UltimateFishing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
UltimateFishing/Assets/Scripts/Assembly-CSharp/VolumetricFogAndMist/VolumetricFog.cs
BobSong 006a5b7e21 first commit
2026-02-21 16:45:37 +08:00

5963 lines
128 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Rendering;
using UnityEngine.XR;
namespace VolumetricFogAndMist
{
[HelpURLAttribute("http://kronnect.com/taptapgo")]
[AddComponentMenu("Image Effects/Rendering/Volumetric Fog & Mist")]
[ExecuteInEditMode]
public class VolumetricFog : MonoBehaviour
{
[Serializable]
public struct PointLightParams
{
public Light light;
public float range;
public float intensity;
public float intensityMultiplier;
public Vector3 position;
public Color color;
}
private struct FogOfWarTransition
{
public bool enabled;
public int x;
public int y;
public float startTime;
public float startDelay;
public float duration;
public byte initialAlpha;
public byte targetAlpha;
}
public const string SKW_FOG_DISTANCE_ON = "FOG_DISTANCE_ON";
public const string SKW_LIGHT_SCATTERING = "FOG_SCATTERING_ON";
public const string SKW_FOG_AREA_BOX = "FOG_AREA_BOX";
public const string SKW_FOG_AREA_SPHERE = "FOG_AREA_SPHERE";
public const string SKW_FOG_VOID_BOX = "FOG_VOID_BOX";
public const string SKW_FOG_VOID_SPHERE = "FOG_VOID_SPHERE";
public const string SKW_FOG_HAZE_ON = "FOG_HAZE_ON";
public const string SKW_FOG_OF_WAR_ON = "FOG_OF_WAR_ON";
public const string SKW_FOG_BLUR = "FOG_BLUR_ON";
public const string SKW_SUN_SHADOWS = "FOG_SUN_SHADOWS_ON";
public const string SKW_FOG_USE_XY_PLANE = "FOG_USE_XY_PLANE";
public const string SKW_FOG_COMPUTE_DEPTH = "FOG_COMPUTE_DEPTH";
public const string SKW_POINT_LIGHTS = "FOG_POINT_LIGHTS";
private const string DEPTH_CAM_NAME = "VFMDepthCamera";
private const string DEPTH_SUN_CAM_NAME = "VFMDepthSunCamera";
private const string VFM_BUILD_FIRST_INSTALL = "VFMFirstInstall";
private const string VFM_BUILD_HINT = "VFMBuildHint961b1";
private static VolumetricFog _fog;
[HideInInspector]
public bool isDirty;
[SerializeField]
private FOG_PRESET _preset = FOG_PRESET.Mist;
[SerializeField]
private VolumetricFogProfile _profile;
[SerializeField]
private bool _profileSync = true;
[SerializeField]
private bool _useFogVolumes;
[SerializeField]
private bool _debugPass;
[SerializeField]
private TRANSPARENT_MODE _transparencyBlendMode;
[SerializeField]
[Range(0f, 1f)]
private float _transparencyBlendPower = 1f;
[SerializeField]
private LayerMask _transparencyLayerMask = -1;
[SerializeField]
private LIGHTING_MODEL _lightingModel;
[SerializeField]
private bool _enableMultipleCameras;
[SerializeField]
private bool _computeDepth;
[SerializeField]
private COMPUTE_DEPTH_SCOPE _computeDepthScope;
[SerializeField]
private float _transparencyCutOff = 0.1f;
[SerializeField]
private bool _renderBeforeTransparent;
[SerializeField]
private GameObject _sun;
[SerializeField]
[Range(0f, 0.5f)]
private float _timeBetweenTextureUpdates = 0.2f;
[SerializeField]
private bool _sunCopyColor = true;
[SerializeField]
[Range(0f, 1.25f)]
private float _density = 1f;
[Range(0f, 1f)]
[SerializeField]
private float _noiseStrength = 0.8f;
[Range(1f, 2f)]
[SerializeField]
private float _noiseFinalMultiplier = 1f;
[Range(-0.3f, 2f)]
[SerializeField]
private float _noiseSparse;
[SerializeField]
[Range(0f, 1000f)]
private float _distance;
[Range(0f, 2000f)]
[SerializeField]
private float _maxFogLength = 1000f;
[SerializeField]
[Range(0f, 1f)]
private float _maxFogLengthFallOff;
[Range(0f, 5f)]
[SerializeField]
private float _distanceFallOff;
[Range(0.0001f, 500f)]
[SerializeField]
private float _height = 4f;
[SerializeField]
private float _baselineHeight;
[SerializeField]
private bool _baselineRelativeToCamera;
[SerializeField]
[Range(0f, 1f)]
private float _baselineRelativeToCameraDelay;
[SerializeField]
[Range(0.2f, 25f)]
private float _noiseScale = 1f;
[SerializeField]
[Range(0f, 1.05f)]
private float _alpha = 1f;
[SerializeField]
private Color _color = new Color(0.89f, 0.89f, 0.89f, 1f);
[SerializeField]
private Color _specularColor = new Color(1f, 1f, 0.8f, 1f);
[Range(0f, 1f)]
[SerializeField]
private float _specularThreshold = 0.6f;
[SerializeField]
[Range(0f, 1f)]
private float _specularIntensity = 0.2f;
[SerializeField]
private Vector3 _lightDirection = new Vector3(1f, 0f, -1f);
[SerializeField]
private float _lightIntensity = 0.2f;
[SerializeField]
private Color _lightColor = Color.white;
[Range(1f, 5f)]
[SerializeField]
private int _updateTextureSpread = 1;
[SerializeField]
[Range(0f, 1f)]
private float _speed = 0.01f;
[SerializeField]
private Vector3 _windDirection = new Vector3(-1f, 0f, 0f);
[SerializeField]
private bool _useRealTime;
[SerializeField]
private Color _skyColor = new Color(0.89f, 0.89f, 0.89f, 1f);
[Range(0f, 1000f)]
[SerializeField]
private float _skyHaze = 50f;
[SerializeField]
[Range(0f, 1f)]
private float _skySpeed = 0.3f;
[SerializeField]
[Range(0f, 1f)]
private float _skyNoiseStrength = 0.1f;
[SerializeField]
[Range(0f, 1f)]
private float _skyAlpha = 1f;
[SerializeField]
[Range(0f, 0.999f)]
private float _skyDepth = 0.999f;
[SerializeField]
private GameObject _character;
[SerializeField]
private FOG_VOID_TOPOLOGY _fogVoidTopology;
[SerializeField]
[Range(0f, 10f)]
private float _fogVoidFallOff = 1f;
[SerializeField]
private float _fogVoidRadius;
[SerializeField]
private Vector3 _fogVoidPosition = Vector3.zero;
[SerializeField]
private float _fogVoidDepth;
[SerializeField]
private float _fogVoidHeight;
[SerializeField]
private bool _fogVoidInverted;
[SerializeField]
private bool _fogAreaShowGizmos = true;
[SerializeField]
private GameObject _fogAreaCenter;
[Range(0.001f, 10f)]
[SerializeField]
private float _fogAreaFallOff = 1f;
[SerializeField]
private FOG_AREA_FOLLOW_MODE _fogAreaFollowMode;
[SerializeField]
private FOG_AREA_TOPOLOGY _fogAreaTopology = FOG_AREA_TOPOLOGY.Sphere;
[SerializeField]
private float _fogAreaRadius;
[SerializeField]
private Vector3 _fogAreaPosition = Vector3.zero;
[SerializeField]
private float _fogAreaDepth;
[SerializeField]
private float _fogAreaHeight;
[SerializeField]
private FOG_AREA_SORTING_MODE _fogAreaSortingMode;
[SerializeField]
private int _fogAreaRenderOrder = 1;
public PointLightParams[] pointLightParams;
[SerializeField]
private bool pointLightDataMigrated;
private Color[] pointLightColorBuffer;
private Vector4[] pointLightPositionBuffer;
[SerializeField]
private GameObject[] _pointLights = new GameObject[6];
[SerializeField]
private float[] _pointLightRanges = new float[6];
[SerializeField]
private float[] _pointLightIntensities = new float[6] { 1f, 1f, 1f, 1f, 1f, 1f };
[SerializeField]
private float[] _pointLightIntensitiesMultiplier = new float[6] { 1f, 1f, 1f, 1f, 1f, 1f };
[SerializeField]
private Vector3[] _pointLightPositions = new Vector3[6];
[SerializeField]
private Color[] _pointLightColors = new Color[6]
{
new Color(1f, 1f, 0f, 1f),
new Color(1f, 1f, 0f, 1f),
new Color(1f, 1f, 0f, 1f),
new Color(1f, 1f, 0f, 1f),
new Color(1f, 1f, 0f, 1f),
new Color(1f, 1f, 0f, 1f)
};
[SerializeField]
private bool _pointLightTrackingAuto;
[SerializeField]
private Transform _pointLightTrackingPivot;
[SerializeField]
private int _pointLightTrackingCount;
[SerializeField]
[Range(0f, 5f)]
private float _pointLightTrackingCheckInterval = 1f;
[SerializeField]
private float _pointLightTrackingNewLightsCheckInterval = 3f;
[SerializeField]
private float _pointLightInscattering = 1f;
[SerializeField]
private float _pointLightIntensity = 1f;
[SerializeField]
private float _pointLightInsideAtten;
[Range(1f, 8f)]
[SerializeField]
private int _downsampling = 1;
[SerializeField]
private bool _forceComposition;
[SerializeField]
private bool _edgeImprove;
[Range(1E-05f, 0.005f)]
[SerializeField]
private float _edgeThreshold = 0.0005f;
[Range(1f, 20f)]
[SerializeField]
private float _stepping = 12f;
[Range(0f, 50f)]
[SerializeField]
private float _steppingNear = 1f;
[SerializeField]
private bool _dithering;
[Range(0.1f, 5f)]
[SerializeField]
private float _ditherStrength = 0.75f;
[Range(0f, 2f)]
[SerializeField]
private float _jitterStrength = 0.5f;
[SerializeField]
private bool _lightScatteringEnabled;
[Range(0f, 1f)]
[SerializeField]
private float _lightScatteringDiffusion = 0.7f;
[Range(0f, 1f)]
[SerializeField]
private float _lightScatteringSpread = 0.686f;
[Range(4f, 64f)]
[SerializeField]
private int _lightScatteringSamples = 16;
[Range(0f, 50f)]
[SerializeField]
private float _lightScatteringWeight = 1.9f;
[Range(0f, 50f)]
[SerializeField]
private float _lightScatteringIllumination = 18f;
[Range(0.9f, 1.1f)]
[SerializeField]
private float _lightScatteringDecay = 0.986f;
[Range(0f, 0.2f)]
[SerializeField]
private float _lightScatteringExposure;
[Range(0f, 1f)]
[SerializeField]
private float _lightScatteringJittering = 0.5f;
[SerializeField]
private bool _fogBlur;
[Range(0f, 1f)]
[SerializeField]
private float _fogBlurDepth = 0.05f;
[SerializeField]
private bool _sunShadows;
[SerializeField]
private LayerMask _sunShadowsLayerMask = -1;
[Range(0f, 1f)]
[SerializeField]
private float _sunShadowsStrength = 0.5f;
[SerializeField]
private float _sunShadowsBias = 0.1f;
[Range(0f, 0.5f)]
[SerializeField]
private float _sunShadowsJitterStrength = 0.1f;
[Range(0f, 4f)]
[SerializeField]
private int _sunShadowsResolution = 2;
[Range(50f, 2000f)]
[SerializeField]
private float _sunShadowsMaxDistance = 200f;
[SerializeField]
private SUN_SHADOWS_BAKE_MODE _sunShadowsBakeMode = SUN_SHADOWS_BAKE_MODE.Discrete;
[SerializeField]
private float _sunShadowsRefreshInterval;
[Range(0f, 1f)]
[SerializeField]
private float _sunShadowsCancellation;
[Range(0f, 10f)]
[SerializeField]
private float _turbulenceStrength;
[SerializeField]
private bool _useXYPlane;
[SerializeField]
private bool _useSinglePassStereoRenderingMatrix;
[SerializeField]
private SPSR_BEHAVIOUR _spsrBehaviour;
[SerializeField]
private bool _reduceFlickerBigWorlds;
[SerializeField]
private bool _enableMask;
[SerializeField]
private LayerMask _maskLayer = 8388608;
[SerializeField]
[Range(1f, 4f)]
private int _maskDownsampling = 1;
[NonSerialized]
public float distanceToCameraMin;
[NonSerialized]
public float distanceToCameraMax;
[NonSerialized]
public float distanceToCamera;
[NonSerialized]
public float distanceToCameraYAxis;
public VolumetricFog fogRenderer;
private VolumetricFog[] allFogRenderers;
private bool isPartOfScene;
private float initialFogAlpha;
private float targetFogAlpha;
private float initialSkyHazeAlpha;
private float targetSkyHazeAlpha;
private bool transitionAlpha;
private bool transitionColor;
private bool transitionSpecularColor;
private bool transitionLightColor;
private bool transitionProfile;
private bool targetColorActive;
private bool targetSpecularColorActive;
private bool targetLightColorActive;
private Color initialFogColor;
private Color targetFogColor;
private Color initialFogSpecularColor;
private Color targetFogSpecularColor;
private Color initialLightColor;
private Color targetLightColor;
private float transitionDuration;
private float transitionStartTime;
private float currentFogAlpha;
private float currentSkyHazeAlpha;
private Color currentFogColor;
private Color currentFogSpecularColor;
private Color currentLightColor;
private VolumetricFogProfile initialProfile;
private VolumetricFogProfile targetProfile;
private float oldBaselineRelativeCameraY;
private float currentFogAltitude;
private float skyHazeSpeedAcum;
private bool _hasCamera;
private bool _hasCameraChecked;
private Camera mainCamera;
private List<string> shaderKeywords;
private Material blurMat;
private RenderBuffer[] mrt;
private int _renderingInstancesCount;
private bool shouldUpdateMaterialProperties;
private int lastFrameCount;
[NonSerialized]
public Material fogMat;
private RenderTexture depthTexture;
private RenderTexture depthSunTexture;
private RenderTexture reducedDestination;
private Light[] lastFoundLights;
private Light[] lightBuffer;
private Light[] currentLights;
private float trackPointAutoLastTime;
private float trackPointCheckNewLightsLastTime;
private Shader depthShader;
private Shader depthShaderAndTrans;
private GameObject depthCamObj;
private Camera depthCam;
private float lastTextureUpdate;
private Vector3 windSpeedAcum;
private Texture2D adjustedTexture;
private Color[] noiseColors;
private Color[] adjustedColors;
private float sunLightIntensity = 1f;
private bool needUpdateTexture;
private bool hasChangeAdjustedColorsAlpha;
private int updatingTextureSlice;
private Color updatingTextureLightColor;
private Color lastRenderSettingsAmbientLight;
private float lastRenderSettingsAmbientIntensity;
private int lastFrameAppliedChaos;
private int lastFrameAppliedWind;
private Light sunLight;
private Vector2 oldSunPos;
private float sunFade = 1f;
private GameObject depthSunCamObj;
private Camera depthSunCam;
private Shader depthSunShader;
[NonSerialized]
public bool needUpdateDepthSunTexture;
private float lastShadowUpdateFrame;
private Texture2D adjustedChaosTexture;
private Material chaosLerpMat;
private float turbAcum;
private float deltaTime;
private float timeOfLastRender;
private List<VolumetricFog> fogInstances = new List<VolumetricFog>();
private List<VolumetricFog> fogRenderInstances = new List<VolumetricFog>();
private MeshRenderer mr;
private float lastTimeSortInstances;
private const float FOG_INSTANCES_SORT_INTERVAL = 2f;
private Vector3 lastCamPos;
private CommandBuffer maskCommandBuffer;
private RenderTextureDescriptor rtMaskDesc;
private Material maskMaterial;
private const int MAX_SIMULTANEOUS_TRANSITIONS = 10000;
[SerializeField]
private bool _fogOfWarEnabled;
[SerializeField]
private Vector3 _fogOfWarCenter;
[SerializeField]
private Vector3 _fogOfWarSize = new Vector3(1024f, 0f, 1024f);
[SerializeField]
[Range(32f, 2048f)]
private int _fogOfWarTextureSize = 256;
[Range(0f, 100f)]
[SerializeField]
private float _fogOfWarRestoreDelay;
[SerializeField]
[Range(0f, 25f)]
private float _fogOfWarRestoreDuration = 2f;
private Texture2D fogOfWarTexture;
private Color32[] fogOfWarColorBuffer;
private FogOfWarTransition[] fowTransitionList;
private int lastTransitionPos;
private Dictionary<int, int> fowTransitionIndices;
private bool requiresTextureUpload;
public const int MAX_POINT_LIGHTS = 6;
public static VolumetricFog instance
{
get
{
if (_fog == null)
{
if (Camera.main != null)
{
_fog = Camera.main.GetComponent<VolumetricFog>();
}
if (_fog == null)
{
Camera[] allCameras = Camera.allCameras;
foreach (Camera camera in allCameras)
{
_fog = camera.GetComponent<VolumetricFog>();
if (_fog != null)
{
break;
}
}
}
}
return _fog;
}
}
public FOG_PRESET preset
{
get
{
return _preset;
}
set
{
if (value != _preset)
{
_preset = value;
UpdatePreset();
isDirty = true;
}
}
}
public VolumetricFogProfile profile
{
get
{
return _profile;
}
set
{
if (value != _profile)
{
_profile = value;
if (_profile != null)
{
_profile.Load(this);
_preset = FOG_PRESET.Custom;
}
isDirty = true;
}
}
}
public bool profileSync
{
get
{
return _profileSync;
}
set
{
if (value != _profileSync)
{
_profileSync = value;
isDirty = true;
}
}
}
public bool useFogVolumes
{
get
{
return _useFogVolumes;
}
set
{
if (value != _useFogVolumes)
{
_useFogVolumes = value;
isDirty = true;
}
}
}
public bool debugDepthPass
{
get
{
return _debugPass;
}
set
{
if (value != _debugPass)
{
_debugPass = value;
isDirty = true;
}
}
}
public TRANSPARENT_MODE transparencyBlendMode
{
get
{
return _transparencyBlendMode;
}
set
{
if (value != _transparencyBlendMode)
{
_transparencyBlendMode = value;
UpdateRenderComponents();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float transparencyBlendPower
{
get
{
return _transparencyBlendPower;
}
set
{
if (value != _transparencyBlendPower)
{
_transparencyBlendPower = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public LayerMask transparencyLayerMask
{
get
{
return _transparencyLayerMask;
}
set
{
if ((int)_transparencyLayerMask != (int)value)
{
_transparencyLayerMask = value;
isDirty = true;
}
}
}
public LIGHTING_MODEL lightingModel
{
get
{
return _lightingModel;
}
set
{
if (value != _lightingModel)
{
_lightingModel = value;
UpdateMaterialProperties();
UpdateTexture();
isDirty = true;
}
}
}
public bool enableMultipleCameras
{
get
{
return _enableMultipleCameras;
}
set
{
if (value != _enableMultipleCameras)
{
_enableMultipleCameras = value;
UpdateMultiCameraSetup();
isDirty = true;
}
}
}
public bool computeDepth
{
get
{
return _computeDepth;
}
set
{
if (value != _computeDepth)
{
_computeDepth = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public COMPUTE_DEPTH_SCOPE computeDepthScope
{
get
{
return _computeDepthScope;
}
set
{
if (value != _computeDepthScope)
{
_computeDepthScope = value;
if (_computeDepthScope == COMPUTE_DEPTH_SCOPE.TreeBillboardsAndTransparentObjects)
{
_transparencyBlendMode = TRANSPARENT_MODE.None;
}
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float transparencyCutOff
{
get
{
return _transparencyCutOff;
}
set
{
if (value != _transparencyCutOff)
{
_transparencyCutOff = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool renderBeforeTransparent
{
get
{
return _renderBeforeTransparent;
}
set
{
if (value != _renderBeforeTransparent)
{
_renderBeforeTransparent = value;
if (_renderBeforeTransparent)
{
_transparencyBlendMode = TRANSPARENT_MODE.None;
}
UpdateRenderComponents();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public GameObject sun
{
get
{
return _sun;
}
set
{
if (value != _sun)
{
_sun = value;
UpdateSun();
isDirty = true;
}
}
}
public float timeBetweenTextureUpdates
{
get
{
return _timeBetweenTextureUpdates;
}
set
{
if (value != _timeBetweenTextureUpdates)
{
_timeBetweenTextureUpdates = value;
isDirty = true;
}
}
}
public bool sunCopyColor
{
get
{
return _sunCopyColor;
}
set
{
if (value != _sunCopyColor)
{
_sunCopyColor = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float density
{
get
{
return _density;
}
set
{
if (value != _density)
{
_preset = FOG_PRESET.Custom;
_density = value;
UpdateMaterialProperties();
UpdateTextureAlpha();
UpdateTexture();
isDirty = true;
}
}
}
public float noiseStrength
{
get
{
return _noiseStrength;
}
set
{
if (value != _noiseStrength)
{
_preset = FOG_PRESET.Custom;
_noiseStrength = value;
UpdateMaterialProperties();
UpdateTextureAlpha();
UpdateTexture();
isDirty = true;
}
}
}
public float noiseFinalMultiplier
{
get
{
return _noiseFinalMultiplier;
}
set
{
if (value != _noiseFinalMultiplier)
{
_preset = FOG_PRESET.Custom;
_noiseFinalMultiplier = value;
UpdateMaterialProperties();
UpdateTextureAlpha();
UpdateTexture();
isDirty = true;
}
}
}
public float noiseSparse
{
get
{
return _noiseSparse;
}
set
{
if (value != _noiseSparse)
{
_preset = FOG_PRESET.Custom;
_noiseSparse = value;
UpdateMaterialProperties();
UpdateTextureAlpha();
UpdateTexture();
isDirty = true;
}
}
}
public float distance
{
get
{
return _distance;
}
set
{
if (value != _distance)
{
_preset = FOG_PRESET.Custom;
_distance = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float maxFogLength
{
get
{
return _maxFogLength;
}
set
{
if (value != _maxFogLength)
{
_maxFogLength = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float maxFogLengthFallOff
{
get
{
return _maxFogLengthFallOff;
}
set
{
if (value != _maxFogLengthFallOff)
{
_maxFogLengthFallOff = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float distanceFallOff
{
get
{
return _distanceFallOff;
}
set
{
if (value != _distanceFallOff)
{
_preset = FOG_PRESET.Custom;
_distanceFallOff = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float height
{
get
{
return _height;
}
set
{
if (value != _height)
{
_preset = FOG_PRESET.Custom;
_height = Mathf.Max(value, 0.0001f);
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float baselineHeight
{
get
{
return _baselineHeight;
}
set
{
if (value == _baselineHeight)
{
return;
}
_preset = FOG_PRESET.Custom;
_baselineHeight = value;
if (_fogAreaRadius > 0f)
{
if (_useXYPlane)
{
_fogAreaPosition.z = _baselineHeight;
}
else
{
_fogAreaPosition.y = _baselineHeight;
}
}
UpdateMaterialProperties();
isDirty = true;
}
}
public bool baselineRelativeToCamera
{
get
{
return _baselineRelativeToCamera;
}
set
{
if (value != _baselineRelativeToCamera)
{
_preset = FOG_PRESET.Custom;
_baselineRelativeToCamera = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float baselineRelativeToCameraDelay
{
get
{
return _baselineRelativeToCameraDelay;
}
set
{
if (value != _baselineRelativeToCameraDelay)
{
_baselineRelativeToCameraDelay = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float noiseScale
{
get
{
return _noiseScale;
}
set
{
if (value != _noiseScale)
{
_preset = FOG_PRESET.Custom;
_noiseScale = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float alpha
{
get
{
return _alpha;
}
set
{
if (value != _alpha)
{
_preset = FOG_PRESET.Custom;
_alpha = value;
currentFogAlpha = _alpha;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Color color
{
get
{
return _color;
}
set
{
if (value != _color)
{
_preset = FOG_PRESET.Custom;
_color = value;
currentFogColor = _color;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Color specularColor
{
get
{
return _specularColor;
}
set
{
if (value != _specularColor)
{
_preset = FOG_PRESET.Custom;
_specularColor = value;
currentFogSpecularColor = _specularColor;
UpdateTexture();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float specularThreshold
{
get
{
return _specularThreshold;
}
set
{
if (value != _specularThreshold)
{
_preset = FOG_PRESET.Custom;
_specularThreshold = value;
UpdateTexture();
isDirty = true;
}
}
}
public float specularIntensity
{
get
{
return _specularIntensity;
}
set
{
if (value != _specularIntensity)
{
_preset = FOG_PRESET.Custom;
_specularIntensity = value;
UpdateMaterialProperties();
UpdateTexture();
isDirty = true;
}
}
}
public Vector3 lightDirection
{
get
{
return _lightDirection;
}
set
{
if (value != _lightDirection)
{
_preset = FOG_PRESET.Custom;
_lightDirection = value;
UpdateMaterialProperties();
UpdateTexture();
isDirty = true;
}
}
}
public float lightIntensity
{
get
{
return _lightIntensity;
}
set
{
if (value != _lightIntensity)
{
_preset = FOG_PRESET.Custom;
_lightIntensity = value;
UpdateMaterialProperties();
UpdateTexture();
isDirty = true;
}
}
}
public Color lightColor
{
get
{
return _lightColor;
}
set
{
if (value != _lightColor)
{
_preset = FOG_PRESET.Custom;
_lightColor = value;
currentLightColor = _lightColor;
UpdateMaterialProperties();
UpdateTexture();
isDirty = true;
}
}
}
public int updateTextureSpread
{
get
{
return _updateTextureSpread;
}
set
{
if (value != _updateTextureSpread)
{
_updateTextureSpread = value;
isDirty = true;
}
}
}
public float speed
{
get
{
return _speed;
}
set
{
if (value != _speed)
{
_preset = FOG_PRESET.Custom;
_speed = value;
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
isDirty = true;
}
}
}
public Vector3 windDirection
{
get
{
return _windDirection;
}
set
{
if (value != _windDirection)
{
_preset = FOG_PRESET.Custom;
_windDirection = value.normalized;
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
isDirty = true;
}
}
}
public bool useRealTime
{
get
{
return _useRealTime;
}
set
{
if (value != _useRealTime)
{
_useRealTime = value;
isDirty = true;
}
}
}
public Color skyColor
{
get
{
return _skyColor;
}
set
{
if (value != _skyColor)
{
_preset = FOG_PRESET.Custom;
_skyColor = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float skyHaze
{
get
{
return _skyHaze;
}
set
{
if (value != _skyHaze)
{
_preset = FOG_PRESET.Custom;
_skyHaze = value;
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
isDirty = true;
}
}
}
public float skySpeed
{
get
{
return _skySpeed;
}
set
{
if (value != _skySpeed)
{
_preset = FOG_PRESET.Custom;
_skySpeed = value;
isDirty = true;
}
}
}
public float skyNoiseStrength
{
get
{
return _skyNoiseStrength;
}
set
{
if (value != _skyNoiseStrength)
{
_preset = FOG_PRESET.Custom;
_skyNoiseStrength = value;
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
isDirty = true;
}
}
}
public float skyAlpha
{
get
{
return _skyAlpha;
}
set
{
if (value != _skyAlpha)
{
_preset = FOG_PRESET.Custom;
_skyAlpha = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float skyDepth
{
get
{
return _skyDepth;
}
set
{
if (value != _skyDepth)
{
_skyDepth = value;
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
isDirty = true;
}
}
}
public GameObject character
{
get
{
return _character;
}
set
{
if (value != _character)
{
_character = value;
isDirty = true;
}
}
}
public FOG_VOID_TOPOLOGY fogVoidTopology
{
get
{
return _fogVoidTopology;
}
set
{
if (value != _fogVoidTopology)
{
_fogVoidTopology = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogVoidFallOff
{
get
{
return _fogVoidFallOff;
}
set
{
if (value != _fogVoidFallOff)
{
_preset = FOG_PRESET.Custom;
_fogVoidFallOff = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogVoidRadius
{
get
{
return _fogVoidRadius;
}
set
{
if (value != _fogVoidRadius)
{
_preset = FOG_PRESET.Custom;
_fogVoidRadius = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Vector3 fogVoidPosition
{
get
{
return _fogVoidPosition;
}
set
{
if (value != _fogVoidPosition)
{
_preset = FOG_PRESET.Custom;
_fogVoidPosition = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogVoidDepth
{
get
{
return _fogVoidDepth;
}
set
{
if (value != _fogVoidDepth)
{
_preset = FOG_PRESET.Custom;
_fogVoidDepth = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogVoidHeight
{
get
{
return _fogVoidHeight;
}
set
{
if (value != _fogVoidHeight)
{
_preset = FOG_PRESET.Custom;
_fogVoidHeight = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
[Obsolete("Fog Void inverted is now deprecated. Use Fog Area settings.")]
public bool fogVoidInverted
{
get
{
return _fogVoidInverted;
}
set
{
_fogVoidInverted = value;
}
}
public bool fogAreaShowGizmos
{
get
{
return _fogAreaShowGizmos;
}
set
{
if (value != _fogAreaShowGizmos)
{
_fogAreaShowGizmos = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public GameObject fogAreaCenter
{
get
{
return _fogAreaCenter;
}
set
{
if (value != _fogAreaCenter)
{
_fogAreaCenter = value;
isDirty = true;
}
}
}
public float fogAreaFallOff
{
get
{
return _fogAreaFallOff;
}
set
{
if (value != _fogAreaFallOff)
{
_fogAreaFallOff = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public FOG_AREA_FOLLOW_MODE fogAreaFollowMode
{
get
{
return _fogAreaFollowMode;
}
set
{
if (value != _fogAreaFollowMode)
{
_fogAreaFollowMode = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public FOG_AREA_TOPOLOGY fogAreaTopology
{
get
{
return _fogAreaTopology;
}
set
{
if (value != _fogAreaTopology)
{
_fogAreaTopology = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogAreaRadius
{
get
{
return _fogAreaRadius;
}
set
{
if (value != _fogAreaRadius)
{
_fogAreaRadius = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Vector3 fogAreaPosition
{
get
{
return _fogAreaPosition;
}
set
{
if (!(value != _fogAreaPosition))
{
return;
}
_fogAreaPosition = value;
if (_fogAreaCenter == null || _fogAreaFollowMode == FOG_AREA_FOLLOW_MODE.RestrictToXZPlane)
{
if (_useXYPlane)
{
_baselineHeight = _fogAreaPosition.z;
}
else
{
_baselineHeight = _fogAreaPosition.y;
}
}
UpdateMaterialProperties();
isDirty = true;
}
}
public float fogAreaDepth
{
get
{
return _fogAreaDepth;
}
set
{
if (value != _fogAreaDepth)
{
_fogAreaDepth = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogAreaHeight
{
get
{
return _fogAreaHeight;
}
set
{
if (value != _fogAreaHeight)
{
_fogAreaHeight = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public FOG_AREA_SORTING_MODE fogAreaSortingMode
{
get
{
return _fogAreaSortingMode;
}
set
{
if (value != _fogAreaSortingMode)
{
_fogAreaSortingMode = value;
lastTimeSortInstances = 0f;
isDirty = true;
}
}
}
public int fogAreaRenderOrder
{
get
{
return _fogAreaRenderOrder;
}
set
{
if (value != _fogAreaRenderOrder)
{
_fogAreaRenderOrder = value;
lastTimeSortInstances = 0f;
isDirty = true;
}
}
}
public bool pointLightTrackAuto
{
get
{
return _pointLightTrackingAuto;
}
set
{
if (value != _pointLightTrackingAuto)
{
_pointLightTrackingAuto = value;
TrackPointLights();
isDirty = true;
}
}
}
public Transform pointLightTrackingPivot
{
get
{
return _pointLightTrackingPivot;
}
set
{
if (value != _pointLightTrackingPivot)
{
_pointLightTrackingPivot = value;
TrackPointLights();
isDirty = true;
}
}
}
public int pointLightTrackingCount
{
get
{
return _pointLightTrackingCount;
}
set
{
if (value != _pointLightTrackingCount)
{
_pointLightTrackingCount = Mathf.Clamp(value, 0, 6);
CheckPointLightData();
TrackPointLights();
isDirty = true;
}
}
}
public float pointLightTrackingCheckInterval
{
get
{
return _pointLightTrackingCheckInterval;
}
set
{
if (value != _pointLightTrackingCheckInterval)
{
_pointLightTrackingCheckInterval = value;
TrackPointLights();
isDirty = true;
}
}
}
public float pointLightTrackingNewLightsCheckInterval
{
get
{
return _pointLightTrackingNewLightsCheckInterval;
}
set
{
if (value != _pointLightTrackingNewLightsCheckInterval)
{
_pointLightTrackingNewLightsCheckInterval = value;
TrackPointLights();
isDirty = true;
}
}
}
public float pointLightInscattering
{
get
{
return _pointLightInscattering;
}
set
{
if (value != _pointLightInscattering)
{
_pointLightInscattering = value;
isDirty = true;
}
}
}
public float pointLightIntensity
{
get
{
return _pointLightIntensity;
}
set
{
if (value != _pointLightIntensity)
{
_pointLightIntensity = value;
isDirty = true;
}
}
}
public float pointLightInsideAtten
{
get
{
return _pointLightInsideAtten;
}
set
{
if (value != _pointLightInsideAtten)
{
_pointLightInsideAtten = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public int downsampling
{
get
{
return _downsampling;
}
set
{
if (value != _downsampling)
{
_preset = FOG_PRESET.Custom;
_downsampling = value;
isDirty = true;
}
}
}
public bool forceComposition
{
get
{
return _forceComposition;
}
set
{
if (value != _forceComposition)
{
_preset = FOG_PRESET.Custom;
_forceComposition = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool edgeImprove
{
get
{
return _edgeImprove;
}
set
{
if (value != _edgeImprove)
{
_preset = FOG_PRESET.Custom;
_edgeImprove = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float edgeThreshold
{
get
{
return _edgeThreshold;
}
set
{
if (value != _edgeThreshold)
{
_preset = FOG_PRESET.Custom;
_edgeThreshold = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float stepping
{
get
{
return _stepping;
}
set
{
if (value != _stepping)
{
_preset = FOG_PRESET.Custom;
_stepping = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float steppingNear
{
get
{
return _steppingNear;
}
set
{
if (value != _steppingNear)
{
_preset = FOG_PRESET.Custom;
_steppingNear = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool dithering
{
get
{
return _dithering;
}
set
{
if (value != _dithering)
{
_dithering = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float ditherStrength
{
get
{
return _ditherStrength;
}
set
{
if (value != _ditherStrength)
{
_ditherStrength = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float jitterStrength
{
get
{
return _jitterStrength;
}
set
{
if (value != _jitterStrength)
{
_jitterStrength = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool lightScatteringEnabled
{
get
{
return _lightScatteringEnabled;
}
set
{
if (value != _lightScatteringEnabled)
{
_lightScatteringEnabled = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringDiffusion
{
get
{
return _lightScatteringDiffusion;
}
set
{
if (value != _lightScatteringDiffusion)
{
_lightScatteringDiffusion = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringSpread
{
get
{
return _lightScatteringSpread;
}
set
{
if (value != _lightScatteringSpread)
{
_lightScatteringSpread = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public int lightScatteringSamples
{
get
{
return _lightScatteringSamples;
}
set
{
if (value != _lightScatteringSamples)
{
_lightScatteringSamples = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringWeight
{
get
{
return _lightScatteringWeight;
}
set
{
if (value != _lightScatteringWeight)
{
_lightScatteringWeight = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringIllumination
{
get
{
return _lightScatteringIllumination;
}
set
{
if (value != _lightScatteringIllumination)
{
_lightScatteringIllumination = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringDecay
{
get
{
return _lightScatteringDecay;
}
set
{
if (value != _lightScatteringDecay)
{
_lightScatteringDecay = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringExposure
{
get
{
return _lightScatteringExposure;
}
set
{
if (value != _lightScatteringExposure)
{
_lightScatteringExposure = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float lightScatteringJittering
{
get
{
return _lightScatteringJittering;
}
set
{
if (value != _lightScatteringJittering)
{
_lightScatteringJittering = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool fogBlur
{
get
{
return _fogBlur;
}
set
{
if (value != _fogBlur)
{
_fogBlur = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogBlurDepth
{
get
{
return _fogBlurDepth;
}
set
{
if (value != _fogBlurDepth)
{
_fogBlurDepth = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool sunShadows
{
get
{
return _sunShadows;
}
set
{
if (value != _sunShadows)
{
_sunShadows = value;
CleanUpTextureDepthSun();
if (_sunShadows)
{
needUpdateDepthSunTexture = true;
}
else
{
DestroySunShadowsDependencies();
}
UpdateMaterialProperties();
isDirty = true;
}
}
}
public LayerMask sunShadowsLayerMask
{
get
{
return _sunShadowsLayerMask;
}
set
{
if ((int)_sunShadowsLayerMask != (int)value)
{
_sunShadowsLayerMask = value;
isDirty = true;
}
}
}
public float sunShadowsStrength
{
get
{
return _sunShadowsStrength;
}
set
{
if (value != _sunShadowsStrength)
{
_sunShadowsStrength = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float sunShadowsBias
{
get
{
return _sunShadowsBias;
}
set
{
if (value != _sunShadowsBias)
{
_sunShadowsBias = value;
needUpdateDepthSunTexture = true;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float sunShadowsJitterStrength
{
get
{
return _sunShadowsJitterStrength;
}
set
{
if (value != _sunShadowsJitterStrength)
{
_sunShadowsJitterStrength = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public int sunShadowsResolution
{
get
{
return _sunShadowsResolution;
}
set
{
if (value != _sunShadowsResolution)
{
_sunShadowsResolution = value;
needUpdateDepthSunTexture = true;
CleanUpTextureDepthSun();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float sunShadowsMaxDistance
{
get
{
return _sunShadowsMaxDistance;
}
set
{
if (value != _sunShadowsMaxDistance)
{
_sunShadowsMaxDistance = value;
needUpdateDepthSunTexture = true;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public SUN_SHADOWS_BAKE_MODE sunShadowsBakeMode
{
get
{
return _sunShadowsBakeMode;
}
set
{
if (value != _sunShadowsBakeMode)
{
_sunShadowsBakeMode = value;
needUpdateDepthSunTexture = true;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float sunShadowsRefreshInterval
{
get
{
return _sunShadowsRefreshInterval;
}
set
{
if (value != _sunShadowsRefreshInterval)
{
_sunShadowsRefreshInterval = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float sunShadowsCancellation
{
get
{
return _sunShadowsCancellation;
}
set
{
if (value != _sunShadowsCancellation)
{
_sunShadowsCancellation = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float turbulenceStrength
{
get
{
return _turbulenceStrength;
}
set
{
if (value != _turbulenceStrength)
{
_turbulenceStrength = value;
if (_turbulenceStrength <= 0f)
{
UpdateTexture();
}
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool useXYPlane
{
get
{
return _useXYPlane;
}
set
{
if (value != _useXYPlane)
{
_useXYPlane = value;
if (_sunShadows)
{
needUpdateDepthSunTexture = true;
}
UpdateMaterialProperties();
isDirty = true;
}
}
}
public bool useSinglePassStereoRenderingMatrix
{
get
{
return _useSinglePassStereoRenderingMatrix;
}
set
{
if (value != _useSinglePassStereoRenderingMatrix)
{
_useSinglePassStereoRenderingMatrix = value;
isDirty = true;
}
}
}
public SPSR_BEHAVIOUR spsrBehaviour
{
get
{
return _spsrBehaviour;
}
set
{
if (value != _spsrBehaviour)
{
_spsrBehaviour = value;
isDirty = true;
}
}
}
public bool reduceFlickerBigWorlds
{
get
{
return _reduceFlickerBigWorlds;
}
set
{
if (value != _reduceFlickerBigWorlds)
{
_reduceFlickerBigWorlds = value;
isDirty = true;
}
}
}
public bool enableMask
{
get
{
return _enableMask;
}
set
{
if (value != _enableMask)
{
_enableMask = value;
UpdateVolumeMask();
isDirty = true;
}
}
}
public LayerMask maskLayer
{
get
{
return _maskLayer;
}
set
{
if ((int)value != (int)_maskLayer)
{
_maskLayer = value;
UpdateVolumeMask();
isDirty = true;
}
}
}
public int maskDownsampling
{
get
{
return _maskDownsampling;
}
set
{
if (value != _maskDownsampling)
{
_maskDownsampling = value;
UpdateVolumeMask();
isDirty = true;
}
}
}
public Camera fogCamera
{
get
{
return mainCamera;
}
}
public int renderingInstancesCount
{
get
{
return _renderingInstancesCount;
}
}
public bool hasCamera
{
get
{
if (!_hasCameraChecked)
{
_hasCamera = GetComponent<Camera>() != null;
_hasCameraChecked = true;
}
return _hasCamera;
}
}
public bool fogOfWarEnabled
{
get
{
return _fogOfWarEnabled;
}
set
{
if (value != _fogOfWarEnabled)
{
_fogOfWarEnabled = value;
FogOfWarUpdateTexture();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Vector3 fogOfWarCenter
{
get
{
return _fogOfWarCenter;
}
set
{
if (value != _fogOfWarCenter)
{
_fogOfWarCenter = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public Vector3 fogOfWarSize
{
get
{
return _fogOfWarSize;
}
set
{
if (value != _fogOfWarSize && value.x > 0f && value.z > 0f)
{
_fogOfWarSize = value;
UpdateMaterialProperties();
isDirty = true;
}
}
}
public int fogOfWarTextureSize
{
get
{
return _fogOfWarTextureSize;
}
set
{
if (value != _fogOfWarTextureSize && value > 16)
{
_fogOfWarTextureSize = value;
FogOfWarUpdateTexture();
UpdateMaterialProperties();
isDirty = true;
}
}
}
public float fogOfWarRestoreDelay
{
get
{
return _fogOfWarRestoreDelay;
}
set
{
if (value != _fogOfWarRestoreDelay)
{
_fogOfWarRestoreDelay = value;
isDirty = true;
}
}
}
public float fogOfWarRestoreDuration
{
get
{
return _fogOfWarRestoreDuration;
}
set
{
if (value != _fogOfWarRestoreDuration)
{
_fogOfWarRestoreDuration = value;
isDirty = true;
}
}
}
public Color32[] fogOfWarTextureData
{
get
{
return fogOfWarColorBuffer;
}
set
{
fogOfWarEnabled = true;
fogOfWarColorBuffer = value;
if (value != null && !(fogOfWarTexture == null) && value.Length == fogOfWarTexture.width * fogOfWarTexture.height)
{
fogOfWarTexture.SetPixels32(fogOfWarColorBuffer);
fogOfWarTexture.Apply();
}
}
}
private void OnEnable()
{
isPartOfScene = isPartOfScene || IsPartOfScene();
if (!isPartOfScene)
{
return;
}
if (_fogVoidInverted)
{
_fogVoidInverted = false;
_fogAreaCenter = _character;
_fogAreaDepth = _fogVoidDepth;
_fogAreaFallOff = _fogVoidFallOff;
_fogAreaHeight = _fogVoidHeight;
_fogAreaPosition = _fogVoidPosition;
_fogAreaRadius = _fogVoidRadius;
_fogVoidRadius = 0f;
_character = null;
}
mainCamera = base.gameObject.GetComponent<Camera>();
_hasCamera = mainCamera != null;
_hasCameraChecked = true;
if (_hasCamera)
{
fogRenderer = this;
if (mainCamera.depthTextureMode == DepthTextureMode.None)
{
mainCamera.depthTextureMode = DepthTextureMode.Depth;
}
UpdateVolumeMask();
}
else if (fogRenderer == null)
{
mainCamera = Camera.main;
if (mainCamera == null)
{
mainCamera = UnityEngine.Object.FindObjectOfType<Camera>();
}
if (mainCamera == null)
{
Debug.LogError("Volumetric Fog: no camera found!");
return;
}
fogRenderer = mainCamera.GetComponent<VolumetricFog>();
if (fogRenderer == null)
{
fogRenderer = mainCamera.gameObject.AddComponent<VolumetricFog>();
fogRenderer.density = 0f;
}
}
else
{
mainCamera = fogRenderer.mainCamera;
if (mainCamera == null)
{
mainCamera = fogRenderer.GetComponent<Camera>();
}
}
if (fogMat == null)
{
InitFogMaterial();
if (_profile != null && _profileSync)
{
_profile.Load(this);
}
}
else
{
UpdateMaterialPropertiesNow();
}
RegisterWithRenderers();
}
private void OnDisable()
{
RemoveMaskCommandBuffer();
}
private void OnDestroy()
{
if (!_hasCamera)
{
UnregisterWithRenderers();
}
else
{
RemoveMaskCommandBuffer();
UnregisterFogArea(this);
}
if (depthCamObj != null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
}
if (adjustedTexture != null)
{
UnityEngine.Object.DestroyImmediate(adjustedTexture);
adjustedTexture = null;
}
if (chaosLerpMat != null)
{
UnityEngine.Object.DestroyImmediate(chaosLerpMat);
chaosLerpMat = null;
}
if (adjustedChaosTexture != null)
{
UnityEngine.Object.DestroyImmediate(adjustedChaosTexture);
adjustedChaosTexture = null;
}
if (blurMat != null)
{
UnityEngine.Object.DestroyImmediate(blurMat);
blurMat = null;
}
if (fogMat != null)
{
UnityEngine.Object.DestroyImmediate(fogMat);
fogMat = null;
}
CleanUpDepthTexture();
DestroySunShadowsDependencies();
}
public void DestroySelf()
{
DestroyRenderComponent<VolumetricFogPreT>();
DestroyRenderComponent<VolumetricFogPosT>();
UnityEngine.Object.DestroyImmediate(this);
}
private void Start()
{
currentFogAlpha = _alpha;
currentSkyHazeAlpha = _skyAlpha;
lastTextureUpdate = Time.time + _timeBetweenTextureUpdates;
RegisterWithRenderers();
Update();
}
private void Update()
{
if (!isPartOfScene)
{
return;
}
if (fogRenderer.sun != null)
{
Vector3 forward = fogRenderer.sun.transform.forward;
if (!Application.isPlaying || (updatingTextureSlice < 0 && Time.time - lastTextureUpdate >= _timeBetweenTextureUpdates))
{
if (forward != _lightDirection)
{
_lightDirection = forward;
needUpdateTexture = true;
needUpdateDepthSunTexture = true;
}
if (sunLight != null)
{
if (_sunCopyColor && sunLight.color != _lightColor)
{
_lightColor = sunLight.color;
currentLightColor = _lightColor;
needUpdateTexture = true;
}
if (sunLightIntensity != sunLight.intensity)
{
sunLightIntensity = sunLight.intensity;
needUpdateTexture = true;
}
}
}
}
if (!needUpdateTexture)
{
if (_lightingModel == LIGHTING_MODEL.Classic)
{
if (lastRenderSettingsAmbientIntensity != RenderSettings.ambientIntensity)
{
needUpdateTexture = true;
}
else if (lastRenderSettingsAmbientLight != RenderSettings.ambientLight)
{
needUpdateTexture = true;
}
}
else if (_lightingModel == LIGHTING_MODEL.Natural && lastRenderSettingsAmbientLight != RenderSettings.ambientLight)
{
needUpdateTexture = true;
}
}
if (transitionProfile)
{
float num = (Time.time - transitionStartTime) / transitionDuration;
if (num > 1f)
{
num = 1f;
}
VolumetricFogProfile.Lerp(initialProfile, targetProfile, num, this);
if (num >= 1f)
{
transitionProfile = false;
}
}
if (transitionAlpha)
{
if (targetFogAlpha >= 0f || targetSkyHazeAlpha >= 0f)
{
if (targetFogAlpha != currentFogAlpha || targetSkyHazeAlpha != currentSkyHazeAlpha)
{
if (transitionDuration > 0f)
{
currentFogAlpha = Mathf.Lerp(initialFogAlpha, targetFogAlpha, (Time.time - transitionStartTime) / transitionDuration);
currentSkyHazeAlpha = Mathf.Lerp(initialSkyHazeAlpha, targetSkyHazeAlpha, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogAlpha = targetFogAlpha;
currentSkyHazeAlpha = targetSkyHazeAlpha;
transitionAlpha = false;
}
fogMat.SetFloat("_FogAlpha", currentFogAlpha);
UpdateSkyColor(currentSkyHazeAlpha);
}
}
else if (currentFogAlpha != _alpha || currentSkyHazeAlpha != _skyAlpha)
{
if (transitionDuration > 0f)
{
currentFogAlpha = Mathf.Lerp(initialFogAlpha, _alpha, (Time.time - transitionStartTime) / transitionDuration);
currentSkyHazeAlpha = Mathf.Lerp(initialSkyHazeAlpha, alpha, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogAlpha = _alpha;
currentSkyHazeAlpha = _skyAlpha;
transitionAlpha = false;
}
fogMat.SetFloat("_FogAlpha", currentFogAlpha);
UpdateSkyColor(currentSkyHazeAlpha);
}
}
if (transitionColor)
{
if (targetColorActive)
{
if (targetFogColor != currentFogColor)
{
if (transitionDuration > 0f)
{
currentFogColor = Color.Lerp(initialFogColor, targetFogColor, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogColor = targetFogColor;
transitionColor = false;
}
}
}
else if (currentFogColor != _color)
{
if (transitionDuration > 0f)
{
currentFogColor = Color.Lerp(initialFogColor, _color, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogColor = _color;
transitionColor = false;
}
}
UpdateMaterialFogColor();
}
if (transitionSpecularColor)
{
if (targetSpecularColorActive)
{
if (targetFogSpecularColor != currentFogSpecularColor)
{
if (transitionDuration > 0f)
{
currentFogSpecularColor = Color.Lerp(initialFogSpecularColor, targetFogSpecularColor, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogSpecularColor = targetFogSpecularColor;
transitionSpecularColor = false;
}
needUpdateTexture = true;
}
}
else if (currentFogSpecularColor != _specularColor)
{
if (transitionDuration > 0f)
{
currentFogSpecularColor = Color.Lerp(initialFogSpecularColor, _specularColor, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentFogSpecularColor = _specularColor;
transitionSpecularColor = false;
}
needUpdateTexture = true;
}
}
if (transitionLightColor)
{
if (targetLightColorActive)
{
if (targetLightColor != currentLightColor)
{
if (transitionDuration > 0f)
{
currentLightColor = Color.Lerp(initialLightColor, targetLightColor, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentLightColor = targetLightColor;
transitionLightColor = false;
}
needUpdateTexture = true;
}
}
else if (currentLightColor != _lightColor)
{
if (transitionDuration > 0f)
{
currentLightColor = Color.Lerp(initialLightColor, _lightColor, (Time.time - transitionStartTime) / transitionDuration);
}
else
{
currentLightColor = _lightColor;
transitionLightColor = false;
}
needUpdateTexture = true;
}
}
if (_baselineRelativeToCamera)
{
UpdateMaterialHeights();
}
else if (_character != null)
{
_fogVoidPosition = _character.transform.position;
UpdateMaterialHeights();
}
if (_fogAreaCenter != null)
{
if (_fogAreaFollowMode == FOG_AREA_FOLLOW_MODE.FullXYZ)
{
_fogAreaPosition = _fogAreaCenter.transform.position;
}
else
{
_fogAreaPosition.x = _fogAreaCenter.transform.position.x;
_fogAreaPosition.z = _fogAreaCenter.transform.position.z;
}
UpdateMaterialHeights();
}
if (_pointLightTrackingAuto && (!Application.isPlaying || Time.time - trackPointAutoLastTime > _pointLightTrackingCheckInterval))
{
trackPointAutoLastTime = Time.time;
TrackPointLights();
}
if (updatingTextureSlice >= 0)
{
UpdateTextureColors(adjustedColors, false);
}
else if (needUpdateTexture)
{
UpdateTexture();
}
if (!_hasCamera)
{
return;
}
if (_fogOfWarEnabled)
{
FogOfWarUpdate();
}
if (_sunShadows && (bool)fogRenderer.sun)
{
CastSunShadows();
}
int count = fogInstances.Count;
if (count <= 1)
{
return;
}
Vector3 position = mainCamera.transform.position;
bool flag = !Application.isPlaying || Time.time - lastTimeSortInstances >= 2f;
if (!flag)
{
float num2 = (position.x - lastCamPos.x) * (position.x - lastCamPos.x) + (position.y - lastCamPos.y) * (position.y - lastCamPos.y) + (position.z - lastCamPos.z) * (position.z - lastCamPos.z);
if (num2 > 625f)
{
lastCamPos = position;
flag = true;
}
}
if (!flag)
{
return;
}
lastTimeSortInstances = Time.time;
float x = position.x;
float y = position.y;
float z = position.z;
for (int i = 0; i < count; i++)
{
VolumetricFog volumetricFog = fogInstances[i];
if (volumetricFog != null)
{
Vector3 position2 = volumetricFog.transform.position;
position2.y = volumetricFog.currentFogAltitude;
float num3 = x - position2.x;
float num4 = y - position2.y;
float num5 = num4 * num4;
float num6 = y - (position2.y + volumetricFog.height);
float num7 = num6 * num6;
volumetricFog.distanceToCameraYAxis = ((!(num5 < num7)) ? num7 : num5);
float num8 = z - position2.z;
float num9 = num3 * num3 + num4 * num4 + num8 * num8;
volumetricFog.distanceToCamera = num9;
Vector3 position3 = position2 - volumetricFog.transform.localScale * 0.5f;
Vector3 position4 = position2 + volumetricFog.transform.localScale * 0.5f;
volumetricFog.distanceToCameraMin = mainCamera.WorldToScreenPoint(position3).z;
volumetricFog.distanceToCameraMax = mainCamera.WorldToScreenPoint(position4).z;
}
}
fogInstances.Sort(delegate(VolumetricFog volumetricFog2, VolumetricFog volumetricFog3)
{
if (!volumetricFog2 || !volumetricFog3)
{
return 0;
}
if (volumetricFog2.fogAreaSortingMode == FOG_AREA_SORTING_MODE.Fixed || volumetricFog3.fogAreaSortingMode == FOG_AREA_SORTING_MODE.Fixed)
{
if (volumetricFog2.fogAreaRenderOrder < volumetricFog3.fogAreaRenderOrder)
{
return -1;
}
if (volumetricFog2.fogAreaRenderOrder > volumetricFog3.fogAreaRenderOrder)
{
return 1;
}
return 0;
}
if ((volumetricFog2.distanceToCameraMin < volumetricFog3.distanceToCameraMin && volumetricFog2.distanceToCameraMax > volumetricFog3.distanceToCameraMax) || (volumetricFog3.distanceToCameraMin < volumetricFog2.distanceToCameraMin && volumetricFog3.distanceToCameraMax > volumetricFog2.distanceToCameraMax) || volumetricFog2.fogAreaSortingMode == FOG_AREA_SORTING_MODE.Altitude || volumetricFog3.fogAreaSortingMode == FOG_AREA_SORTING_MODE.Altitude)
{
if (volumetricFog2.distanceToCameraYAxis < volumetricFog3.distanceToCameraYAxis)
{
return 1;
}
if (volumetricFog2.distanceToCameraYAxis > volumetricFog3.distanceToCameraYAxis)
{
return -1;
}
return 0;
}
if (volumetricFog2.distanceToCamera < volumetricFog3.distanceToCamera)
{
return 1;
}
return (volumetricFog2.distanceToCamera > volumetricFog3.distanceToCamera) ? (-1) : 0;
});
}
private void OnPreCull()
{
if (!base.enabled || !base.gameObject.activeSelf || fogMat == null || !_hasCamera || mainCamera == null)
{
return;
}
if (mainCamera.depthTextureMode == DepthTextureMode.None)
{
mainCamera.depthTextureMode = DepthTextureMode.Depth;
}
if (_computeDepth)
{
GetTransparentDepth();
}
if (!_hasCamera)
{
return;
}
int count = fogRenderInstances.Count;
for (int i = 0; i < count; i++)
{
if (fogRenderInstances[i] != null && fogRenderInstances[i].turbulenceStrength > 0f)
{
fogRenderInstances[i].ApplyChaos();
}
}
}
private void OnDidApplyAnimationProperties()
{
shouldUpdateMaterialProperties = true;
}
private bool IsPartOfScene()
{
VolumetricFog[] array = UnityEngine.Object.FindObjectsOfType<VolumetricFog>();
for (int i = 0; i < array.Length; i++)
{
if (array[i] == this)
{
return true;
}
}
return false;
}
private void InitFogMaterial()
{
targetFogAlpha = -1f;
targetSkyHazeAlpha = -1f;
_skyColor.a = _skyAlpha;
updatingTextureSlice = -1;
fogMat = new Material(Shader.Find("VolumetricFogAndMist/VolumetricFog"));
fogMat.hideFlags = HideFlags.DontSave;
Texture2D texture2D = Resources.Load<Texture2D>("Textures/Noise3");
noiseColors = texture2D.GetPixels();
adjustedColors = new Color[noiseColors.Length];
adjustedTexture = new Texture2D(texture2D.width, texture2D.height, TextureFormat.RGBA32, false);
adjustedTexture.hideFlags = HideFlags.DontSave;
timeOfLastRender = Time.time;
CheckPointLightData();
if (_pointLightTrackingAuto)
{
TrackPointLights();
}
FogOfWarInit();
if (fogOfWarTexture == null)
{
FogOfWarUpdateTexture();
}
CopyTransitionValues();
UpdatePreset();
oldBaselineRelativeCameraY = mainCamera.transform.position.y;
if (_sunShadows)
{
needUpdateDepthSunTexture = true;
}
}
private void UpdateRenderComponents()
{
if (_hasCamera)
{
if (_renderBeforeTransparent)
{
AssignRenderComponent<VolumetricFogPreT>();
DestroyRenderComponent<VolumetricFogPosT>();
}
else if (_transparencyBlendMode == TRANSPARENT_MODE.Blend)
{
AssignRenderComponent<VolumetricFogPreT>();
AssignRenderComponent<VolumetricFogPosT>();
}
else
{
AssignRenderComponent<VolumetricFogPosT>();
DestroyRenderComponent<VolumetricFogPreT>();
}
}
}
private void DestroyRenderComponent<T>() where T : IVolumetricFogRenderComponent
{
T[] componentsInChildren = GetComponentsInChildren<T>(true);
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (componentsInChildren[i].fog == this || componentsInChildren[i].fog == null)
{
componentsInChildren[i].DestroySelf();
}
}
}
private void AssignRenderComponent<T>() where T : Component, IVolumetricFogRenderComponent
{
T[] componentsInChildren = GetComponentsInChildren<T>(true);
int num = -1;
for (int i = 0; i < componentsInChildren.Length; i++)
{
if (componentsInChildren[i].fog == this)
{
return;
}
if (componentsInChildren[i].fog == null)
{
num = i;
}
}
if (num < 0)
{
T val = base.gameObject.AddComponent<T>();
val.fog = this;
}
else
{
componentsInChildren[num].fog = this;
}
}
private void RegisterFogArea(VolumetricFog fog)
{
if (!fogInstances.Contains(fog))
{
fogInstances.Add(fog);
}
}
private void UnregisterFogArea(VolumetricFog fog)
{
if (fogInstances.Contains(fog))
{
fogInstances.Remove(fog);
}
}
private void RegisterWithRenderers()
{
allFogRenderers = UnityEngine.Object.FindObjectsOfType<VolumetricFog>();
if (!_hasCamera && fogRenderer != null)
{
if (fogRenderer.enableMultipleCameras)
{
for (int i = 0; i < allFogRenderers.Length; i++)
{
if (allFogRenderers[i].hasCamera)
{
allFogRenderers[i].RegisterFogArea(this);
}
}
}
else
{
fogRenderer.RegisterFogArea(this);
}
}
else
{
fogInstances.Clear();
RegisterFogArea(this);
for (int j = 0; j < allFogRenderers.Length; j++)
{
if (!allFogRenderers[j].hasCamera && (_enableMultipleCameras || allFogRenderers[j].fogRenderer == this))
{
RegisterFogArea(allFogRenderers[j]);
}
}
}
lastTimeSortInstances = 0f;
}
private void UnregisterWithRenderers()
{
if (allFogRenderers == null)
{
return;
}
for (int i = 0; i < allFogRenderers.Length; i++)
{
if (allFogRenderers[i] != null && allFogRenderers[i].hasCamera)
{
allFogRenderers[i].UnregisterFogArea(this);
}
}
}
public void UpdateMultiCameraSetup()
{
allFogRenderers = UnityEngine.Object.FindObjectsOfType<VolumetricFog>();
for (int i = 0; i < allFogRenderers.Length; i++)
{
if (allFogRenderers[i] != null && allFogRenderers[i].hasCamera)
{
allFogRenderers[i].SetEnableMultipleCameras(_enableMultipleCameras);
}
}
RegisterWithRenderers();
}
private void SetEnableMultipleCameras(bool state)
{
_enableMultipleCameras = state;
RegisterWithRenderers();
}
internal void DoOnRenderImage(RenderTexture source, RenderTexture destination)
{
int count = fogInstances.Count;
fogRenderInstances.Clear();
for (int i = 0; i < count; i++)
{
if (fogInstances[i] != null && fogInstances[i].isActiveAndEnabled && fogInstances[i].density > 0f)
{
fogRenderInstances.Add(fogInstances[i]);
}
}
_renderingInstancesCount = fogRenderInstances.Count;
if (_renderingInstancesCount == 0 || mainCamera == null)
{
Graphics.Blit(source, destination);
return;
}
if (_hasCamera && _density <= 0f && shouldUpdateMaterialProperties)
{
UpdateMaterialPropertiesNow();
}
if (_renderingInstancesCount == 1)
{
fogRenderInstances[0].DoOnRenderImageInstance(mainCamera, source, destination);
return;
}
RenderTextureDescriptor descriptor = source.descriptor;
descriptor.depthBufferBits = 0;
descriptor.msaaSamples = 1;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
fogRenderInstances[0].DoOnRenderImageInstance(mainCamera, source, temporary);
if (_renderingInstancesCount == 2)
{
fogRenderInstances[1].DoOnRenderImageInstance(mainCamera, temporary, destination);
}
if (_renderingInstancesCount >= 3)
{
RenderTexture temporary2 = RenderTexture.GetTemporary(descriptor);
RenderTexture source2 = temporary;
RenderTexture renderTexture = temporary2;
int num = _renderingInstancesCount - 1;
for (int j = 1; j < num; j++)
{
if (j > 1)
{
renderTexture.DiscardContents();
}
fogRenderInstances[j].DoOnRenderImageInstance(mainCamera, source2, renderTexture);
if (renderTexture == temporary2)
{
source2 = temporary2;
renderTexture = temporary;
}
else
{
source2 = temporary;
renderTexture = temporary2;
}
}
fogRenderInstances[num].DoOnRenderImageInstance(mainCamera, source2, destination);
RenderTexture.ReleaseTemporary(temporary2);
}
RenderTexture.ReleaseTemporary(temporary);
}
internal void DoOnRenderImageInstance(Camera mainCamera, RenderTexture source, RenderTexture destination)
{
if (mainCamera == null || fogMat == null)
{
Graphics.Blit(source, destination);
return;
}
if (!_hasCamera)
{
CheckFogAreaDimensions();
if (_sunShadows && !fogRenderer.sunShadows)
{
fogRenderer.sunShadows = true;
}
}
if (shouldUpdateMaterialProperties)
{
UpdateMaterialPropertiesNow();
}
if (lastFrameCount != Time.frameCount && Application.isPlaying)
{
if (_useRealTime)
{
deltaTime = Time.time - timeOfLastRender;
timeOfLastRender = Time.time;
}
else
{
deltaTime = Time.deltaTime;
}
UpdateWindSpeedQuick();
}
if (_hasCamera)
{
if (_spsrBehaviour == SPSR_BEHAVIOUR.ForcedOn && !_useSinglePassStereoRenderingMatrix)
{
useSinglePassStereoRenderingMatrix = true;
}
else if (_spsrBehaviour == SPSR_BEHAVIOUR.ForcedOff && _useSinglePassStereoRenderingMatrix)
{
useSinglePassStereoRenderingMatrix = false;
}
}
bool flag = XRSettings.enabled;
Vector3 position = mainCamera.transform.position;
bool flag2 = fogRenderer.reduceFlickerBigWorlds;
if (flag2)
{
fogMat.SetVector("_FlickerFreeCamPos", position);
mainCamera.transform.position = Vector3.zero;
if (flag)
{
mainCamera.ResetWorldToCameraMatrix();
}
}
else
{
fogMat.SetVector("_FlickerFreeCamPos", Vector3.zero);
}
if (mainCamera.orthographic)
{
fogMat.SetVector("_ClipDir", mainCamera.transform.forward);
}
if (flag && fogRenderer.useSinglePassStereoRenderingMatrix)
{
fogMat.SetMatrix("_ClipToWorld", mainCamera.cameraToWorldMatrix);
}
else
{
fogMat.SetMatrix("_ClipToWorld", mainCamera.cameraToWorldMatrix * mainCamera.projectionMatrix.inverse);
}
if (flag2)
{
mainCamera.transform.position = position;
}
if (lastFrameCount != Time.frameCount || !Application.isPlaying)
{
if ((bool)fogRenderer.sun && _lightScatteringEnabled)
{
UpdateScatteringData();
}
if (pointLightParams.Length != 6)
{
CheckPointLightData();
}
for (int i = 0; i < pointLightParams.Length; i++)
{
Light light = pointLightParams[i].light;
if (light != null)
{
if (pointLightParams[i].color != light.color)
{
pointLightParams[i].color = light.color;
isDirty = true;
}
if (pointLightParams[i].range != light.range)
{
pointLightParams[i].range = light.range;
isDirty = true;
}
if (pointLightParams[i].position != light.transform.position)
{
pointLightParams[i].position = light.transform.position;
isDirty = true;
}
if (pointLightParams[i].intensity != light.intensity)
{
pointLightParams[i].intensity = light.intensity;
isDirty = true;
}
}
}
SetPointLightMaterialProperties();
}
if ((float)_downsampling > 1f || _forceComposition)
{
int scaledSize = GetScaledSize(source.width, _downsampling);
int scaledSize2 = GetScaledSize(source.width, _downsampling);
RenderTextureDescriptor descriptor = source.descriptor;
descriptor.width = scaledSize;
descriptor.height = scaledSize2;
descriptor.msaaSamples = 1;
reducedDestination = RenderTexture.GetTemporary(descriptor);
RenderTextureDescriptor descriptor2 = source.descriptor;
descriptor2.width = scaledSize;
descriptor2.height = scaledSize2;
descriptor2.msaaSamples = 1;
RenderTextureFormat colorFormat = ((!SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.RFloat)) ? RenderTextureFormat.ARGBFloat : RenderTextureFormat.RFloat);
descriptor.colorFormat = colorFormat;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
if (_fogBlur)
{
SetBlurTexture(source, descriptor);
}
if (!_edgeImprove || flag || SystemInfo.supportedRenderTargetCount < 2)
{
Graphics.Blit(source, reducedDestination, fogMat, 3);
if (_edgeImprove)
{
Graphics.Blit(source, temporary, fogMat, 4);
fogMat.SetTexture("_DownsampledDepth", temporary);
}
else
{
fogMat.SetTexture("_DownsampledDepth", null);
}
}
else
{
fogMat.SetTexture("_MainTex", source);
if (mrt == null)
{
mrt = new RenderBuffer[2];
}
mrt[0] = reducedDestination.colorBuffer;
mrt[1] = temporary.colorBuffer;
Graphics.SetRenderTarget(mrt, reducedDestination.depthBuffer);
Graphics.Blit(null, fogMat, 1);
fogMat.SetTexture("_DownsampledDepth", temporary);
}
fogMat.SetTexture("_FogDownsampled", reducedDestination);
Graphics.Blit(source, destination, fogMat, 2);
RenderTexture.ReleaseTemporary(temporary);
RenderTexture.ReleaseTemporary(reducedDestination);
}
else
{
if (_fogBlur)
{
RenderTextureDescriptor descriptor3 = source.descriptor;
descriptor3.width = 256;
descriptor3.height = 256;
SetBlurTexture(source, descriptor3);
}
Graphics.Blit(source, destination, fogMat, 0);
}
if (flag2 && flag)
{
mainCamera.ResetWorldToCameraMatrix();
}
lastFrameCount = Time.frameCount;
}
private int GetScaledSize(int size, float factor)
{
size = (int)((float)size / factor);
size /= 4;
if (size < 1)
{
size = 1;
}
return size * 4;
}
private void CleanUpDepthTexture()
{
if ((bool)depthTexture)
{
RenderTexture.ReleaseTemporary(depthTexture);
depthTexture = null;
}
}
private void GetTransparentDepth()
{
CleanUpDepthTexture();
if (depthCam == null)
{
if (depthCamObj == null)
{
depthCamObj = GameObject.Find("VFMDepthCamera");
}
if (depthCamObj == null)
{
depthCamObj = new GameObject("VFMDepthCamera");
depthCam = depthCamObj.AddComponent<Camera>();
depthCam.enabled = false;
depthCamObj.hideFlags = HideFlags.HideAndDontSave;
}
else
{
depthCam = depthCamObj.GetComponent<Camera>();
if (depthCam == null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
return;
}
}
}
depthCam.CopyFrom(mainCamera);
depthCam.depthTextureMode = DepthTextureMode.None;
depthTexture = RenderTexture.GetTemporary(mainCamera.pixelWidth, mainCamera.pixelHeight, 24, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear);
depthCam.backgroundColor = new Color(0f, 0f, 0f, 0f);
depthCam.clearFlags = CameraClearFlags.Color;
depthCam.cullingMask = _transparencyLayerMask;
depthCam.targetTexture = depthTexture;
depthCam.renderingPath = RenderingPath.Forward;
if (depthShader == null)
{
depthShader = Shader.Find("VolumetricFogAndMist/CopyDepth");
}
if (depthShaderAndTrans == null)
{
depthShaderAndTrans = Shader.Find("VolumetricFogAndMist/CopyDepthAndTrans");
}
switch (_computeDepthScope)
{
case COMPUTE_DEPTH_SCOPE.OnlyTreeBillboards:
depthCam.RenderWithShader(depthShader, "RenderType");
break;
case COMPUTE_DEPTH_SCOPE.TreeBillboardsAndTransparentObjects:
depthCam.RenderWithShader(depthShaderAndTrans, "RenderType");
break;
default:
depthCam.RenderWithShader(depthShaderAndTrans, null);
break;
}
Shader.SetGlobalTexture("_VolumetricFogDepthTexture", depthTexture);
}
private void CastSunShadows()
{
if (base.enabled && base.gameObject.activeSelf && !(fogMat == null))
{
if (_sunShadowsBakeMode == SUN_SHADOWS_BAKE_MODE.Discrete && _sunShadowsRefreshInterval > 0f && Time.time > lastShadowUpdateFrame + _sunShadowsRefreshInterval)
{
needUpdateDepthSunTexture = true;
}
if (!Application.isPlaying || needUpdateDepthSunTexture || depthSunTexture == null || !depthSunTexture.IsCreated())
{
needUpdateDepthSunTexture = false;
lastShadowUpdateFrame = Time.time;
GetSunShadows();
}
}
}
private void GetSunShadows()
{
if (_sun == null || !_sunShadows)
{
return;
}
if (depthSunCam == null)
{
if (depthSunCamObj == null)
{
depthSunCamObj = GameObject.Find("VFMDepthSunCamera");
}
if (depthSunCamObj == null)
{
depthSunCamObj = new GameObject("VFMDepthSunCamera");
depthSunCamObj.hideFlags = HideFlags.HideAndDontSave;
depthSunCam = depthSunCamObj.AddComponent<Camera>();
}
else
{
depthSunCam = depthSunCamObj.GetComponent<Camera>();
if (depthSunCam == null)
{
UnityEngine.Object.DestroyImmediate(depthSunCamObj);
depthSunCamObj = null;
return;
}
}
if (depthSunShader == null)
{
depthSunShader = Shader.Find("VolumetricFogAndMist/CopySunDepth");
}
depthSunCam.SetReplacementShader(depthSunShader, "RenderType");
depthSunCam.nearClipPlane = 1f;
depthSunCam.renderingPath = RenderingPath.Forward;
depthSunCam.orthographic = true;
depthSunCam.aspect = 1f;
depthSunCam.backgroundColor = new Color(0f, 0f, 0.5f, 0f);
depthSunCam.clearFlags = CameraClearFlags.Color;
depthSunCam.depthTextureMode = DepthTextureMode.None;
}
float orthographicSize = _sunShadowsMaxDistance / 0.95f;
depthSunCam.transform.position = mainCamera.transform.position - _sun.transform.forward * 2000f;
depthSunCam.transform.rotation = _sun.transform.rotation;
depthSunCam.farClipPlane = 4000f;
depthSunCam.orthographicSize = orthographicSize;
if (sunLight != null)
{
depthSunCam.cullingMask = _sunShadowsLayerMask;
}
if (depthSunTexture == null)
{
int width = (int)Mathf.Pow(2f, _sunShadowsResolution + 9);
depthSunTexture = new RenderTexture(width, width, 24, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
depthSunTexture.hideFlags = HideFlags.DontSave;
depthSunTexture.filterMode = FilterMode.Point;
depthSunTexture.wrapMode = TextureWrapMode.Clamp;
depthSunTexture.Create();
}
depthSunCam.targetTexture = depthSunTexture;
Shader.SetGlobalFloat("_VF_ShadowBias", _sunShadowsBias);
if (Application.isPlaying && _sunShadowsBakeMode == SUN_SHADOWS_BAKE_MODE.Realtime)
{
if (!depthSunCam.enabled)
{
depthSunCam.enabled = true;
}
}
else
{
if (depthSunCam.enabled)
{
depthSunCam.enabled = false;
}
depthSunCam.Render();
}
Shader.SetGlobalMatrix("_VolumetricFogSunProj", depthSunCam.projectionMatrix * depthSunCam.worldToCameraMatrix);
Shader.SetGlobalTexture("_VolumetricFogSunDepthTexture", depthSunTexture);
Vector4 value = depthSunCam.transform.position;
value.w = Mathf.Min(_sunShadowsMaxDistance, _maxFogLength);
Shader.SetGlobalVector("_VolumetricFogSunWorldPos", value);
UpdateSunShadowsData();
}
private void SetBlurTexture(RenderTexture source, RenderTextureDescriptor desc)
{
if (blurMat == null)
{
Shader shader = Shader.Find("VolumetricFogAndMist/Blur");
blurMat = new Material(shader);
blurMat.hideFlags = HideFlags.DontSave;
}
if (!(blurMat == null))
{
blurMat.SetFloat("_BlurDepth", _fogBlurDepth);
RenderTexture temporary = RenderTexture.GetTemporary(desc);
Graphics.Blit(source, temporary, blurMat, 0);
RenderTexture temporary2 = RenderTexture.GetTemporary(desc);
Graphics.Blit(temporary, temporary2, blurMat, 1);
blurMat.SetFloat("_BlurDepth", _fogBlurDepth * 2f);
temporary.DiscardContents();
Graphics.Blit(temporary2, temporary, blurMat, 0);
temporary2.DiscardContents();
Graphics.Blit(temporary, temporary2, blurMat, 1);
fogMat.SetTexture("_BlurTex", temporary2);
RenderTexture.ReleaseTemporary(temporary2);
RenderTexture.ReleaseTemporary(temporary);
}
}
private void DestroySunShadowsDependencies()
{
if (depthSunCamObj != null)
{
UnityEngine.Object.DestroyImmediate(depthSunCamObj);
depthSunCamObj = null;
}
CleanUpTextureDepthSun();
}
private void CleanUpTextureDepthSun()
{
if (depthSunTexture != null)
{
depthSunTexture.Release();
depthSunTexture = null;
}
}
public string GetCurrentPresetName()
{
return Enum.GetName(typeof(FOG_PRESET), _preset);
}
public void UpdatePreset()
{
switch (_preset)
{
case FOG_PRESET.Clear:
_density = 0f;
_fogOfWarEnabled = false;
_fogVoidRadius = 0f;
break;
case FOG_PRESET.Mist:
_skySpeed = 0.3f;
_skyHaze = 15f;
_skyNoiseStrength = 0.1f;
_skyAlpha = 0.8f;
_density = 0.3f;
_noiseStrength = 0.6f;
_noiseScale = 1f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 6f;
_stepping = 8f;
_steppingNear = 0f;
_alpha = 1f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.1f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0.12f;
_speed = 0.01f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.WindyMist:
_skySpeed = 0.3f;
_skyHaze = 25f;
_skyNoiseStrength = 0.1f;
_skyAlpha = 0.85f;
_density = 0.3f;
_noiseStrength = 0.5f;
_noiseScale = 1.15f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 6.5f;
_stepping = 10f;
_steppingNear = 0f;
_alpha = 1f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.1f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0f;
_speed = 0.15f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.GroundFog:
_skySpeed = 0.3f;
_skyHaze = 0f;
_skyNoiseStrength = 0.1f;
_skyAlpha = 0.85f;
_density = 0.6f;
_noiseStrength = 0.479f;
_noiseScale = 1.15f;
_noiseSparse = 0f;
_distance = 5f;
_distanceFallOff = 1f;
_height = 1.5f;
_stepping = 8f;
_steppingNear = 0f;
_alpha = 0.95f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.2f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0.2f;
_speed = 0.01f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.FrostedGround:
_skySpeed = 0f;
_skyHaze = 0f;
_skyNoiseStrength = 0.729f;
_skyAlpha = 0.55f;
_density = 1f;
_noiseStrength = 0.164f;
_noiseScale = 1.81f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 0.5f;
_stepping = 20f;
_steppingNear = 50f;
_alpha = 0.97f;
_color = new Color(0.546f, 0.648f, 0.71f, 1f);
_skyColor = _color;
_specularColor = new Color(0.792f, 0.792f, 0.792f, 1f);
_specularIntensity = 1f;
_specularThreshold = 0.866f;
_lightColor = new Color(0.972f, 0.972f, 0.972f, 1f);
_lightIntensity = 0.743f;
_speed = 0f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.FoggyLake:
_skySpeed = 0.3f;
_skyHaze = 40f;
_skyNoiseStrength = 0.574f;
_skyAlpha = 0.827f;
_density = 1f;
_noiseStrength = 0.03f;
_noiseScale = 5.77f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 4f;
_stepping = 6f;
_steppingNear = 14.4f;
_alpha = 1f;
_color = new Color(0f, 0.96f, 1f, 1f);
_skyColor = _color;
_specularColor = Color.white;
_lightColor = Color.white;
_specularIntensity = 0.861f;
_specularThreshold = 0.907f;
_lightIntensity = 0.126f;
_speed = 0f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.LowClouds:
_skySpeed = 0.3f;
_skyHaze = 60f;
_skyNoiseStrength = 1f;
_skyAlpha = 0.96f;
_density = 1f;
_noiseStrength = 0.7f;
_noiseScale = 1f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 4f;
_stepping = 12f;
_steppingNear = 0f;
_alpha = 0.98f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.15f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0.15f;
_speed = 0.008f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.SeaClouds:
_skySpeed = 0.3f;
_skyHaze = 60f;
_skyNoiseStrength = 1f;
_skyAlpha = 0.96f;
_density = 1f;
_noiseStrength = 1f;
_noiseScale = 1.5f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 12.4f;
_stepping = 6f;
_alpha = 0.98f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.259f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0.15f;
_speed = 0.008f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.Fog:
_skySpeed = 0.3f;
_skyHaze = 144f;
_skyNoiseStrength = 0.7f;
_skyAlpha = 0.9f;
_density = 0.35f;
_noiseStrength = 0.3f;
_noiseScale = 1f;
_noiseSparse = 0f;
_distance = 20f;
_distanceFallOff = 0.7f;
_height = 8f;
_stepping = 8f;
_steppingNear = 0f;
_alpha = 0.97f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0f;
_speed = 0.05f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.HeavyFog:
_skySpeed = 0.05f;
_skyHaze = 500f;
_skyNoiseStrength = 0.96f;
_skyAlpha = 1f;
_density = 0.35f;
_noiseStrength = 0.1f;
_noiseScale = 1f;
_noiseSparse = 0f;
_distance = 20f;
_distanceFallOff = 0.8f;
_height = 18f;
_stepping = 6f;
_steppingNear = 0f;
_alpha = 1f;
_color = new Color(0.91f, 0.91f, 0.91f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0f;
_speed = 0.015f;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.SandStorm1:
_skySpeed = 0.35f;
_skyHaze = 388f;
_skyNoiseStrength = 0.847f;
_skyAlpha = 1f;
_density = 0.487f;
_noiseStrength = 0.758f;
_noiseScale = 1.71f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 16f;
_stepping = 6f;
_steppingNear = 0f;
_alpha = 1f;
_color = new Color(0.505f, 0.505f, 0.505f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0f;
_speed = 0.3f;
_windDirection = Vector3.right;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.Smoke:
_skySpeed = 0.109f;
_skyHaze = 10f;
_skyNoiseStrength = 0.119f;
_skyAlpha = 1f;
_density = 1f;
_noiseStrength = 0.767f;
_noiseScale = 1.6f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 8f;
_stepping = 12f;
_steppingNear = 25f;
_alpha = 1f;
_color = new Color(0.125f, 0.125f, 0.125f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 1f, 1f);
_specularIntensity = 0.575f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 1f;
_speed = 0.075f;
_windDirection = Vector3.right;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_baselineHeight += 8f;
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.ToxicSwamp:
_skySpeed = 0.062f;
_skyHaze = 22f;
_skyNoiseStrength = 0.694f;
_skyAlpha = 1f;
_density = 1f;
_noiseStrength = 1f;
_noiseScale = 1f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 2.5f;
_stepping = 20f;
_steppingNear = 50f;
_alpha = 0.95f;
_color = new Color(0.0238f, 0.175f, 0.109f, 1f);
_skyColor = _color;
_specularColor = new Color(0.593f, 0.625f, 0.207f, 1f);
_specularIntensity = 0.735f;
_specularThreshold = 0.6f;
_lightColor = new Color(0.73f, 0.746f, 0.511f, 1f);
_lightIntensity = 0.492f;
_speed = 0.0003f;
_windDirection = Vector3.right;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.SandStorm2:
_skySpeed = 0f;
_skyHaze = 0f;
_skyNoiseStrength = 0.729f;
_skyAlpha = 0.55f;
_density = 0.545f;
_noiseStrength = 1f;
_noiseScale = 3f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 12f;
_stepping = 5f;
_steppingNear = 19.6f;
_alpha = 0.96f;
_color = new Color(0.609f, 0.609f, 0.609f, 1f);
_skyColor = _color;
_specularColor = new Color(0.589f, 0.621f, 0.207f, 1f);
_specularIntensity = 0.505f;
_specularThreshold = 0.6f;
_lightColor = new Color(0.726f, 0.742f, 0.507f, 1f);
_lightIntensity = 0.581f;
_speed = 0.168f;
_windDirection = Vector3.right;
_downsampling = 1;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
_fogVoidRadius = 0f;
CopyTransitionValues();
break;
case FOG_PRESET.WorldEdge:
{
_skySpeed = 0.3f;
_skyHaze = 60f;
_skyNoiseStrength = 1f;
_skyAlpha = 0.96f;
_density = 1f;
_noiseStrength = 1f;
_noiseScale = 3f;
_noiseSparse = 0f;
_distance = 0f;
_distanceFallOff = 0f;
_height = 20f;
_stepping = 6f;
_alpha = 0.98f;
_color = new Color(0.89f, 0.89f, 0.89f, 1f);
_skyColor = _color;
_specularColor = new Color(1f, 1f, 0.8f, 1f);
_specularIntensity = 0.259f;
_specularThreshold = 0.6f;
_lightColor = Color.white;
_lightIntensity = 0.15f;
_speed = 0.03f;
_downsampling = 2;
_baselineRelativeToCamera = false;
CheckWaterLevel(false);
Terrain activeTerrain = GetActiveTerrain();
if (activeTerrain != null)
{
_fogVoidPosition = activeTerrain.transform.position + activeTerrain.terrainData.size * 0.5f;
_fogVoidRadius = activeTerrain.terrainData.size.x * 0.45f;
_fogVoidHeight = activeTerrain.terrainData.size.y;
_fogVoidDepth = activeTerrain.terrainData.size.z * 0.45f;
_fogVoidFallOff = 6f;
_fogAreaRadius = 0f;
_character = null;
_fogAreaCenter = null;
float x = activeTerrain.terrainData.size.x;
if (mainCamera.farClipPlane < x)
{
mainCamera.farClipPlane = x;
}
if (_maxFogLength < x * 0.6f)
{
_maxFogLength = x * 0.6f;
}
}
CopyTransitionValues();
break;
}
}
currentFogAlpha = _alpha;
currentFogColor = _color;
currentFogSpecularColor = _specularColor;
currentLightColor = _lightColor;
currentSkyHazeAlpha = _skyAlpha;
UpdateSun();
FogOfWarUpdateTexture();
UpdateMaterialProperties();
UpdateRenderComponents();
UpdateTextureAlpha();
UpdateTexture();
if (_sunShadows)
{
needUpdateDepthSunTexture = true;
}
else
{
DestroySunShadowsDependencies();
}
if (!Application.isPlaying)
{
UpdateWindSpeedQuick();
}
TrackPointLights();
lastTimeSortInstances = 0f;
}
public void CheckWaterLevel(bool baseZero)
{
if (mainCamera == null)
{
return;
}
if (_baselineHeight > mainCamera.transform.position.y || baseZero)
{
_baselineHeight = 0f;
}
GameObject gameObject = GameObject.Find("Water");
if (gameObject == null)
{
GameObject[] array = UnityEngine.Object.FindObjectsOfType<GameObject>();
for (int i = 0; i < array.Length; i++)
{
if (array[i] != null && array[i].layer == 4)
{
gameObject = array[i];
break;
}
}
}
if (gameObject != null)
{
_renderBeforeTransparent = false;
if (_baselineHeight < gameObject.transform.position.y)
{
_baselineHeight = gameObject.transform.position.y;
}
}
UpdateMaterialHeights();
}
public static Terrain GetActiveTerrain()
{
Terrain activeTerrain = Terrain.activeTerrain;
if (activeTerrain != null && activeTerrain.isActiveAndEnabled)
{
return activeTerrain;
}
for (int i = 0; i < Terrain.activeTerrains.Length; i++)
{
activeTerrain = Terrain.activeTerrains[i];
if (activeTerrain != null && activeTerrain.isActiveAndEnabled)
{
return activeTerrain;
}
}
return null;
}
private void UpdateMaterialFogColor()
{
fogMat.SetColor("_Color", currentFogColor * 2f);
}
private void UpdateMaterialHeights()
{
currentFogAltitude = _baselineHeight;
Vector3 vector = _fogAreaPosition;
if (_fogAreaRadius > 0f)
{
if (_fogAreaCenter != null && _fogAreaFollowMode == FOG_AREA_FOLLOW_MODE.FullXYZ)
{
currentFogAltitude += _fogAreaCenter.transform.position.y;
}
if (_useXYPlane)
{
vector.z = 0f;
}
else
{
vector.y = 0f;
}
}
if (_baselineRelativeToCamera && !_useXYPlane)
{
oldBaselineRelativeCameraY += (mainCamera.transform.position.y - oldBaselineRelativeCameraY) * Mathf.Clamp01(1.001f - _baselineRelativeToCameraDelay);
currentFogAltitude += oldBaselineRelativeCameraY - 1f;
}
float w = 0.01f / _noiseScale;
fogMat.SetVector("_FogData", new Vector4(currentFogAltitude, _height, 1f / _density, w));
fogMat.SetFloat("_FogSkyHaze", _skyHaze + currentFogAltitude);
Vector3 vector2 = _fogVoidPosition - currentFogAltitude * Vector3.up;
fogMat.SetVector("_FogVoidPosition", vector2);
fogMat.SetVector("_FogAreaPosition", vector);
}
public void UpdateMaterialProperties()
{
if (Application.isPlaying)
{
shouldUpdateMaterialProperties = true;
}
else
{
UpdateMaterialPropertiesNow();
}
}
public void UpdateMaterialPropertiesNow()
{
if (fogMat == null)
{
return;
}
shouldUpdateMaterialProperties = false;
UpdateSkyColor(_skyAlpha);
Vector4 value = new Vector4(1f / (_stepping + 1f), 1f / (1f + _steppingNear), _edgeThreshold, (!_dithering) ? 0f : (_ditherStrength * 0.1f));
fogMat.SetFloat("_Jitter", _jitterStrength);
if (!_edgeImprove)
{
value.z = 0f;
}
fogMat.SetVector("_FogStepping", value);
fogMat.SetFloat("_FogAlpha", currentFogAlpha);
UpdateMaterialHeights();
float num = 0.01f / _noiseScale;
float w = _maxFogLength * _maxFogLengthFallOff + 1f;
fogMat.SetVector("_FogDistance", new Vector4(num * num * _distance * _distance, _distanceFallOff * _distanceFallOff + 0.1f, _maxFogLength, w));
UpdateMaterialFogColor();
if (shaderKeywords == null)
{
shaderKeywords = new List<string>();
}
else
{
shaderKeywords.Clear();
}
if (_distance > 0f)
{
shaderKeywords.Add("FOG_DISTANCE_ON");
}
if (_fogVoidRadius > 0f && _fogVoidFallOff > 0f)
{
Vector4 value2 = new Vector4(1f / (1f + _fogVoidRadius), 1f / (1f + _fogVoidHeight), 1f / (1f + _fogVoidDepth), _fogVoidFallOff);
if (_fogVoidTopology == FOG_VOID_TOPOLOGY.Box)
{
shaderKeywords.Add("FOG_VOID_BOX");
}
else
{
shaderKeywords.Add("FOG_VOID_SPHERE");
}
fogMat.SetVector("_FogVoidData", value2);
}
if (_fogAreaRadius > 0f && _fogAreaFallOff > 0f)
{
Vector4 value3 = new Vector4(1f / (0.0001f + _fogAreaRadius), 1f / (0.0001f + _fogAreaHeight), 1f / (0.0001f + _fogAreaDepth), _fogAreaFallOff);
if (_fogAreaTopology == FOG_AREA_TOPOLOGY.Box)
{
shaderKeywords.Add("FOG_AREA_BOX");
}
else
{
shaderKeywords.Add("FOG_AREA_SPHERE");
value3.y = _fogAreaRadius * _fogAreaRadius;
value3.x /= num;
value3.z /= num;
}
fogMat.SetVector("_FogAreaData", value3);
}
if (_skyHaze > 0f && _skyAlpha > 0f && !_useXYPlane && hasCamera)
{
shaderKeywords.Add("FOG_HAZE_ON");
}
if (_fogOfWarEnabled)
{
shaderKeywords.Add("FOG_OF_WAR_ON");
fogMat.SetTexture("_FogOfWar", fogOfWarTexture);
fogMat.SetVector("_FogOfWarCenter", _fogOfWarCenter);
fogMat.SetVector("_FogOfWarSize", _fogOfWarSize);
Vector3 vector = _fogOfWarCenter - 0.5f * _fogOfWarSize;
if (_useXYPlane)
{
fogMat.SetVector("_FogOfWarCenterAdjusted", new Vector3(vector.x / _fogOfWarSize.x, vector.y / (_fogOfWarSize.y + 0.0001f), 1f));
}
else
{
fogMat.SetVector("_FogOfWarCenterAdjusted", new Vector3(vector.x / _fogOfWarSize.x, 1f, vector.z / (_fogOfWarSize.z + 0.0001f)));
}
}
CheckPointLightData();
bool flag = false;
for (int i = 0; i < pointLightParams.Length; i++)
{
if (pointLightParams[i].light != null || pointLightParams[i].range * pointLightParams[i].intensity > 0f)
{
flag = true;
break;
}
}
if (flag)
{
fogMat.SetFloat("_PointLightInsideAtten", _pointLightInsideAtten);
shaderKeywords.Add("FOG_POINT_LIGHTS");
}
if ((bool)fogRenderer.sun)
{
UpdateScatteringData();
if (_lightScatteringEnabled && _lightScatteringExposure > 0f)
{
shaderKeywords.Add("FOG_SCATTERING_ON");
}
if (_sunShadows)
{
shaderKeywords.Add("FOG_SUN_SHADOWS_ON");
UpdateSunShadowsData();
}
}
if (_fogBlur)
{
shaderKeywords.Add("FOG_BLUR_ON");
fogMat.SetFloat("_FogBlurDepth", _fogBlurDepth);
}
if (_useXYPlane)
{
shaderKeywords.Add("FOG_USE_XY_PLANE");
}
if (fogRenderer.computeDepth)
{
shaderKeywords.Add("FOG_COMPUTE_DEPTH");
}
fogMat.shaderKeywords = shaderKeywords.ToArray();
if (_computeDepth && _computeDepthScope == COMPUTE_DEPTH_SCOPE.TreeBillboardsAndTransparentObjects)
{
Shader.SetGlobalFloat("_VFM_CutOff", _transparencyCutOff);
}
}
public void NotifyChangesToFogInstances()
{
if (!hasCamera)
{
return;
}
int num = ((fogInstances != null) ? fogInstances.Count : 0);
for (int i = 0; i < num; i++)
{
VolumetricFog volumetricFog = fogInstances[i];
if (volumetricFog != null && volumetricFog != this)
{
volumetricFog.UpdateMaterialProperties();
}
}
}
private void UpdateSunShadowsData()
{
if (!(_sun == null) && _sunShadows && !(fogMat == null))
{
float num = _sunShadowsStrength * Mathf.Clamp01((0f - _sun.transform.forward.y) * 10f);
if (num < 0f)
{
num = 0f;
}
if (num > 0f && !fogMat.IsKeywordEnabled("FOG_SUN_SHADOWS_ON"))
{
fogMat.EnableKeyword("FOG_SUN_SHADOWS_ON");
}
else if (num <= 0f && fogMat.IsKeywordEnabled("FOG_SUN_SHADOWS_ON"))
{
fogMat.DisableKeyword("FOG_SUN_SHADOWS_ON");
}
if (_hasCamera)
{
Shader.SetGlobalVector("_VolumetricFogSunShadowsData", new Vector4(num, _sunShadowsJitterStrength, _sunShadowsCancellation, 0f));
}
}
}
private void UpdateWindSpeedQuick()
{
if (!(fogMat == null) && (!Application.isPlaying || lastFrameAppliedWind != Time.frameCount))
{
lastFrameAppliedWind = Time.frameCount;
float num = 0.01f / _noiseScale;
windSpeedAcum += deltaTime * _windDirection * _speed / num;
fogMat.SetVector("_FogWindDir", windSpeedAcum);
skyHazeSpeedAcum += deltaTime * _skySpeed / 20f;
fogMat.SetVector("_FogSkyData", new Vector4(_skyHaze, _skyNoiseStrength, skyHazeSpeedAcum, _skyDepth));
}
}
private void UpdateScatteringData()
{
Vector3 position = mainCamera.transform.position + _lightDirection * 1000f;
Vector3 vector = mainCamera.WorldToViewportPoint(position);
if (vector.z < 0f)
{
Vector2 vector2 = new Vector2(vector.x, vector.y);
float num = Mathf.Clamp01(1f - _lightDirection.y);
if (vector2 != oldSunPos)
{
oldSunPos = vector2;
sunFade = Mathf.SmoothStep(1f, 0f, (vector2 - Vector2.one * 0.5f).magnitude * 0.5f) * num;
}
fogMat.SetVector("_SunPosition", vector2);
if (_lightScatteringEnabled && !fogMat.IsKeywordEnabled("FOG_SCATTERING_ON"))
{
fogMat.EnableKeyword("FOG_SCATTERING_ON");
}
float num2 = _lightScatteringExposure * sunFade;
fogMat.SetVector("_FogScatteringData", new Vector4(_lightScatteringSpread / (float)_lightScatteringSamples, (num2 > 0f) ? _lightScatteringSamples : 0, num2, _lightScatteringWeight / (float)_lightScatteringSamples));
fogMat.SetVector("_FogScatteringData2", new Vector4(_lightScatteringIllumination, _lightScatteringDecay, _lightScatteringJittering, (!_lightScatteringEnabled) ? 0f : (1.2f * _lightScatteringDiffusion * num * sunLightIntensity)));
fogMat.SetVector("_SunDir", -_lightDirection);
fogMat.SetColor("_SunColor", _lightColor);
}
else if (fogMat.IsKeywordEnabled("FOG_SCATTERING_ON"))
{
fogMat.DisableKeyword("FOG_SCATTERING_ON");
}
}
private void UpdateSun()
{
if (fogRenderer != null && fogRenderer.sun != null)
{
sunLight = fogRenderer.sun.GetComponent<Light>();
}
else
{
sunLight = null;
}
}
private void UpdateSkyColor(float alpha)
{
if (!(fogMat == null))
{
float num = (_lightIntensity + sunLightIntensity) * Mathf.Clamp01(1f - _lightDirection.y);
if (num < 0f)
{
num = 0f;
}
else if (num > 1f)
{
num = 1f;
}
_skyColor.a = alpha;
Color value = num * _skyColor;
fogMat.SetColor("_FogSkyColor", value);
}
}
private void UpdateTextureAlpha()
{
if (adjustedColors == null)
{
return;
}
float num = Mathf.Clamp(_noiseStrength, 0f, 0.95f);
for (int i = 0; i < adjustedColors.Length; i++)
{
float num2 = 1f - (_noiseSparse + noiseColors[i].b) * num;
num2 *= _density * _noiseFinalMultiplier;
if (num2 < 0f)
{
num2 = 0f;
}
else if (num2 > 1f)
{
num2 = 1f;
}
adjustedColors[i].a = num2;
}
hasChangeAdjustedColorsAlpha = true;
}
private void UpdateTexture()
{
if (!(fogMat == null))
{
UpdateSkyColor(_skyAlpha);
float num = _lightIntensity + sunLightIntensity;
if (!_useXYPlane)
{
num *= Mathf.Clamp01(1f - _lightDirection.y * 2f);
}
switch (_lightingModel)
{
default:
{
Color a = RenderSettings.ambientLight * RenderSettings.ambientIntensity;
updatingTextureLightColor = Color.Lerp(a, currentLightColor * num, num);
lastRenderSettingsAmbientLight = RenderSettings.ambientLight;
lastRenderSettingsAmbientIntensity = RenderSettings.ambientIntensity;
break;
}
case LIGHTING_MODEL.Natural:
{
Color ambientLight = RenderSettings.ambientLight;
lastRenderSettingsAmbientLight = RenderSettings.ambientLight;
updatingTextureLightColor = Color.Lerp(ambientLight, currentLightColor * num + ambientLight, _lightIntensity);
break;
}
case LIGHTING_MODEL.SingleLight:
updatingTextureLightColor = Color.Lerp(Color.black, currentLightColor * num, _lightIntensity);
break;
}
if (Application.isPlaying)
{
updatingTextureSlice = 0;
}
else
{
updatingTextureSlice = -1;
}
UpdateTextureColors(adjustedColors, hasChangeAdjustedColorsAlpha);
needUpdateTexture = false;
}
}
private void UpdateTextureColors(Color[] colors, bool forceUpdateEntireTexture)
{
float num = 1.0001f - _specularThreshold;
int width = adjustedTexture.width;
Vector3 vector = new Vector3(0f - _lightDirection.x, 0f, 0f - _lightDirection.z).normalized * 0.3f;
vector.y = ((!(_lightDirection.y > 0f)) ? (1f - Mathf.Clamp01(0f - _lightDirection.y)) : Mathf.Clamp01(1f - _lightDirection.y));
int num2 = Mathf.FloorToInt(vector.z * (float)width) * width;
int num3 = (int)((float)num2 + vector.x * (float)width) + colors.Length;
float num4 = vector.y / num;
Color color = currentFogSpecularColor * (1f + _specularIntensity) * _specularIntensity;
bool flag = false;
if (updatingTextureSlice >= 1 || forceUpdateEntireTexture)
{
flag = true;
}
float num5 = updatingTextureLightColor.r * 0.5f;
float num6 = updatingTextureLightColor.g * 0.5f;
float num7 = updatingTextureLightColor.b * 0.5f;
float num8 = color.r * 0.5f;
float num9 = color.g * 0.5f;
float num10 = color.b * 0.5f;
int num11 = colors.Length;
int num12 = 0;
int num13 = num11;
if (updatingTextureSlice >= 0)
{
if (updatingTextureSlice > _updateTextureSpread)
{
updatingTextureSlice = -1;
needUpdateTexture = true;
return;
}
num12 = num11 * updatingTextureSlice / _updateTextureSpread;
num13 = num11 * (updatingTextureSlice + 1) / _updateTextureSpread;
}
int num14 = 0;
for (int i = num12; i < num13; i++)
{
int num15 = (i + num3) % num11;
float a = colors[i].a;
float num16 = (a - colors[num15].a) * num4;
if (num16 < 0f)
{
num16 = 0f;
}
else if (num16 > 1f)
{
num16 = 1f;
}
float num17 = num5 + num8 * num16;
float num18 = num6 + num9 * num16;
float num19 = num7 + num10 * num16;
if (!flag)
{
if (num14++ < 100)
{
if (num17 != colors[i].r || num18 != colors[i].g || num19 != colors[i].b)
{
flag = true;
}
}
else if (!flag)
{
break;
}
}
colors[i].r = num17;
colors[i].g = num18;
colors[i].b = num19;
}
bool flag2 = forceUpdateEntireTexture;
if (flag)
{
if (updatingTextureSlice >= 0)
{
updatingTextureSlice++;
if (updatingTextureSlice >= _updateTextureSpread)
{
updatingTextureSlice = -1;
flag2 = true;
}
}
else
{
flag2 = true;
}
}
else
{
updatingTextureSlice = -1;
}
if (flag2)
{
if (Application.isPlaying && _turbulenceStrength > 0f && (bool)adjustedChaosTexture)
{
adjustedChaosTexture.SetPixels(adjustedColors);
adjustedChaosTexture.Apply();
}
else
{
adjustedTexture.SetPixels(adjustedColors);
adjustedTexture.Apply();
fogMat.SetTexture("_NoiseTex", adjustedTexture);
}
lastTextureUpdate = Time.time;
}
}
internal void ApplyChaos()
{
if ((bool)adjustedTexture && (!Application.isPlaying || lastFrameAppliedChaos != Time.frameCount))
{
lastFrameAppliedChaos = Time.frameCount;
if (chaosLerpMat == null)
{
Shader shader = Shader.Find("VolumetricFogAndMist/Chaos Lerp");
chaosLerpMat = new Material(shader);
chaosLerpMat.hideFlags = HideFlags.DontSave;
}
turbAcum += deltaTime * _turbulenceStrength;
chaosLerpMat.SetFloat("_Amount", turbAcum);
if (!adjustedChaosTexture)
{
adjustedChaosTexture = UnityEngine.Object.Instantiate(adjustedTexture);
adjustedChaosTexture.hideFlags = HideFlags.DontSave;
}
RenderTexture temporary = RenderTexture.GetTemporary(adjustedTexture.width, adjustedTexture.height, 0, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
temporary.wrapMode = TextureWrapMode.Repeat;
Graphics.Blit(adjustedChaosTexture, temporary, chaosLerpMat);
fogMat.SetTexture("_NoiseTex", temporary);
RenderTexture.ReleaseTemporary(temporary);
}
}
private void CopyTransitionValues()
{
currentFogAlpha = _alpha;
currentSkyHazeAlpha = _skyAlpha;
currentFogColor = _color;
currentFogSpecularColor = _specularColor;
currentLightColor = _lightColor;
}
public void SetTargetProfile(VolumetricFogProfile targetProfile, float duration)
{
if (_useFogVolumes)
{
initialProfile = ScriptableObject.CreateInstance<VolumetricFogProfile>();
initialProfile.Save(this);
this.targetProfile = targetProfile;
transitionDuration = duration;
transitionStartTime = Time.time;
transitionProfile = true;
}
}
public void ClearTargetProfile(float duration)
{
SetTargetProfile(initialProfile, duration);
}
public void SetTargetAlpha(float newFogAlpha, float newSkyHazeAlpha, float duration)
{
if (_useFogVolumes)
{
initialFogAlpha = currentFogAlpha;
initialSkyHazeAlpha = currentSkyHazeAlpha;
targetFogAlpha = newFogAlpha;
targetSkyHazeAlpha = newSkyHazeAlpha;
transitionDuration = duration;
transitionStartTime = Time.time;
transitionAlpha = true;
}
}
public void ClearTargetAlpha(float duration)
{
SetTargetAlpha(-1f, -1f, duration);
}
public void SetTargetColor(Color newColor, float duration)
{
if (useFogVolumes)
{
initialFogColor = currentFogColor;
targetFogColor = newColor;
transitionDuration = duration;
transitionStartTime = Time.time;
transitionColor = true;
targetColorActive = true;
}
}
public void ClearTargetColor(float duration)
{
SetTargetColor(_color, duration);
targetColorActive = false;
}
public void SetTargetSpecularColor(Color newSpecularColor, float duration)
{
if (useFogVolumes)
{
initialFogSpecularColor = currentFogSpecularColor;
targetFogSpecularColor = newSpecularColor;
transitionDuration = duration;
transitionStartTime = Time.time;
transitionSpecularColor = true;
targetSpecularColorActive = true;
}
}
public void ClearTargetSpecularColor(float duration)
{
SetTargetSpecularColor(_specularColor, duration);
targetSpecularColorActive = false;
}
public void SetTargetLightColor(Color newLightColor, float duration)
{
if (useFogVolumes)
{
_sunCopyColor = false;
initialLightColor = currentLightColor;
targetLightColor = newLightColor;
transitionDuration = duration;
transitionStartTime = Time.time;
transitionLightColor = true;
targetLightColorActive = true;
}
}
public void ClearTargetLightColor(float duration)
{
SetTargetLightColor(_lightColor, duration);
targetLightColorActive = false;
}
public void CheckPointLightData()
{
if (_pointLightTrackingPivot == null)
{
_pointLightTrackingPivot = base.transform;
}
if (!pointLightDataMigrated)
{
pointLightParams = new PointLightParams[6];
for (int i = 0; i < _pointLightColors.Length; i++)
{
pointLightParams[i].color = _pointLightColors[i];
Light light = null;
if (_pointLights[i] != null)
{
light = _pointLights[i].GetComponent<Light>();
}
pointLightParams[i].light = light;
pointLightParams[i].intensity = _pointLightIntensities[i];
pointLightParams[i].intensityMultiplier = _pointLightIntensitiesMultiplier[i];
pointLightParams[i].position = _pointLightPositions[i];
pointLightParams[i].range = _pointLightRanges[i];
}
for (int j = _pointLightColors.Length; j < 6; j++)
{
PointLightDataSetDefaults(j);
}
pointLightDataMigrated = true;
isDirty = true;
}
if (_pointLightTrackingCount > 6)
{
_pointLightTrackingCount = 6;
isDirty = true;
}
if (pointLightParams != null)
{
if (pointLightParams.Length != 6)
{
PointLightParams[] array = new PointLightParams[6];
int num = Mathf.Min(array.Length, pointLightParams.Length);
Array.Copy(pointLightParams, array, num);
pointLightParams = array;
for (int k = num; k < array.Length; k++)
{
PointLightDataSetDefaults(k);
}
isDirty = true;
}
}
else
{
pointLightParams = new PointLightParams[6];
for (int l = 0; l < pointLightParams.Length; l++)
{
PointLightDataSetDefaults(l);
}
isDirty = true;
}
if (currentLights == null || currentLights.Length != 6)
{
currentLights = new Light[6];
}
}
private void PointLightDataSetDefaults(int k)
{
if (k < pointLightParams.Length)
{
pointLightParams[k].color = new Color(1f, 1f, 0f, 1f);
pointLightParams[k].intensity = 1f;
pointLightParams[k].intensityMultiplier = 1f;
pointLightParams[k].range = 0f;
}
}
private void SetPointLightMaterialProperties()
{
int num = pointLightParams.Length;
if (pointLightColorBuffer == null || pointLightColorBuffer.Length != num)
{
pointLightColorBuffer = new Color[num];
}
if (pointLightPositionBuffer == null || pointLightPositionBuffer.Length != num)
{
pointLightPositionBuffer = new Vector4[num];
}
Vector3 vector = ((!(mainCamera != null)) ? Vector3.zero : mainCamera.transform.position);
for (int i = 0; i < num; i++)
{
Vector3 position = pointLightParams[i].position;
if (!_sunShadows)
{
position.y -= _baselineHeight;
}
float num2 = pointLightParams[i].range * _pointLightInscattering / 25f;
float num3 = _pointLightIntensity * pointLightParams[i].intensity * pointLightParams[i].intensityMultiplier;
if (num2 > 0f && num3 > 0f)
{
if (_distance > 0f)
{
float num4 = 0.01f / _noiseScale;
float num5 = _distance * num4;
float num6 = Mathf.Max(num5 * num5 - new Vector2((vector.x - position.x) * num4, (vector.z - position.z) * num4).sqrMagnitude, 0f);
num6 *= _distanceFallOff * _distanceFallOff + 0.1f;
num3 = ((!(num3 > num6)) ? 0f : (num3 - num6));
}
pointLightPositionBuffer[i] = position;
pointLightColorBuffer[i] = new Vector4(pointLightParams[i].color.r * num3, pointLightParams[i].color.g * num3, pointLightParams[i].color.b * num3, num2);
}
else
{
pointLightColorBuffer[i] = Color.black;
}
}
fogMat.SetColorArray("_FogPointLightColor", pointLightColorBuffer);
fogMat.SetVectorArray("_FogPointLightPosition", pointLightPositionBuffer);
}
public Light GetPointLight(int index)
{
if (index < 0 || index >= pointLightParams.Length)
{
return null;
}
return pointLightParams[index].light;
}
private void TrackNewLights()
{
lastFoundLights = UnityEngine.Object.FindObjectsOfType<Light>();
}
public void TrackPointLights(bool forceImmediateUpdate = false)
{
if (!_pointLightTrackingAuto)
{
return;
}
if (_pointLightTrackingPivot == null)
{
_pointLightTrackingPivot = base.transform;
}
if (forceImmediateUpdate || lastFoundLights == null || !Application.isPlaying || (_pointLightTrackingNewLightsCheckInterval > 0f && Time.time - trackPointCheckNewLightsLastTime > _pointLightTrackingNewLightsCheckInterval))
{
trackPointCheckNewLightsLastTime = Time.time;
TrackNewLights();
}
int num = lastFoundLights.Length;
if (lightBuffer == null || lightBuffer.Length != num)
{
lightBuffer = new Light[num];
}
for (int i = 0; i < num; i++)
{
lightBuffer[i] = lastFoundLights[i];
}
bool flag = false;
for (int j = 0; j < pointLightParams.Length && j < currentLights.Length; j++)
{
Light light = null;
if (j < _pointLightTrackingCount)
{
light = GetNearestLight(lightBuffer);
}
pointLightParams[j].light = light;
if (pointLightParams[j].range != 0f && light == null)
{
pointLightParams[j].range = 0f;
}
if (currentLights[j] != light)
{
currentLights[j] = light;
flag = true;
}
}
if (flag)
{
UpdateMaterialProperties();
}
}
private Light GetNearestLight(Light[] lights)
{
float num = float.MaxValue;
Vector3 position = _pointLightTrackingPivot.position;
Light result = null;
int num2 = -1;
for (int i = 0; i < lights.Length; i++)
{
Light light = lights[i];
if (!(light == null) && light.enabled && light.type == LightType.Point && light.isActiveAndEnabled)
{
float sqrMagnitude = (light.transform.position - position).sqrMagnitude;
if (sqrMagnitude < num)
{
result = light;
num = sqrMagnitude;
num2 = i;
}
}
}
if (num2 >= 0)
{
lights[num2] = null;
}
return result;
}
public static VolumetricFog CreateFogArea(Vector3 position, float radius, float height = 16f, float fallOff = 1f)
{
VolumetricFog volumetricFog = CreateFogAreaPlaceholder(true, position, radius, height, radius);
volumetricFog.preset = FOG_PRESET.SeaClouds;
volumetricFog.transform.position = position;
volumetricFog.skyHaze = 0f;
volumetricFog.dithering = true;
return volumetricFog;
}
public static VolumetricFog CreateFogArea(Vector3 position, Vector3 boxSize)
{
VolumetricFog volumetricFog = CreateFogAreaPlaceholder(false, position, boxSize.x * 0.5f, boxSize.y * 0.5f, boxSize.z * 0.5f);
volumetricFog.preset = FOG_PRESET.SeaClouds;
volumetricFog.transform.position = position;
volumetricFog.height = boxSize.y * 0.98f;
volumetricFog.skyHaze = 0f;
return volumetricFog;
}
private static VolumetricFog CreateFogAreaPlaceholder(bool spherical, Vector3 position, float radius, float height, float depth)
{
GameObject original = ((!spherical) ? Resources.Load<GameObject>("Prefabs/FogBoxArea") : Resources.Load<GameObject>("Prefabs/FogSphereArea"));
GameObject gameObject = UnityEngine.Object.Instantiate(original);
gameObject.transform.position = position;
gameObject.transform.localScale = new Vector3(radius, height, depth);
return gameObject.GetComponent<VolumetricFog>();
}
public static void RemoveAllFogAreas()
{
VolumetricFog[] array = UnityEngine.Object.FindObjectsOfType<VolumetricFog>();
for (int i = 0; i < array.Length; i++)
{
if (array[i] != null && !array[i].hasCamera)
{
UnityEngine.Object.DestroyImmediate(array[i].gameObject);
}
}
}
private void CheckFogAreaDimensions()
{
if (!_hasCamera && mr == null)
{
mr = GetComponent<MeshRenderer>();
}
if (mr == null)
{
return;
}
Vector3 extents = mr.bounds.extents;
switch (_fogAreaTopology)
{
case FOG_AREA_TOPOLOGY.Box:
fogAreaRadius = extents.x;
fogAreaHeight = extents.y;
fogAreaDepth = extents.z;
break;
case FOG_AREA_TOPOLOGY.Sphere:
fogAreaRadius = extents.x;
if (base.transform.localScale.z != base.transform.localScale.x)
{
base.transform.localScale = new Vector3(base.transform.localScale.x, base.transform.localScale.y, base.transform.localScale.x);
}
break;
}
if (_fogAreaCenter != null)
{
if (_fogAreaFollowMode == FOG_AREA_FOLLOW_MODE.FullXYZ)
{
base.transform.position = _fogAreaCenter.transform.position;
}
else
{
base.transform.position = new Vector3(_fogAreaCenter.transform.position.x, base.transform.position.y, _fogAreaCenter.transform.position.z);
}
}
fogAreaPosition = base.transform.position;
}
public void UpdateVolumeMask()
{
if (!_hasCamera || mainCamera == null)
{
return;
}
RemoveMaskCommandBuffer();
if (!_enableMask)
{
return;
}
if (maskCommandBuffer != null)
{
maskCommandBuffer.Clear();
}
else
{
maskCommandBuffer = new CommandBuffer();
maskCommandBuffer.name = "Volumetric Fog Mask Write";
}
if (maskMaterial == null)
{
maskMaterial = new Material(Shader.Find("VolumetricFogAndMist/MaskWrite"));
}
if (XRSettings.enabled)
{
rtMaskDesc = XRSettings.eyeTextureDesc;
}
else
{
rtMaskDesc = new RenderTextureDescriptor(mainCamera.pixelWidth, mainCamera.pixelHeight);
}
rtMaskDesc.colorFormat = RenderTextureFormat.Depth;
rtMaskDesc.depthBufferBits = 24;
rtMaskDesc.sRGB = false;
rtMaskDesc.msaaSamples = 1;
rtMaskDesc.useMipMap = false;
rtMaskDesc.volumeDepth = 1;
int num = Mathf.Max(1, _maskDownsampling);
rtMaskDesc.width /= num;
rtMaskDesc.height /= num;
int num2 = Shader.PropertyToID("_VolumetricFogScreenMaskTexture");
maskCommandBuffer.GetTemporaryRT(num2, rtMaskDesc);
maskCommandBuffer.SetRenderTarget(num2);
maskCommandBuffer.ClearRenderTarget(true, false, Color.white);
Renderer[] array = UnityEngine.Object.FindObjectsOfType<Renderer>();
for (int i = 0; i < array.Length; i++)
{
if (((1 << array[i].gameObject.layer) & _maskLayer.value) != 0 && array[i].gameObject.activeSelf)
{
if (array[i].enabled && Application.isPlaying)
{
array[i].enabled = false;
}
maskCommandBuffer.DrawRenderer(array[i], maskMaterial);
}
}
maskCommandBuffer.ReleaseTemporaryRT(num2);
mainCamera.AddCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, maskCommandBuffer);
}
public void TogglePreviewMask()
{
Renderer[] array = UnityEngine.Object.FindObjectsOfType<Renderer>();
for (int i = 0; i < array.Length; i++)
{
if (((1 << array[i].gameObject.layer) & _maskLayer.value) != 0 && array[i].gameObject.activeSelf)
{
array[i].enabled = !array[i].enabled;
}
}
}
private void RemoveMaskCommandBuffer()
{
if (maskCommandBuffer != null && mainCamera != null)
{
mainCamera.RemoveCommandBuffer(CameraEvent.BeforeImageEffectsOpaque, maskCommandBuffer);
}
}
private void FogOfWarInit()
{
fowTransitionList = new FogOfWarTransition[10000];
fowTransitionIndices = new Dictionary<int, int>(10000);
lastTransitionPos = -1;
}
private void FogOfWarUpdateTexture()
{
if (_fogOfWarEnabled)
{
int scaledSize = GetScaledSize(_fogOfWarTextureSize, 1f);
if (fogOfWarTexture == null || fogOfWarTexture.width != scaledSize || fogOfWarTexture.height != scaledSize)
{
fogOfWarTexture = new Texture2D(scaledSize, scaledSize, TextureFormat.Alpha8, false);
fogOfWarTexture.hideFlags = HideFlags.DontSave;
fogOfWarTexture.filterMode = FilterMode.Bilinear;
fogOfWarTexture.wrapMode = TextureWrapMode.Clamp;
ResetFogOfWar();
}
}
}
private void FogOfWarUpdate()
{
if (!_fogOfWarEnabled)
{
return;
}
int width = fogOfWarTexture.width;
for (int i = 0; i <= lastTransitionPos; i++)
{
FogOfWarTransition fogOfWarTransition = fowTransitionList[i];
if (!fogOfWarTransition.enabled)
{
continue;
}
float num = Time.time - fogOfWarTransition.startTime - fogOfWarTransition.startDelay;
if (!(num > 0f))
{
continue;
}
float value = ((!(fogOfWarTransition.duration <= 0f)) ? (num / fogOfWarTransition.duration) : 1f);
value = Mathf.Clamp01(value);
byte a = (byte)Mathf.Lerp((int)fogOfWarTransition.initialAlpha, (int)fogOfWarTransition.targetAlpha, value);
int num2 = fogOfWarTransition.y * width + fogOfWarTransition.x;
fogOfWarColorBuffer[num2].a = a;
fogOfWarTexture.SetPixel(fogOfWarTransition.x, fogOfWarTransition.y, fogOfWarColorBuffer[num2]);
requiresTextureUpload = true;
if (value >= 1f)
{
fowTransitionList[i].enabled = false;
if (fogOfWarTransition.targetAlpha < byte.MaxValue && _fogOfWarRestoreDelay > 0f)
{
AddFogOfWarTransitionSlot(fogOfWarTransition.x, fogOfWarTransition.y, fogOfWarTransition.targetAlpha, byte.MaxValue, _fogOfWarRestoreDelay, _fogOfWarRestoreDuration);
}
}
}
if (requiresTextureUpload)
{
requiresTextureUpload = false;
fogOfWarTexture.Apply();
}
}
public void SetFogOfWarAlpha(Vector3 worldPosition, float radius, float fogNewAlpha)
{
SetFogOfWarAlpha(worldPosition, radius, fogNewAlpha, 1f);
}
public void SetFogOfWarAlpha(Vector3 worldPosition, float radius, float fogNewAlpha, float duration)
{
if (fogOfWarTexture == null)
{
return;
}
float num = (worldPosition.x - _fogOfWarCenter.x) / _fogOfWarSize.x + 0.5f;
if (num < 0f || num > 1f)
{
return;
}
float num2 = (worldPosition.z - _fogOfWarCenter.z) / _fogOfWarSize.z + 0.5f;
if (num2 < 0f || num2 > 1f)
{
return;
}
int width = fogOfWarTexture.width;
int num3 = fogOfWarTexture.height;
int num4 = (int)(num * (float)width);
int num5 = (int)(num2 * (float)num3);
int num6 = num5 * width + num4;
byte b = (byte)(fogNewAlpha * 255f);
Color32 color = fogOfWarColorBuffer[num6];
if (b == color.a)
{
return;
}
float num7 = radius / _fogOfWarSize.z;
int num8 = (int)((float)num3 * num7);
for (int i = num5 - num8; i <= num5 + num8; i++)
{
if (i <= 0 || i >= num3 - 1)
{
continue;
}
for (int j = num4 - num8; j <= num4 + num8; j++)
{
if (j <= 0 || j >= width - 1)
{
continue;
}
int num9 = (int)Mathf.Sqrt((num5 - i) * (num5 - i) + (num4 - j) * (num4 - j));
if (num9 > num8)
{
continue;
}
num6 = i * width + j;
Color32 color2 = fogOfWarColorBuffer[num6];
byte b2 = (byte)Mathf.Lerp((int)b, (int)color2.a, (float)num9 / (float)num8);
if (b2 >= byte.MaxValue)
{
continue;
}
if (duration > 0f)
{
AddFogOfWarTransitionSlot(j, i, color2.a, b2, 0f, duration);
continue;
}
color2.a = b2;
fogOfWarColorBuffer[num6] = color2;
fogOfWarTexture.SetPixel(j, i, color2);
requiresTextureUpload = true;
if (_fogOfWarRestoreDuration > 0f)
{
AddFogOfWarTransitionSlot(j, i, b2, byte.MaxValue, _fogOfWarRestoreDelay, _fogOfWarRestoreDuration);
}
}
}
}
public void SetFogOfWarAlpha(Bounds bounds, float fogNewAlpha, float duration)
{
if (fogOfWarTexture == null)
{
return;
}
Vector3 center = bounds.center;
float num = (center.x - _fogOfWarCenter.x) / _fogOfWarSize.x + 0.5f;
if (num < 0f || num > 1f)
{
return;
}
float num2 = (center.z - _fogOfWarCenter.z) / _fogOfWarSize.z + 0.5f;
if (num2 < 0f || num2 > 1f)
{
return;
}
int width = fogOfWarTexture.width;
int num3 = fogOfWarTexture.height;
int num4 = (int)(num * (float)width);
int num5 = (int)(num2 * (float)num3);
int num6 = num5 * width + num4;
byte b = (byte)(fogNewAlpha * 255f);
Color32 color = fogOfWarColorBuffer[num6];
if (b == color.a)
{
return;
}
float num7 = bounds.extents.z / _fogOfWarSize.z;
float num8 = bounds.extents.x / _fogOfWarSize.z;
int num9 = (int)((float)num3 * num7);
int num10 = (int)((float)num3 * num8);
for (int i = num5 - num9; i <= num5 + num9; i++)
{
if (i <= 0 || i >= num3 - 1)
{
continue;
}
for (int j = num4 - num10; j <= num4 + num10; j++)
{
if (j <= 0 || j >= width - 1)
{
continue;
}
int num11 = Mathf.CeilToInt(num4 - j);
int num12 = Mathf.CeilToInt(num5 - i);
if (num11 > num10 || num12 > num9)
{
continue;
}
num6 = i * width + j;
Color32 color2 = fogOfWarColorBuffer[num6];
byte b2 = (byte)Mathf.Lerp((int)b, (int)color2.a, (float)num12 / (float)num9 * ((float)num11 / (float)num10));
if (b2 >= byte.MaxValue)
{
continue;
}
if (duration > 0f)
{
AddFogOfWarTransitionSlot(j, i, color2.a, b2, 0f, duration);
continue;
}
color2.a = b2;
fogOfWarColorBuffer[num6] = color2;
fogOfWarTexture.SetPixel(j, i, color2);
requiresTextureUpload = true;
if (_fogOfWarRestoreDuration > 0f)
{
AddFogOfWarTransitionSlot(j, i, b2, byte.MaxValue, _fogOfWarRestoreDelay, _fogOfWarRestoreDuration);
}
}
}
}
public void ResetFogOfWarAlpha(Vector3 worldPosition, float radius)
{
if (fogOfWarTexture == null)
{
return;
}
float num = (worldPosition.x - _fogOfWarCenter.x) / _fogOfWarSize.x + 0.5f;
if (num < 0f || num > 1f)
{
return;
}
float num2 = (worldPosition.z - _fogOfWarCenter.z) / _fogOfWarSize.z + 0.5f;
if (num2 < 0f || num2 > 1f)
{
return;
}
int width = fogOfWarTexture.width;
int num3 = fogOfWarTexture.height;
int num4 = (int)(num * (float)width);
int num5 = (int)(num2 * (float)num3);
int num6 = num5 * width + num4;
float num7 = radius / _fogOfWarSize.z;
int num8 = (int)((float)num3 * num7);
int num9 = num8 * num8;
for (int i = num5 - num8; i <= num5 + num8; i++)
{
if (i > 0 && i < num3 - 1)
{
for (int j = num4 - num8; j <= num4 + num8; j++)
{
if (j > 0 && j < width - 1)
{
int num10 = (num5 - i) * (num5 - i) + (num4 - j) * (num4 - j);
if (num10 <= num9)
{
num6 = i * width + j;
Color32 color = fogOfWarColorBuffer[num6];
color.a = byte.MaxValue;
fogOfWarColorBuffer[num6] = color;
fogOfWarTexture.SetPixel(j, i, color);
}
}
}
}
requiresTextureUpload = true;
}
}
public void ResetFogOfWar()
{
if (!(fogOfWarTexture == null) && isPartOfScene)
{
int num = fogOfWarTexture.height;
int width = fogOfWarTexture.width;
int num2 = num * width;
if (fogOfWarColorBuffer == null || fogOfWarColorBuffer.Length != num2)
{
fogOfWarColorBuffer = new Color32[num2];
}
Color32 color = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
for (int i = 0; i < num2; i++)
{
fogOfWarColorBuffer[i] = color;
}
fogOfWarTexture.SetPixels32(fogOfWarColorBuffer);
fogOfWarTexture.Apply();
lastTransitionPos = -1;
fowTransitionIndices.Clear();
isDirty = true;
}
}
private void AddFogOfWarTransitionSlot(int x, int y, byte initialAlpha, byte targetAlpha, float delay, float duration)
{
int key = y * 64000 + x;
int value;
if (!fowTransitionIndices.TryGetValue(key, out value))
{
value = -1;
for (int i = 0; i <= lastTransitionPos; i++)
{
if (!fowTransitionList[i].enabled)
{
value = i;
fowTransitionIndices[key] = value;
break;
}
}
}
if (value >= 0 && fowTransitionList[value].enabled && (fowTransitionList[value].x != x || fowTransitionList[value].y != y))
{
value = -1;
}
if (value < 0)
{
if (lastTransitionPos >= 9999)
{
return;
}
value = ++lastTransitionPos;
fowTransitionIndices[key] = value;
}
fowTransitionList[value].x = x;
fowTransitionList[value].y = y;
fowTransitionList[value].duration = duration;
fowTransitionList[value].startTime = Time.time;
fowTransitionList[value].startDelay = delay;
fowTransitionList[value].initialAlpha = initialAlpha;
fowTransitionList[value].targetAlpha = targetAlpha;
fowTransitionList[value].enabled = true;
}
public float GetFogOfWarAlpha(Vector3 worldPosition)
{
if (fogOfWarColorBuffer == null)
{
return 1f;
}
float num = (worldPosition.x - _fogOfWarCenter.x) / _fogOfWarSize.x + 0.5f;
if (num < 0f || num > 1f)
{
return 1f;
}
float num2 = (worldPosition.z - _fogOfWarCenter.z) / _fogOfWarSize.z + 0.5f;
if (num2 < 0f || num2 > 1f)
{
return 1f;
}
int width = fogOfWarTexture.width;
int num3 = fogOfWarTexture.height;
int num4 = (int)(num * (float)width);
int num5 = (int)(num2 * (float)num3);
int num6 = num5 * width + num4;
if (num6 < 0 || num6 >= fogOfWarColorBuffer.Length)
{
return 1f;
}
return (float)(int)fogOfWarColorBuffer[num6].a / 255f;
}
}
}
Reference in New Issue View Git Blame Copy Permalink