/// <summary>
/// Optimizes the planar reflections
/// </summary>
/// <param name="planarReflectionProbe"></param>
private void OptimizePlanarReflections(PlanarReflectionProbe planarReflectionProbe)
{
if (planarReflectionProbe != null)
{
PlanarReflectionProbe planar = planarReflectionProbe;
if (planar != null)
{
#if !UNITY_2019_1_OR_NEWER
planar.mode = UnityEngine.Rendering.ReflectionProbeMode.Realtime;
planar.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.OnAwake;
planar.captureSettings.farClipPlane = 25f;
planar.captureSettings.overrides = CaptureSettingsOverrides.FieldOfview;
planar.captureSettings.fieldOfView = 90f;
planar.RequestRealtimeRender();
#else
planar.mode = ProbeSettings.Mode.Realtime;
#endif
}
HDAdditionalReflectionData data = planar.gameObject.GetComponent <HDAdditionalReflectionData>();
if (data != null)
{
#if !UNITY_2019_1_OR_NEWER
data.mode = UnityEngine.Rendering.ReflectionProbeMode.Realtime;
data.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.OnAwake;
data.captureSettings.farClipPlane = 250f;
data.captureSettings.fieldOfView = 90f;
#else
data.mode = ProbeSettings.Mode.Realtime;
#endif
}
}
}
public SerializedHDReflectionProbe(SerializedObject so, SerializedObject addso)
{
this.so = so;
this.addso = addso;
proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolume);
influenceVolume = new SerializedInfluenceVolume(addso.Find((HDAdditionalReflectionData d) => d.influenceVolume));
target = (ReflectionProbe)so.targetObject;
targetData = target.GetComponent <HDAdditionalReflectionData>();
mode = so.FindProperty("m_Mode");
customBakedTexture = so.FindProperty("m_CustomBakedTexture");
renderDynamicObjects = so.FindProperty("m_RenderDynamicObjects");
refreshMode = so.FindProperty("m_RefreshMode");
timeSlicingMode = so.FindProperty("m_TimeSlicingMode");
intensityMultiplier = so.FindProperty("m_IntensityMultiplier");
boxSize = so.FindProperty("m_BoxSize");
boxOffset = so.FindProperty("m_BoxOffset");
resolution = so.FindProperty("m_Resolution");
shadowDistance = so.FindProperty("m_ShadowDistance");
cullingMask = so.FindProperty("m_CullingMask");
useOcclusionCulling = so.FindProperty("m_UseOcclusionCulling");
nearClip = so.FindProperty("m_NearClip");
farClip = so.FindProperty("m_FarClip");
boxProjection = so.FindProperty("m_BoxProjection");
legacyBlendDistance = so.FindProperty("m_BlendDistance");
weight = addso.Find((HDAdditionalReflectionData d) => d.weight);
multiplier = addso.Find((HDAdditionalReflectionData d) => d.multiplier);
}
protected override void OnEnable()
{
var additionalData = CoreEditorUtils.GetAdditionalData <HDAdditionalReflectionData>(targets);
m_AdditionalDataSerializedObject = new SerializedObject(additionalData);
m_SerializedHDProbe = new SerializedHDReflectionProbe(serializedObject, m_AdditionalDataSerializedObject);
foreach (var t in targets)
{
var p = (ReflectionProbe)t;
s_ReflectionProbeEditors[p] = this;
}
base.OnEnable();
m_UIState.owner = this;
m_UIState.Reset(m_SerializedHDProbe, Repaint);
InitializeTargetProbe();
HDAdditionalReflectionData probe = (HDAdditionalReflectionData)m_AdditionalDataSerializedObject.targetObject;
probe.influenceVolume.Init(probe);
//unhide previously hidden components
probe.hideFlags = HideFlags.None;
}
internal static void InitializeProbe(ReflectionProbe p, HDAdditionalReflectionData data)
{
var meshFilter = p.GetComponent <MeshFilter>() ?? p.gameObject.AddComponent <MeshFilter>();
var meshRenderer = p.GetComponent <MeshRenderer>() ?? p.gameObject.AddComponent <MeshRenderer>();
meshFilter.sharedMesh = s_SphereMesh;
// Lazy evaluation attempt to avoid shader compil error issue in Editor (The shader is not found the first time
// we load after deleting Library folder)
if (s_PreviewMaterial == null)
{
s_PreviewMaterial = new Material(Shader.Find("Debug/ReflectionProbePreview"))
{
hideFlags = HideFlags.HideAndDontSave
};
}
var material = meshRenderer.sharedMaterial;
if (material == null ||
material == s_PreviewMaterial ||
material.shader != s_PreviewMaterial.shader)
{
material = Object.Instantiate(s_PreviewMaterial);
material.SetTexture(_Cubemap, p.texture);
material.hideFlags = HideFlags.HideAndDontSave;
meshRenderer.material = material;
}
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion;
}
static void SetupCameraForRender(Camera camera, HDAdditionalReflectionData additional, Camera viewerCamera = null)
{
float nearClipPlane, farClipPlane, aspect, fov;
Color backgroundColor;
CameraClearFlags clearFlags;
Vector3 capturePosition;
Quaternion captureRotation;
Matrix4x4 worldToCamera, projection;
CalculateCaptureCameraProperties(additional,
out nearClipPlane, out farClipPlane,
out aspect, out fov, out clearFlags, out backgroundColor,
out worldToCamera, out projection,
out capturePosition, out captureRotation, viewerCamera);
camera.farClipPlane = farClipPlane;
camera.nearClipPlane = nearClipPlane;
camera.fieldOfView = fov;
camera.aspect = aspect;
camera.clearFlags = clearFlags;
camera.backgroundColor = camera.backgroundColor;
camera.projectionMatrix = projection;
camera.worldToCameraMatrix = worldToCamera;
camera.cullingMask = additional.reflectionProbe.cullingMask;
var ctr = camera.transform;
ctr.position = capturePosition;
ctr.rotation = captureRotation;
}
static void Gizmos_Influence(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, bool isEdit)
{
var col = Gizmos.color;
var mat = Gizmos.matrix;
Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
switch (a.influenceShape)
{
case ShapeType.Box:
{
Gizmos.color = k_GizmoThemeColorExtentFace;
e.m_UIState.alternativeBoxInfluenceHandle.DrawHull(isEdit);
break;
}
case ShapeType.Sphere:
{
Gizmos.color = k_GizmoThemeColorExtentFace;
if (isEdit)
{
Gizmos.DrawSphere(p.center, a.influenceSphereRadius);
}
else
{
Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius);
}
break;
}
}
Gizmos.matrix = mat;
Gizmos.color = col;
}
public void Render(HDAdditionalReflectionData additional, RenderTexture target, Camera viewerCamera = null)
{
var renderCamera = GetRenderCamera();
// Copy current frameSettings of this probe to the HDAdditionalData of the render camera
//probe.frameSettings.CopyTo(s_RenderCameraData.GetFrameSettings());
SetupCameraForRender(renderCamera, additional, viewerCamera);
renderCamera.RenderToCubemap(target);
target.IncrementUpdateCount();
}
public RenderTexture NewRenderTarget(HDAdditionalReflectionData probe)
{
var rt = new RenderTexture(m_Parameters.reflectionProbeSize, m_Parameters.reflectionProbeSize, 0, RenderTextureFormat.ARGBHalf);
// No hide and don't save for this one
rt.useMipMap = true;
rt.autoGenerateMips = false;
rt.name = CoreUtils.GetRenderTargetAutoName(m_Parameters.reflectionProbeSize, m_Parameters.reflectionProbeSize, 1, RenderTextureFormat.ARGBHalf, "ProbeRT");
rt.dimension = TextureDimension.Cube;
rt.Create();
return(rt);
}
static void Gizmos_CapturePoint(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e)
{
if (sphere == null)
{
sphere = Resources.GetBuiltinResource <Mesh>("New-Sphere.fbx");
}
if (material == null)
{
material = new Material(Shader.Find("Debug/ReflectionProbePreview"));
}
material.SetTexture("_Cubemap", p.texture);
material.SetPass(0);
Graphics.DrawMeshNow(sphere, Matrix4x4.TRS(p.transform.position, Quaternion.identity, Vector3.one));
}
IEnumerator Start()
{
yield return(new WaitForSeconds(0.5f));
foreach (var probe in refProbe)
{
Lightmapping.BakeReflectionProbe(probe, "Assets/" + probe.ToString() + ".hdr");
HDAdditionalReflectionData addRefData = probe.gameObject.GetComponent <HDAdditionalReflectionData>();
Texture texture = (Texture)AssetDatabase.LoadAssetAtPath("Assets/" + probe.ToString() + ".hdr", typeof(Texture));
addRefData.bakedTexture = texture;
yield return(null);
}
}
public static void CalculateCaptureCameraProperties(HDAdditionalReflectionData additional, out float nearClipPlane, out float farClipPlane, out float aspect, out float fov, out CameraClearFlags clearFlags, out Color backgroundColor, out Matrix4x4 worldToCamera, out Matrix4x4 projection, out Vector3 capturePosition, out Quaternion captureRotation, Camera viewerCamera = null)
{
nearClipPlane = additional.reflectionProbe.nearClipPlane;
farClipPlane = additional.reflectionProbe.farClipPlane;
aspect = 1f;
fov = 90f;
clearFlags = CameraClearFlags.Nothing;
backgroundColor = Color.white;
capturePosition = additional.capturePosition;
captureRotation = Quaternion.identity;
worldToCamera = GeometryUtils.CalculateWorldToCameraMatrixRHS(capturePosition, captureRotation);
projection = Matrix4x4.Perspective(fov, aspect, nearClipPlane, farClipPlane);
}
protected virtual UnityEngine.Object[] GetHDReflectionProbes()
{
#if UNITY_2020_1_OR_NEWER
var reflectionProbes = Resources.FindObjectsOfTypeAll <ReflectionProbe>();
#else
var reflectionProbes = UnityEngine.Object.FindObjectsOfType <ReflectionProbe>();
#endif
foreach (ReflectionProbe probe in reflectionProbes)
{
HDAdditionalReflectionData hdAdditionalReflectionData = probe.GetComponent <HDAdditionalReflectionData>();
serializedReflectionProbeDataPairing[probe] = hdAdditionalReflectionData != null ? new SerializedObject(hdAdditionalReflectionData) : null;
}
return(reflectionProbes);
}
public void RegisterProbe(HDAdditionalReflectionData additional)
{
m_AdditionalDataReflectionProbes.Add(additional);
//SetProbeBoundsDirty(probe);
if (additional.mode == ReflectionProbeMode.Realtime)
{
//switch (additional.refreshMode)
//{
// case ReflectionProbeRefreshMode.OnAwake:
// m_AdditionalDataReflectionProbe_RequestRealtimeRender.Add(additional);
// break;
// case ReflectionProbeRefreshMode.EveryFrame:
m_AdditionalDataReflectionProbe_RealtimeUpdate.Add(additional);
// break;
//}
}
}
static void ResetReflectionProbe(MenuCommand menuCommand)
{
GameObject go = ((ReflectionProbe)menuCommand.context).gameObject;
Assert.IsNotNull(go);
ReflectionProbe reflectionProbe = go.GetComponent <ReflectionProbe>();
HDAdditionalReflectionData reflectionProbeAdditionalData = go.GetComponent <HDAdditionalReflectionData>();
Assert.IsNotNull(reflectionProbe);
Assert.IsNotNull(reflectionProbeAdditionalData);
Undo.SetCurrentGroupName("Reset HD Reflection Probe");
Undo.RecordObjects(new UnityEngine.Object[] { reflectionProbe, reflectionProbeAdditionalData }, "Reset HD Reflection Probe");
reflectionProbe.Reset();
// To avoid duplicating init code we copy default settings to Reset additional data
// Note: we can't call this code inside the HDAdditionalReflectionData, thus why we don't wrap it in Reset() function
EditorUtility.CopySerialized(HDUtils.s_DefaultHDAdditionalReflectionData, reflectionProbeAdditionalData);
}
public SerializedHDReflectionProbe(SerializedObject so, SerializedObject addso)
{
this.so = so;
this.addso = addso;
target = (ReflectionProbe)so.targetObject;
targetData = target.GetComponent <HDAdditionalReflectionData>();
mode = so.FindProperty("m_Mode");
customBakedTexture = so.FindProperty("m_CustomBakedTexture");
renderDynamicObjects = so.FindProperty("m_RenderDynamicObjects");
refreshMode = so.FindProperty("m_RefreshMode");
timeSlicingMode = so.FindProperty("m_TimeSlicingMode");
intensityMultiplier = so.FindProperty("m_IntensityMultiplier");
boxSize = so.FindProperty("m_BoxSize");
boxOffset = so.FindProperty("m_BoxOffset");
resolution = so.FindProperty("m_Resolution");
shadowDistance = so.FindProperty("m_ShadowDistance");
cullingMask = so.FindProperty("m_CullingMask");
useOcclusionCulling = so.FindProperty("m_UseOcclusionCulling");
nearClip = so.FindProperty("m_NearClip");
farClip = so.FindProperty("m_FarClip");
boxProjection = so.FindProperty("m_BoxProjection");
legacyBlendDistance = so.FindProperty("m_BlendDistance");
influenceShape = addso.Find((HDAdditionalReflectionData d) => d.influenceShape);
influenceSphereRadius = addso.Find((HDAdditionalReflectionData d) => d.influenceSphereRadius);
useSeparateProjectionVolume = addso.Find((HDAdditionalReflectionData d) => d.useSeparateProjectionVolume);
boxReprojectionVolumeSize = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeSize);
boxReprojectionVolumeCenter = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeCenter);
sphereReprojectionVolumeRadius = addso.Find((HDAdditionalReflectionData d) => d.sphereReprojectionVolumeRadius);
dimmer = addso.Find((HDAdditionalReflectionData d) => d.dimmer);
blendDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendDistancePositive);
blendDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendDistanceNegative);
blendNormalDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistancePositive);
blendNormalDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistanceNegative);
boxSideFadePositive = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadePositive);
boxSideFadeNegative = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadeNegative);
proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolumeComponent);
}
void OnEnable()
{
var additionalData = CoreEditorUtils.GetAdditionalData <HDAdditionalReflectionData>(targets);
m_AdditionalDataSerializedObject = new SerializedObject(additionalData);
m_SerializedHdReflectionProbe = new SerializedHDReflectionProbe(serializedObject, m_AdditionalDataSerializedObject);
m_UIState.owner = this;
m_UIState.Reset(m_SerializedHdReflectionProbe, Repaint);
foreach (var t in targets)
{
var p = (ReflectionProbe)t;
s_ReflectionProbeEditors[p] = this;
}
InitializeAllTargetProbes();
HDAdditionalReflectionData probe = (HDAdditionalReflectionData)m_AdditionalDataSerializedObject.targetObject;
probe.influenceVolume.Init(probe);
}
static void Gizmos_Influence(ReflectionProbe p, HDAdditionalReflectionData a, Editor e, bool isEdit)
{
var col = Gizmos.color;
var mat = Gizmos.matrix;
Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
switch (a.influenceShape)
{
case ReflectionInfluenceShape.Box:
{
Gizmos.color = isEdit ? k_GizmoThemeColorExtentFace : k_GizmoThemeColorExtent;
if (isEdit)
{
Gizmos.DrawCube(p.center, p.size);
}
else
{
Gizmos.DrawWireCube(p.center, p.size);
}
break;
}
case ReflectionInfluenceShape.Sphere:
{
Gizmos.color = k_GizmoThemeColorExtentFace;
if (isEdit)
{
Gizmos.DrawSphere(p.center, a.influenceSphereRadius);
}
else
{
Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius);
}
break;
}
}
Gizmos.matrix = mat;
Gizmos.color = col;
}
internal static void InitializeProbe(ReflectionProbe p, HDAdditionalReflectionData data)
{
var meshFilter = p.GetComponent <MeshFilter>() ?? p.gameObject.AddComponent <MeshFilter>();
var meshRenderer = p.GetComponent <MeshRenderer>() ?? p.gameObject.AddComponent <MeshRenderer>();
meshFilter.sharedMesh = s_SphereMesh;
var material = meshRenderer.sharedMaterial;
if (material == null ||
material == s_PreviewMaterial ||
material.shader != s_PreviewMaterial.shader)
{
material = Object.Instantiate(s_PreviewMaterial);
material.SetTexture(_Cubemap, p.texture);
material.hideFlags = HideFlags.HideAndDontSave;
meshRenderer.material = material;
}
meshRenderer.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
meshRenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
meshRenderer.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion;
}
static void Gizmos_InfluenceFade(ReflectionProbe p, HDAdditionalReflectionData a, Editor e, InfluenceType type, bool isEdit)
{
var col = Gizmos.color;
var mat = Gizmos.matrix;
Vector3 boxCenterOffset;
Vector3 boxSizeOffset;
float sphereRadiusOffset;
Color color;
switch (type)
{
default:
case InfluenceType.Standard:
{
boxCenterOffset = a.boxBlendCenterOffset;
boxSizeOffset = a.boxBlendSizeOffset;
sphereRadiusOffset = a.sphereBlendRadiusOffset;
color = isEdit ? k_GizmoThemeColorInfluenceBlendFace : k_GizmoThemeColorInfluenceBlend;
break;
}
case InfluenceType.Normal:
{
boxCenterOffset = a.boxBlendNormalCenterOffset;
boxSizeOffset = a.boxBlendNormalSizeOffset;
sphereRadiusOffset = a.sphereBlendNormalRadiusOffset;
color = isEdit ? k_GizmoThemeColorInfluenceNormalBlendFace : k_GizmoThemeColorInfluenceNormalBlend;
break;
}
}
Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
switch (a.influenceShape)
{
case ReflectionInfluenceShape.Box:
{
Gizmos.color = color;
if (isEdit)
{
Gizmos.DrawCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
}
else
{
Gizmos.DrawWireCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
}
break;
}
case ReflectionInfluenceShape.Sphere:
{
Gizmos.color = color;
if (isEdit)
{
Gizmos.DrawSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
}
else
{
Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
}
break;
}
}
Gizmos.matrix = mat;
Gizmos.color = col;
}
public SerializedHDReflectionProbe(SerializedObject so, SerializedObject addso)
{
this.so = so;
this.addso = addso;
target = (ReflectionProbe)so.targetObject;
targetData = target.GetComponent <HDAdditionalReflectionData>();
mode = so.FindProperty("m_Mode");
customBakedTexture = so.FindProperty("m_CustomBakedTexture");
renderDynamicObjects = so.FindProperty("m_RenderDynamicObjects");
refreshMode = so.FindProperty("m_RefreshMode");
timeSlicingMode = so.FindProperty("m_TimeSlicingMode");
intensityMultiplier = so.FindProperty("m_IntensityMultiplier");
boxSize = so.FindProperty("m_BoxSize");
boxOffset = so.FindProperty("m_BoxOffset");
resolution = so.FindProperty("m_Resolution");
shadowDistance = so.FindProperty("m_ShadowDistance");
cullingMask = so.FindProperty("m_CullingMask");
useOcclusionCulling = so.FindProperty("m_UseOcclusionCulling");
nearClip = so.FindProperty("m_NearClip");
farClip = so.FindProperty("m_FarClip");
boxProjection = so.FindProperty("m_BoxProjection");
legacyBlendDistance = so.FindProperty("m_BlendDistance");
influenceShape = addso.Find((HDAdditionalReflectionData d) => d.influenceShape);
influenceSphereRadius = addso.Find((HDAdditionalReflectionData d) => d.influenceSphereRadius);
useSeparateProjectionVolume = addso.Find((HDAdditionalReflectionData d) => d.useSeparateProjectionVolume);
boxReprojectionVolumeSize = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeSize);
boxReprojectionVolumeCenter = addso.Find((HDAdditionalReflectionData d) => d.boxReprojectionVolumeCenter);
sphereReprojectionVolumeRadius = addso.Find((HDAdditionalReflectionData d) => d.sphereReprojectionVolumeRadius);
weight = addso.Find((HDAdditionalReflectionData d) => d.weight);
multiplier = addso.Find((HDAdditionalReflectionData d) => d.multiplier);
blendDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendDistancePositive);
blendDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendDistanceNegative);
blendNormalDistancePositive = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistancePositive);
blendNormalDistanceNegative = addso.Find((HDAdditionalReflectionData d) => d.blendNormalDistanceNegative);
boxSideFadePositive = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadePositive);
boxSideFadeNegative = addso.Find((HDAdditionalReflectionData d) => d.boxSideFadeNegative);
editorAdvancedModeBlendDistancePositive = addso.FindProperty("editorAdvancedModeBlendDistancePositive");
editorAdvancedModeBlendDistanceNegative = addso.FindProperty("editorAdvancedModeBlendDistanceNegative");
editorSimplifiedModeBlendDistance = addso.FindProperty("editorSimplifiedModeBlendDistance");
editorAdvancedModeBlendNormalDistancePositive = addso.FindProperty("editorAdvancedModeBlendNormalDistancePositive");
editorAdvancedModeBlendNormalDistanceNegative = addso.FindProperty("editorAdvancedModeBlendNormalDistanceNegative");
editorSimplifiedModeBlendNormalDistance = addso.FindProperty("editorSimplifiedModeBlendNormalDistance");
editorAdvancedModeEnabled = addso.FindProperty("editorAdvancedModeEnabled");
//handle data migration from before editor value were saved
if (editorAdvancedModeBlendDistancePositive.vector3Value == Vector3.zero &&
editorAdvancedModeBlendDistanceNegative.vector3Value == Vector3.zero &&
editorSimplifiedModeBlendDistance.floatValue == 0f &&
editorAdvancedModeBlendNormalDistancePositive.vector3Value == Vector3.zero &&
editorAdvancedModeBlendNormalDistanceNegative.vector3Value == Vector3.zero &&
editorSimplifiedModeBlendNormalDistance.floatValue == 0f &&
(blendDistancePositive.vector3Value != Vector3.zero ||
blendDistanceNegative.vector3Value != Vector3.zero ||
blendNormalDistancePositive.vector3Value != Vector3.zero ||
blendNormalDistanceNegative.vector3Value != Vector3.zero))
{
Vector3 positive = blendDistancePositive.vector3Value;
Vector3 negative = blendDistanceNegative.vector3Value;
//exact advanced
editorAdvancedModeBlendDistancePositive.vector3Value = positive;
editorAdvancedModeBlendDistanceNegative.vector3Value = negative;
//aproximated simplified
editorSimplifiedModeBlendDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
positive = blendNormalDistancePositive.vector3Value;
negative = blendNormalDistanceNegative.vector3Value;
//exact advanced
editorAdvancedModeBlendNormalDistancePositive.vector3Value = positive;
editorAdvancedModeBlendNormalDistanceNegative.vector3Value = negative;
//aproximated simplified
editorSimplifiedModeBlendNormalDistance.floatValue = Mathf.Max(positive.x, positive.y, positive.z, negative.x, negative.y, negative.z);
//display old data
editorAdvancedModeEnabled.boolValue = true;
Apply();
}
proxyVolumeComponent = addso.Find((HDAdditionalReflectionData d) => d.proxyVolume);
}
static void SetupCameraForRender(Camera camera, HDAdditionalCameraData additionalData, HDAdditionalReflectionData additional)
{
Vector3 capturePosition = additional.capturePosition;
Quaternion captureRotation = Quaternion.identity;
float nearClipPlane = additional.captureSettings.nearClipPlane;
float farClipPlane = additional.captureSettings.farClipPlane;
float aspect = 1f;
float fov = additional.captureSettings.fieldOfView;
camera.clearFlags = CameraClearFlags.Nothing;
camera.backgroundColor = Color.white;
camera.aspect = 1f;
additionalData.backgroundColorHDR = additional.captureSettings.backgroundColorHDR;
additionalData.clearColorMode = additional.captureSettings.clearColorMode;
additionalData.clearDepth = additional.captureSettings.clearDepth;
camera.cullingMask = additional.captureSettings.cullingMask;
additionalData.volumeLayerMask = additional.captureSettings.volumeLayerMask;
additionalData.volumeAnchorOverride = additional.captureSettings.volumeAnchorOverride;
camera.useOcclusionCulling = additional.captureSettings.useOcclusionCulling;
camera.orthographic = additional.captureSettings.projection == CameraProjection.Orthographic;
camera.farClipPlane = farClipPlane;
camera.nearClipPlane = nearClipPlane;
camera.fieldOfView = fov;
camera.orthographicSize = additional.captureSettings.orthographicSize;
//additionalData.aperture = additional.captureSettings.aperture;
//additionalData.shutterspeed = additional.captureSettings.shutterspeed;
//additionalData.iso = additional.captureSettings.iso;
additionalData.renderingPath = additional.captureSettings.renderingPath;
SetupFrameSettings(additionalData, additional);
camera.projectionMatrix = Matrix4x4.Perspective(fov, aspect, nearClipPlane, farClipPlane);
camera.worldToCameraMatrix = GeometryUtils.CalculateWorldToCameraMatrixRHS(capturePosition, captureRotation);
var ctr = camera.transform;
ctr.position = capturePosition;
ctr.rotation = captureRotation;
}
static void Gizmos_InfluenceFade(ReflectionProbe p, HDAdditionalReflectionData a, HDReflectionProbeEditor e, InfluenceType type, bool isEdit)
{
var col = Gizmos.color;
var mat = Gizmos.matrix;
Gizmo6FacesBoxContained box;
Vector3 boxCenterOffset;
Vector3 boxSizeOffset;
float sphereRadiusOffset;
Color color;
switch (type)
{
default:
case InfluenceType.Standard:
{
box = e != null ? e.m_UIState.alternativeBoxBlendHandle : null;
boxCenterOffset = a.boxBlendCenterOffset;
boxSizeOffset = a.boxBlendSizeOffset;
sphereRadiusOffset = a.sphereBlendRadiusOffset;
color = isEdit ? k_GizmoThemeColorInfluenceBlendFace : k_GizmoThemeColorInfluenceBlend;
break;
}
case InfluenceType.Normal:
{
box = e != null ? e.m_UIState.alternativeBoxBlendNormalHandle : null;
boxCenterOffset = a.boxBlendNormalCenterOffset;
boxSizeOffset = a.boxBlendNormalSizeOffset;
sphereRadiusOffset = a.sphereBlendNormalRadiusOffset;
color = isEdit ? k_GizmoThemeColorInfluenceNormalBlendFace : k_GizmoThemeColorInfluenceNormalBlend;
break;
}
}
Gizmos.matrix = HDReflectionProbeEditorUtility.GetLocalSpace(p);
switch (a.influenceShape)
{
case ShapeType.Box:
{
Gizmos.color = color;
if (e != null) // e == null may occure when editor have still not been created at selection while the tool is not used for this part
{
box.DrawHull(isEdit);
}
else
{
if (isEdit)
{
Gizmos.DrawCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
}
else
{
Gizmos.DrawWireCube(p.center + boxCenterOffset, p.size + boxSizeOffset);
}
}
break;
}
case ShapeType.Sphere:
{
Gizmos.color = color;
if (isEdit)
{
Gizmos.DrawSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
}
else
{
Gizmos.DrawWireSphere(p.center, a.influenceSphereRadius + sphereRadiusOffset);
}
break;
}
}
Gizmos.matrix = mat;
Gizmos.color = col;
}
/// <summary>
/// Setup for the automatically probe spawning
/// </summary>
/// <param name="profile"></param>
public static void CreateAutomaticProbes(AmbientLightingProfile profile, AmbientSkiesConsts.RenderPipelineSettings renderPipelineSettings)
{
GameObject oldReflectionProbe = GameObject.Find("Global Reflection Probe");
if (oldReflectionProbe != null)
{
Object.DestroyImmediate(oldReflectionProbe);
Debug.Log("Old Reflection Probe Destroyed");
}
GameObject relfectionParentObject = ReflectionProbeParenting(true);
int numberTerrains = Terrain.activeTerrains.Length;
if (numberTerrains == 0)
{
Debug.LogError("Unable to initiate probe spawning systen. No terrain found");
return;
}
else
{
if (profile.reflectionProbesPerRow < 2)
{
Debug.LogError("Please set Probes Per Row to a value of 2 or higher");
return;
}
else
{
m_currentProbeCount = 0;
float seaLevel = 0f;
bool seaLevelActive = false;
#if GAIA_PRESENT
Gaia.GaiaSessionManager gaiaSession = Object.FindObjectOfType <Gaia.GaiaSessionManager>();
if (gaiaSession != null)
{
seaLevel = profile.seaLevel;
seaLevelActive = true;
}
#else
seaLevel = profile.seaLevel;
#endif
for (int terrainIdx = 0; terrainIdx < numberTerrains; terrainIdx++)
{
Terrain terrain = Terrain.activeTerrains[terrainIdx];
Vector3 terrainSize = terrain.terrainData.size;
for (int row = 0; row < profile.reflectionProbesPerRow; ++row)
{
for (int columns = 0; columns < profile.reflectionProbesPerRow; ++columns)
{
GameObject probeObject = new GameObject("Global Generated Reflection Probe");
Vector3 newPosition = probeObject.transform.position;
newPosition.x = ((columns + 1) * terrainSize.x / profile.reflectionProbesPerRow) - terrainSize.x / profile.reflectionProbesPerRow / 2f + terrain.transform.position.x;
newPosition.z = ((row + 1) * terrainSize.z / profile.reflectionProbesPerRow) - terrainSize.z / profile.reflectionProbesPerRow / 2f + terrain.transform.position.z;
float sampledHeight = terrain.SampleHeight(newPosition);
ReflectionProbe probeData = probeObject.AddComponent <ReflectionProbe>();
probeData.enabled = false;
probeData.blendDistance = 0f;
probeData.cullingMask = profile.reflectionprobeCullingMask;
probeData.farClipPlane = profile.reflectionProbeClipPlaneDistance;
probeData.mode = profile.reflectionProbeMode;
probeData.refreshMode = profile.reflectionProbeRefresh;
if (seaLevelActive)
{
newPosition.y = 500f + seaLevel + 0.2f;
}
else
{
newPosition.y = sampledHeight + profile.reflectionProbeOffset;
probeData.center = new Vector3(0f, 0f - profile.reflectionProbeOffset - sampledHeight, 0f);
}
probeObject.transform.position = newPosition;
probeObject.transform.SetParent(relfectionParentObject.transform);
switch (profile.reflectionProbeResolution)
{
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution16:
probeData.resolution = 16;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution32:
probeData.resolution = 32;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution64:
probeData.resolution = 64;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution128:
probeData.resolution = 128;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution256:
probeData.resolution = 256;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution512:
probeData.resolution = 512;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution1024:
probeData.resolution = 1024;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution2048:
probeData.resolution = 2048;
break;
}
probeData.shadowDistance = 80f;
probeData.size = new Vector3(terrainSize.x / profile.reflectionProbesPerRow, terrainSize.y, terrainSize.z / profile.reflectionProbesPerRow);
probeData.timeSlicingMode = profile.reflectionProbeTimeSlicingMode;
probeData.hdr = true;
probeData.shadowDistance = profile.reflectionProbeShadowDistance;
//If HDRP
if (renderPipelineSettings == AmbientSkiesConsts.RenderPipelineSettings.HighDefinition)
{
#if HDPipeline && UNITY_2018_3_OR_NEWER
HDAdditionalReflectionData reflectionData = probeObject.GetComponent <HDAdditionalReflectionData>();
if (reflectionData == null)
{
reflectionData = probeObject.AddComponent <HDAdditionalReflectionData>();
reflectionData.multiplier = 1f;
}
else
{
reflectionData.multiplier = 1f;
}
#endif
}
m_storedProbes.Add(probeData);
m_currentProbeCount++;
}
}
}
#if HDPipeline && GAIA_PRESENT
if (seaLevelActive)
{
GameObject planarObject = GameObject.Find("Gaia Water Planar Reflections Object");
if (planarObject == null)
{
planarObject = new GameObject("Gaia Water Planar Reflections Object");
PlanarReflectionProbe planar = planarObject.AddComponent <PlanarReflectionProbe>();
planar.mode = ProbeSettings.Mode.Realtime;
planar.realtimeMode = ProbeSettings.RealtimeMode.OnEnable;
planar.influenceVolume.shape = InfluenceShape.Box;
planar.influenceVolume.boxSize = new Vector3(10000f, 5f, 10000f);
planarObject.transform.position = new Vector3(0f, profile.seaLevel + 0.2f, 0f);
planarObject.transform.SetParent(relfectionParentObject.transform);
}
}
#endif
m_probeRenderActive = true;
}
}
}
/// <summary>
/// Creates a reflection probe at current scene view camera location
/// </summary>
/// <param name="profile"></param>
/// <param name="renderPipelineSettings"></param>
public static void CreateProbeAtLocation(AmbientLightingProfile profile, AmbientSkiesConsts.RenderPipelineSettings renderPipelineSettings)
{
GameObject oldReflectionProbe = GameObject.Find("Global Reflection Probe");
if (oldReflectionProbe != null)
{
Object.DestroyImmediate(oldReflectionProbe);
Debug.Log("Old Reflection Probe Destroyed");
}
//Creates the probe
GameObject createdProbeObject = new GameObject(profile.reflectionProbeName);
//Assign scene view camera
Vector3 position = SceneView.lastActiveSceneView.camera.transform.position;
if (SceneView.lastActiveSceneView.pivot != position)
{
//Set position based on scene view camera position
createdProbeObject.transform.localPosition = position;
}
else
{
Debug.LogWarning("Scene View camera not found, probe spawned at position 0, 0, 0");
}
//Parent the probe object
GameObject reflectionProbeParent = ReflectionProbeParenting(true);
createdProbeObject.transform.SetParent(reflectionProbeParent.transform);
//Add probe data
ReflectionProbe probeData = createdProbeObject.AddComponent <ReflectionProbe>();
//Configure Probe settings
probeData.blendDistance = profile.reflectionProbeBlendDistance;
probeData.cullingMask = profile.reflectionprobeCullingMask;
probeData.farClipPlane = profile.reflectionProbeClipPlaneDistance;
probeData.mode = profile.reflectionProbeMode;
probeData.refreshMode = profile.reflectionProbeRefresh;
probeData.blendDistance = 5f;
switch (profile.reflectionProbeResolution)
{
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution16:
probeData.resolution = 16;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution32:
probeData.resolution = 32;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution64:
probeData.resolution = 64;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution128:
probeData.resolution = 128;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution256:
probeData.resolution = 256;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution512:
probeData.resolution = 512;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution1024:
probeData.resolution = 1024;
break;
case AmbientSkiesConsts.ReflectionProbeResolution.Resolution2048:
probeData.resolution = 2048;
break;
}
probeData.shadowDistance = profile.reflectionProbeShadowDistance;
probeData.size = profile.reflectionProbeScale;
probeData.timeSlicingMode = profile.reflectionProbeTimeSlicingMode;
probeData.hdr = true;
probeData.shadowDistance = profile.reflectionProbeShadowDistance;
//If HDRP
if (renderPipelineSettings == AmbientSkiesConsts.RenderPipelineSettings.HighDefinition)
{
#if HDPipeline && UNITY_2018_3_OR_NEWER
HDAdditionalReflectionData reflectionData = createdProbeObject.GetComponent <HDAdditionalReflectionData>();
if (reflectionData == null)
{
reflectionData = createdProbeObject.AddComponent <HDAdditionalReflectionData>();
reflectionData.multiplier = 1f;
}
else
{
reflectionData.multiplier = 1f;
}
#endif
}
m_currentProbeCount++;
SceneView.lastActiveSceneView.Repaint();
EditorGUIUtility.PingObject(createdProbeObject);
}
/// <summary>
/// Creates a single Reflection Probe in the given position
/// </summary>
/// <param name="position"></param>
/// <param name="terrain"></param>
/// <param name="reflectionProbeData"></param>
/// <param name="seaLevelActive"></param>
/// <param name="seaLevel"></param>
/// <param name="parentTransform"></param>
/// <param name="isHDRP"></param>
/// <returns></returns>
public static ReflectionProbe CreateReflectionProbe(Vector3 position, Vector3 size, Terrain terrain, ReflectionProbeData reflectionProbeData, bool seaLevelActive, float seaLevel, Transform parentTransform, bool isHDRP, bool probeCulling = false)
{
GameObject probeObject = new GameObject("Global Generated Reflection Probe");
float sampledHeight = terrain.SampleHeight(position);
ReflectionProbe reflectionProbe = probeObject.AddComponent <ReflectionProbe>();
reflectionProbe.enabled = false;
reflectionProbe.blendDistance = 0f;
reflectionProbe.cullingMask = reflectionProbeData.reflectionprobeCullingMask;
reflectionProbe.farClipPlane = reflectionProbeData.reflectionProbeClipPlaneDistance;
reflectionProbe.mode = reflectionProbeData.reflectionProbeMode;
switch (reflectionProbeData.reflectionProbeRefresh)
{
case GaiaConstants.ReflectionProbeRefreshModePW.OnAwake:
reflectionProbe.refreshMode = ReflectionProbeRefreshMode.OnAwake;
break;
case GaiaConstants.ReflectionProbeRefreshModePW.EveryFrame:
reflectionProbe.refreshMode = ReflectionProbeRefreshMode.EveryFrame;
break;
case GaiaConstants.ReflectionProbeRefreshModePW.ViaScripting:
reflectionProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
break;
case GaiaConstants.ReflectionProbeRefreshModePW.ProbeManager:
reflectionProbe.refreshMode = ReflectionProbeRefreshMode.ViaScripting;
break;
}
if (!seaLevelActive)
{
position.y = 500f + seaLevel + 0.2f;
}
else
{
position.y = sampledHeight + reflectionProbeData.reflectionProbeOffset;
reflectionProbe.center = new Vector3(0f, 0f - reflectionProbeData.reflectionProbeOffset - sampledHeight, 0f);
}
if (position.y < seaLevel)
{
position.y = seaLevel + reflectionProbeData.reflectionProbeOffset;
}
probeObject.transform.position = position;
probeObject.transform.SetParent(parentTransform);
switch (reflectionProbeData.reflectionProbeResolution)
{
case GaiaConstants.ReflectionProbeResolution.Resolution16:
reflectionProbe.resolution = 16;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution32:
reflectionProbe.resolution = 32;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution64:
reflectionProbe.resolution = 64;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution128:
reflectionProbe.resolution = 128;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution256:
reflectionProbe.resolution = 256;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution512:
reflectionProbe.resolution = 512;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution1024:
reflectionProbe.resolution = 1024;
break;
case GaiaConstants.ReflectionProbeResolution.Resolution2048:
reflectionProbe.resolution = 2048;
break;
}
reflectionProbe.shadowDistance = 80f;
reflectionProbe.size = size;
reflectionProbe.timeSlicingMode = reflectionProbeData.reflectionProbeTimeSlicingMode;
reflectionProbe.hdr = true;
reflectionProbe.shadowDistance = reflectionProbeData.reflectionProbeShadowDistance;
//If HDRP
if (isHDRP)
{
#if HDPipeline
HDAdditionalReflectionData reflectionData = probeObject.GetComponent <HDAdditionalReflectionData>();
if (reflectionData == null)
{
reflectionData = probeObject.AddComponent <HDAdditionalReflectionData>();
}
reflectionData.multiplier = 1f;
reflectionData.realtimeMode = ProbeSettings.RealtimeMode.OnEnable;
#endif
}
#if GAIA_PRO_PRESENT
ReflectionProbeCuller culler = reflectionProbe.GetComponent <ReflectionProbeCuller>();
if (probeCulling)
{
if (culler == null)
{
culler = reflectionProbe.gameObject.AddComponent <ReflectionProbeCuller>();
culler.m_probe = reflectionProbe;
culler.Initialize();
}
}
else
{
if (culler != null)
{
GameObject.DestroyImmediate(culler);
}
}
#endif
return(reflectionProbe);
}
public void UnregisterProbe(HDAdditionalReflectionData additional)
{
m_AdditionalDataReflectionProbes.Remove(additional);
m_AdditionalDataReflectionProbe_RequestRealtimeRender.Remove(additional);
m_AdditionalDataReflectionProbe_RealtimeUpdate.Remove(additional);
}
/// <summary>
/// Start function
/// </summary>
void Start()
{
#if UNITY_POST_PROCESSING_STACK_V2
transitionPostFX = GameObject.Find("Underwater Transition PostFX").GetComponent <PostProcessVolume>();
underwaterPostFX = GameObject.Find("Underwater PostFX").GetComponent <PostProcessVolume>();
if (Application.isPlaying)
{
if (transitionPostFX != null)
{
transitionPostFX.enabled = true;
}
if (underwaterPostFX != null)
{
underwaterPostFX.enabled = true;
}
}
else
{
if (transitionPostFX != null)
{
transitionPostFX.enabled = false;
}
if (underwaterPostFX != null)
{
underwaterPostFX.enabled = false;
}
}
#endif
if (m_gaiaSettings == null)
{
m_gaiaSettings = GaiaUtils.GetGaiaSettings();
}
if (m_gaiaSceneInfo == null)
{
m_gaiaSceneInfo = GaiaSceneInfo.GetSceneInfo();
}
if (m_gaiaSettings != null)
{
m_currentRenderer = m_gaiaSettings.m_currentRenderer;
}
#if HDPipeline
if (m_currentRenderer == GaiaConstants.EnvironmentRenderer.HighDefinition2018x)
{
GameObject underwaterProbe = GameObject.Find("Underwater Reflection Probe");
if (underwaterProbe != null)
{
m_underwaterProbe = GameObject.Find("Underwater Reflection Probe").GetComponent <ReflectionProbe>();
}
}
#endif
GameObject waterPlanar = GameObject.Find("Water Planar Reflections");
if (waterPlanar != null)
{
ReflectionProbe reflection = GameObject.Find("Water Planar Reflections").GetComponent <ReflectionProbe>();
{
if (reflection != null)
{
reflection.mode = UnityEngine.Rendering.ReflectionProbeMode.Custom;
}
#if HDPipeline
HDAdditionalReflectionData reflectionData = GameObject.Find("Water Planar Reflections").GetComponent <HDAdditionalReflectionData>();
if (reflectionData != null)
{
#if !UNITY_2019_1_OR_NEWER
reflectionData.mode = UnityEngine.Rendering.ReflectionProbeMode.Custom;
#else
reflectionData.mode = ProbeSettings.Mode.Realtime;
#endif
}
#endif
}
}
#if HDPipeline
if (m_underwaterProbe != null)
{
m_underwaterProbe.enabled = false;
}
#endif
mainlight = gameObject.GetComponent <Light>();
mainlight.cookie = null;
causticsObject = gameObject.transform;
partentObject = GetOrCreateEnvironmentParent().transform;
if (m_currentRenderer == GaiaConstants.EnvironmentRenderer.HighDefinition2018x)
{
#if UNITY_2019_1_OR_NEWER && HDPipeline
postVolume = GameObject.Find("Gaia HDRP Post Processing").GetComponent <Volume>();
volume = GameObject.Find("High Definition Environment Volume").GetComponent <Volume>();
if (volume != null)
{
VolumeProfile profile = volume.sharedProfile;
if (profile != null)
{
VolumetricFog fog;
if (profile.TryGet(out fog))
{
storedFogColor = fog.albedo.value;
storedFogDistance = fog.meanFreePath.value;
}
}
}
#endif
}
else
{
storedFogColor = RenderSettings.fogColor;
storedFogDistance = RenderSettings.fogEndDistance;
}
ambientAudio = null;
if (ambientAudio == null)
{
ambientAudio = GameObject.Find("Ambient Audio");
}
underwaterAudio = null;
if (underwaterAudio == null)
{
underwaterAudio = GameObject.Find("Underwater SoundFX");
}
#if UNITY_EDITOR
if (player == null)
{
player = GetThePlayer();
}
#endif
if (m_gaiaSceneInfo != null)
{
m_sealevel = m_gaiaSceneInfo.m_seaLevel;
}
if (m_useHorizonFix)
{
horizonObject = GameObject.Find("Ambient Underwater Horizon");
if (horizonObjectStored != null)
{
horizonObject = Instantiate(horizonObjectStored);
horizonObject.name = "Ambient Underwater Horizon";
if (partentObject != null)
{
horizonObject.transform.parent = partentObject;
}
MeshRenderer[] theRenders = horizonObject.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer rends in theRenders)
{
rends.enabled = false;
}
}
}
if (m_useUnderwaterparticles)
{
underwaterParticles = GameObject.Find("Underwater Particles Effects");
if (underwaterParticlesStored != null)
{
underwaterParticles = Instantiate(underwaterParticlesStored);
underwaterParticles.name = "Underwater Particles Effects";
underwaterParticles.SetActive(false);
if (partentObject != null)
{
underwaterParticles.transform.parent = partentObject;
}
}
}
if (gameObject.GetComponent <AudioSource>() == null)
{
gameObject.AddComponent <AudioSource>();
objectAudioSource = gameObject.GetComponent <AudioSource>();
objectAudioSource.volume = m_waterSubmergeSounfFXVolume;
}
else
{
objectAudioSource = gameObject.GetComponent <AudioSource>();
objectAudioSource.volume = m_waterSubmergeSounfFXVolume;
}
if (mainlight.type == LightType.Directional)
{
mainlight.cookieSize = m_causticsSize;
}
StopAllCoroutines();
}
