public void MoveContextItemDown(int index) { if (index < 0 || index >= this.m_ContextItems.Count - 1) { return; } DS_HazeContextItem contextItem = this.m_ContextItems[index]; this.m_ContextItems.RemoveAt(index); this.m_ContextItems.Insert(index + 1, contextItem); if (this.m_SoloItem == -1) { return; } if (this.m_SoloItem == index) { ++this.m_SoloItem; } else { if (this.m_SoloItem != index + 1) { return; } --this.m_SoloItem; } }
/// <summary> /// Move the context variant at index up in the list (unless already at the top). /// </summary> /// <param name="index"></param> public void MoveContextItemUp(int index) { if (index < 1 || index >= m_ContextItems.Count) { return; } DS_HazeContextItem tmp = m_ContextItems[index]; m_ContextItems.RemoveAt(index); m_ContextItems.Insert(index - 1, tmp); // Update the solo index. if (m_SoloItem == -1) { return; } if (m_SoloItem == index) { m_SoloItem -= 1; } else if (m_SoloItem == index - 1) { m_SoloItem++; } }
/// <summary> /// Linearly interpolate between this variant and another. /// </summary> /// <param name="other"> DS_HazeContextVariant to interpolate with. </param> /// <param name="dt"> How far through the blend. </param> public void Lerp(DS_HazeContextItem other, float dt) { if (other == null) { #if DEVELOPMENT_BUILD || UNITY_EDITOR Debug.LogError("DeepSky::DS_HazeContextItem:Lerp - null context passed!"); #endif return; } dt = Mathf.Clamp01(dt); float dTinv = 1.0f - dt; m_AirScatteringScale = m_AirScatteringScale * dTinv + other.m_AirScatteringScale * dt; m_AirDensityHeightFalloff = m_AirDensityHeightFalloff * dTinv + other.m_AirDensityHeightFalloff * dt; m_HazeScatteringScale = m_HazeScatteringScale * dTinv + other.m_HazeScatteringScale * dt; m_HazeDensityHeightFalloff = m_HazeDensityHeightFalloff * dTinv + other.m_HazeDensityHeightFalloff * dt; m_HazeScatteringDirection = m_HazeScatteringDirection * dTinv + other.m_HazeScatteringDirection * dt; m_HazeSecondaryScatteringRatio = m_HazeSecondaryScatteringRatio * dTinv + other.m_HazeSecondaryScatteringRatio * dt; m_FogOpacity = m_FogOpacity * dTinv + other.m_FogOpacity * dt; m_FogScatteringScale = m_FogScatteringScale * dTinv + other.m_FogScatteringScale * dt; m_FogExtinctionScale = m_FogExtinctionScale * dTinv + other.m_FogExtinctionScale * dt; m_FogDensityHeightFalloff = m_FogDensityHeightFalloff * dTinv + other.m_FogDensityHeightFalloff * dt; m_FogStartDistance = m_FogStartDistance * dTinv + other.m_FogStartDistance * dt; m_FogScatteringDirection = m_FogScatteringDirection * dTinv + other.m_FogScatteringDirection * dt; m_FogAmbientColour = m_FogAmbientColour * dTinv + other.m_FogAmbientColour * dt; m_FogLightColour = m_FogLightColour * dTinv + other.m_FogLightColour * dt; }
/// <summary> /// Return a DS_HazeContextVariant that has the linearly interpolated values, from top-to-bottom /// in the stack. If a variant is 'soloed', or there's only one, then that is returned as-is. /// </summary> public DS_HazeContextItem GetContextItemBlended(float time = -1) { DS_HazeContextItem blended = new DS_HazeContextItem(); blended.CopyFrom(m_ContextItems[0]); // If there's only the default variant, return it directly. if (m_ContextItems.Count == 1) { return(blended); } // Check for a 'soloed' variant (editor only). #if UNITY_EDITOR if (m_SoloItem > -1 && m_SoloItem < m_ContextItems.Count) { blended.CopyFrom(m_ContextItems[m_SoloItem]); return(blended); } #endif // Created a blended variant. time = Mathf.Clamp01(time); float weight = 0; for (int cv = 1; cv < m_ContextItems.Count; cv++) { weight = m_ContextItems[cv].m_Weight.Evaluate(time); blended.Lerp(m_ContextItems[cv], weight); } return(blended); }
public void Lerp(DS_HazeContextItem other, float dt) { if (other == null) { return; } dt = Mathf.Clamp01(dt); float num = 1f - dt; this.m_AirScatteringScale = (float)((double)this.m_AirScatteringScale * (double)num + (double)other.m_AirScatteringScale * (double)dt); this.m_AirDensityHeightFalloff = (float)((double)this.m_AirDensityHeightFalloff * (double)num + (double)other.m_AirDensityHeightFalloff * (double)dt); this.m_HazeScatteringScale = (float)((double)this.m_HazeScatteringScale * (double)num + (double)other.m_HazeScatteringScale * (double)dt); this.m_HazeDensityHeightFalloff = (float)((double)this.m_HazeDensityHeightFalloff * (double)num + (double)other.m_HazeDensityHeightFalloff * (double)dt); this.m_HazeScatteringDirection = (float)((double)this.m_HazeScatteringDirection * (double)num + (double)other.m_HazeScatteringDirection * (double)dt); this.m_HazeSecondaryScatteringRatio = (float)((double)this.m_HazeSecondaryScatteringRatio * (double)num + (double)other.m_HazeSecondaryScatteringRatio * (double)dt); this.m_FogOpacity = (float)((double)this.m_FogOpacity * (double)num + (double)other.m_FogOpacity * (double)dt); this.m_FogScatteringScale = (float)((double)this.m_FogScatteringScale * (double)num + (double)other.m_FogScatteringScale * (double)dt); this.m_FogExtinctionScale = (float)((double)this.m_FogExtinctionScale * (double)num + (double)other.m_FogExtinctionScale * (double)dt); this.m_FogDensityHeightFalloff = (float)((double)this.m_FogDensityHeightFalloff * (double)num + (double)other.m_FogDensityHeightFalloff * (double)dt); this.m_FogStartDistance = (float)((double)this.m_FogStartDistance * (double)num + (double)other.m_FogStartDistance * (double)dt); this.m_FogScatteringDirection = (float)((double)this.m_FogScatteringDirection * (double)num + (double)other.m_FogScatteringDirection * (double)dt); this.m_FogStartHeight = (float)((double)this.m_FogStartHeight * (double)num + (double)other.m_FogStartHeight * (double)dt); this.m_FogAmbientColour = Color.op_Addition(Color.op_Multiply(this.m_FogAmbientColour, num), Color.op_Multiply(other.m_FogAmbientColour, dt)); this.m_FogLightColour = Color.op_Addition(Color.op_Multiply(this.m_FogLightColour, num), Color.op_Multiply(other.m_FogLightColour, dt)); }
public DS_HazeContextItem GetRenderContextAtPosition(Vector3 position) { List <DS_HazeZone> dsHazeZoneList = new List <DS_HazeZone>(); for (int index = 0; index < this.m_Zones.Count; ++index) { if (this.m_Zones[index].Contains(position) && ((Behaviour)this.m_Zones[index]).get_enabled()) { dsHazeZoneList.Add(this.m_Zones[index]); } } if (dsHazeZoneList.Count == 0) { return((DS_HazeContextItem)null); } if (dsHazeZoneList.Count == 1) { return(dsHazeZoneList[0].Context.GetContextItemBlended(this.m_Time)); } dsHazeZoneList.Sort((Comparison <DS_HazeZone>)((z1, z2) => z1 < z2 ? -1 : 1)); DS_HazeContextItem contextItemBlended = dsHazeZoneList[0].Context.GetContextItemBlended(this.m_Time); for (int index = 1; index < dsHazeZoneList.Count; ++index) { float blendWeight = dsHazeZoneList[index].GetBlendWeight(position); contextItemBlended.Lerp(dsHazeZoneList[index].Context.GetContextItemBlended(this.m_Time), blendWeight); } return(contextItemBlended); }
/// <summary> /// Default constructor - with a 'Default' DS_HazeContextVariant and a time of 0.5 (midday). /// </summary> public DS_HazeContext() { m_ContextItems = new List <DS_HazeContextItem>(); DS_HazeContextItem ctxItem = new DS_HazeContextItem(); ctxItem.m_Name = "Default"; m_ContextItems.Add(ctxItem); }
public void DuplicateContextItem(int index) { if (index < 0 || index >= this.m_ContextItems.Count) { return; } DS_HazeContextItem dsHazeContextItem = new DS_HazeContextItem(); dsHazeContextItem.CopyFrom(this.m_ContextItems[index]); dsHazeContextItem.m_Name += "_Copy"; this.m_ContextItems.Add(dsHazeContextItem); }
public void CopyFrom(DS_HazeContext other) { if (this.m_ContextItems.Count > 0) { this.m_ContextItems.Clear(); } for (int index = 0; index < other.m_ContextItems.Count; ++index) { DS_HazeContextItem dsHazeContextItem = new DS_HazeContextItem(); dsHazeContextItem.CopyFrom(other.m_ContextItems[index]); this.m_ContextItems.Add(dsHazeContextItem); } }
/// <summary> /// Create and add a duplicate of the passed DS_HazeContextVariant. /// </summary> /// <param name="index"> Index into context variants list of the one to duplicate. </param> public void DuplicateContextItem(int index) { if (index < 0 || index >= m_ContextItems.Count) { return; } DS_HazeContextItem dup = new DS_HazeContextItem(); dup.CopyFrom(m_ContextItems[index]); dup.m_Name += "_Copy"; m_ContextItems.Add(dup); }
/// <summary> /// Copy settings and time-of-day variants from another DS_HazeContext. /// </summary> /// <param name="other"> DS_HazeContext to copy from. </param> public void CopyFrom(DS_HazeContext other) { // Clear any existing variants first. if (m_ContextItems.Count > 0) { m_ContextItems.Clear(); } for (int cv = 0; cv < other.m_ContextItems.Count; cv++) { DS_HazeContextItem ctxV = new DS_HazeContextItem(); ctxV.CopyFrom(other.m_ContextItems[cv]); m_ContextItems.Add(ctxV); } }
public void CopyFrom(DS_HazeContextItem other) { if (other == null) { return; } Type type1 = this.GetType(); Type type2 = other.GetType(); foreach (FieldInfo field1 in type1.GetFields()) { FieldInfo field2 = type2.GetField(field1.Name); field1.SetValue((object)this, field2.GetValue((object)other)); } this.m_Weight = new AnimationCurve(this.m_Weight.get_keys()); }
public DS_HazeContextItem GetContextItemBlended(float time = -1f) { DS_HazeContextItem dsHazeContextItem = new DS_HazeContextItem(); dsHazeContextItem.CopyFrom(this.m_ContextItems[0]); if (this.m_ContextItems.Count == 1) { return(dsHazeContextItem); } time = Mathf.Clamp01(time); for (int index = 1; index < this.m_ContextItems.Count; ++index) { float dt = this.m_ContextItems[index].m_Weight.Evaluate(time); dsHazeContextItem.Lerp(this.m_ContextItems[index], dt); } return(dsHazeContextItem); }
/// <summary> /// Find the zones containing the given position and blend between them. /// The render context will be null if the position is not within any zones. /// If there is only one zone, that will provide the context as-is. /// </summary> public DS_HazeContextItem GetRenderContextAtPosition(Vector3 position) { List <DS_HazeZone> blendZones = new List <DS_HazeZone>(); for (int zi = 0; zi < m_Zones.Count; zi++) { if (m_Zones[zi].Contains(position) && m_Zones[zi].enabled) { blendZones.Add(m_Zones[zi]); } } if (blendZones.Count == 0) { return(null); } if (blendZones.Count == 1) { return(blendZones[0].Context.GetContextItemBlended(m_Time)); } blendZones.Sort(delegate(DS_HazeZone z1, DS_HazeZone z2) { if (z1 < z2) { return(-1); } else { return(1); } }); // With the list in priority order (lowest to highest), iterate through and blend from first to last. DS_HazeContextItem renderContext = blendZones[0].Context.GetContextItemBlended(m_Time); float weight = 0; for (int ci = 1; ci < blendZones.Count; ci++) { weight = blendZones[ci].GetBlendWeight(position); renderContext.Lerp(blendZones[ci].Context.GetContextItemBlended(m_Time), weight); } return(renderContext); }
/// <summary> /// Copy all the values from 'other'. /// </summary> /// <param name="other"> The DS_HazeContextVariant to get values from. </param> public void CopyFrom(DS_HazeContextItem other) { if (other == null) { #if DEVELOPMENT_BUILD || UNITY_EDITOR Debug.LogError("DeepSky::DS_HazeContextItem:CopyFrom - null context passed!"); #endif return; } Type thisType = GetType(); Type otherType = other.GetType(); foreach (FieldInfo field in thisType.GetFields()) { FieldInfo otherField = otherType.GetField(field.Name); field.SetValue(this, otherField.GetValue(other)); } // We need an actual copy of the weight curve, not just the reference. m_Weight = new AnimationCurve(m_Weight.keys); }
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label) { EditorGUI.BeginProperty(position, label, property); EditorGUI.indentLevel++; float curY = position.y + EditorGUIUtility.singleLineHeight / 2; float ctrlCount = 0; float ctrlSizeY = EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing; // Get all the rects upfront. Rect name = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect aLabel = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect aBetaSMult = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect aBetaS = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect aFalloff = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hLabel = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hBetaSMult = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hBetaS = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hFalloff = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hDir = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect hRatio = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fLabel = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fOpacity = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fBetaS = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fExtMult = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fExtS = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fFalloff = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fDist = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fDir = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fAmb = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); Rect fLight = new Rect(position.x, curY + ctrlSizeY * ctrlCount++, position.width, EditorGUIUtility.singleLineHeight); // Draw all the properties and labels. SerializedProperty airMultProp = property.FindPropertyRelative("m_AirScatteringMultiplier"); SerializedProperty hazeMultProp = property.FindPropertyRelative("m_HazeScatteringMultiplier"); SerializedProperty fogEMultProp = property.FindPropertyRelative("m_FogExtinctionMultiplier"); SerializedProperty airScatterProp = property.FindPropertyRelative("m_AirScatteringScale"); SerializedProperty hazeScatterProp = property.FindPropertyRelative("m_HazeScatteringScale"); SerializedProperty fogEProp = property.FindPropertyRelative("m_FogExtinctionScale"); GUIStyle popupStyle = new GUIStyle(EditorStyles.popup); popupStyle.alignment = TextAnchor.MiddleLeft; popupStyle.fixedWidth = 40; DS_HazeCore.HeightFalloffType falloff = DS_HazeCore.HeightFalloffType.Exponential; if (DS_HazeCore.Instance != null) { falloff = DS_HazeCore.Instance.HeightFalloff; } EditorGUI.PropertyField(name, property.FindPropertyRelative("m_Name")); EditorGUI.LabelField(aLabel, "Air:", EditorStyles.boldLabel); EditorGUI.BeginChangeCheck(); airMultProp.enumValueIndex = EditorGUI.Popup(aBetaSMult, "Scattering Multiplier", airMultProp.enumValueIndex, MultiplierStr, popupStyle); float airParamMax = 8 * DS_HazeContextItem.MultiplierAsFloat((DS_HazeContextItem.Multiplier)airMultProp.enumValueIndex); EditorGUI.Slider(aBetaS, airScatterProp, 0, airParamMax, "Scattering"); if (EditorGUI.EndChangeCheck()) { if (airScatterProp.floatValue > airParamMax) { airScatterProp.floatValue = airParamMax; } } bool wasEnabled = GUI.enabled; if (falloff != DS_HazeCore.HeightFalloffType.Exponential) { GUI.enabled = false; } EditorGUI.PropertyField(aFalloff, property.FindPropertyRelative("m_AirDensityHeightFalloff"), new GUIContent("Height Falloff", strToolTipAirHeightFalloff)); GUI.enabled = wasEnabled; EditorGUI.LabelField(hLabel, "Haze:", EditorStyles.boldLabel); EditorGUI.BeginChangeCheck(); hazeMultProp.enumValueIndex = EditorGUI.Popup(hBetaSMult, "Scattering Multiplier", hazeMultProp.enumValueIndex, MultiplierStr, popupStyle); float hazeParamMax = 8 * DS_HazeContextItem.MultiplierAsFloat((DS_HazeContextItem.Multiplier)hazeMultProp.enumValueIndex); EditorGUI.Slider(hBetaS, hazeScatterProp, 0, hazeParamMax, "Scattering"); if (EditorGUI.EndChangeCheck()) { if (hazeScatterProp.floatValue > hazeParamMax) { hazeScatterProp.floatValue = hazeParamMax; } } wasEnabled = GUI.enabled; if (falloff != DS_HazeCore.HeightFalloffType.Exponential) { GUI.enabled = false; } EditorGUI.PropertyField(hFalloff, property.FindPropertyRelative("m_HazeDensityHeightFalloff"), new GUIContent("Height Falloff", strToolTipHazeHeightFalloff)); GUI.enabled = wasEnabled; EditorGUI.PropertyField(hDir, property.FindPropertyRelative("m_HazeScatteringDirection"), new GUIContent("Scatter Direction", strToolTipHazeScatterDirection)); EditorGUI.PropertyField(hRatio, property.FindPropertyRelative("m_HazeSecondaryScatteringRatio"), new GUIContent("Direct/Indirect Ratio", strToolTipHazeIndirectRatio)); EditorGUI.LabelField(fLabel, "Fog/Mist:", EditorStyles.boldLabel); EditorGUI.PropertyField(fOpacity, property.FindPropertyRelative("m_FogOpacity"), new GUIContent("Opacity", strToolTipFogOpacity)); EditorGUI.BeginChangeCheck(); EditorGUI.PropertyField(fBetaS, property.FindPropertyRelative("m_FogScatteringScale"), new GUIContent("Scattering", strToolTipFogScatterScale)); fogEMultProp.enumValueIndex = EditorGUI.Popup(fExtMult, "Extinction Multiplier", fogEMultProp.enumValueIndex, MultiplierStr, popupStyle); float fogEParamMax = 8 * DS_HazeContextItem.MultiplierAsFloat((DS_HazeContextItem.Multiplier)fogEMultProp.enumValueIndex); EditorGUI.Slider(fExtS, fogEProp, 0, fogEParamMax, "Extinction"); if (EditorGUI.EndChangeCheck()) { if (fogEProp.floatValue > fogEParamMax) { fogEProp.floatValue = fogEParamMax; } } wasEnabled = GUI.enabled; if (falloff != DS_HazeCore.HeightFalloffType.Exponential) { GUI.enabled = false; } EditorGUI.PropertyField(fFalloff, property.FindPropertyRelative("m_FogDensityHeightFalloff"), new GUIContent("Height Falloff", strToolTipFogHeightFalloff)); GUI.enabled = wasEnabled; EditorGUI.PropertyField(fDist, property.FindPropertyRelative("m_FogStartDistance"), new GUIContent("Start Distance", strToolTipFogStartDistance)); EditorGUI.PropertyField(fDir, property.FindPropertyRelative("m_FogScatteringDirection"), new GUIContent("Scatter Direction", strToolTipFogScatterDirection)); EditorGUI.PropertyField(fAmb, property.FindPropertyRelative("m_FogAmbientColour"), new GUIContent("Ambient Colour", strToolTipFogAmbCol)); EditorGUI.PropertyField(fLight, property.FindPropertyRelative("m_FogLightColour"), new GUIContent("Light Colour", strToolTipFogLightCol)); EditorGUI.indentLevel--; EditorGUI.EndProperty(); }
private void SetMaterialFromContext(DS_HazeContextItem ctx) { if (this.WillRenderWithTemporalReprojection) { this.m_InterleavedOffsetIndex += 1f / 16f; if (Mathf.Approximately(this.m_InterleavedOffsetIndex, 1f)) { this.m_InterleavedOffsetIndex = 0.0f; } } float num1 = 1f; float num2 = 1f; float num3 = 1f; switch (DS_HazeCore.Instance.HeightFalloff) { case DS_HazeCore.HeightFalloffType.Exponential: float num4 = Mathf.Abs((float)((Component)this).get_transform().get_position().y); num1 = Mathf.Exp(-ctx.m_AirDensityHeightFalloff * num4); num2 = Mathf.Exp(-ctx.m_HazeDensityHeightFalloff * num4); num3 = Mathf.Exp((float)(-(double)ctx.m_FogDensityHeightFalloff * ((double)num4 - (double)ctx.m_FogStartHeight))); break; case DS_HazeCore.HeightFalloffType.None: num1 = 1f; num2 = 1f; num3 = 1f; break; } Vector3 vector3_1 = Vector3.op_Multiply(ctx.m_AirScatteringScale, new Vector3(0.00116f, 0.0027f, 0.00662f)); float num5 = ctx.m_HazeScatteringScale * 0.0021f; float fogScatteringScale = ctx.m_FogScatteringScale; float num6 = ctx.m_FogExtinctionScale * 0.01f; Vector4 vector4_1; ((Vector4) ref vector4_1).\u002Ector(ctx.m_AirDensityHeightFalloff, ctx.m_HazeDensityHeightFalloff, 0.0f, ctx.m_HazeScatteringDirection); Vector4 vector4_2; ((Vector4) ref vector4_2).\u002Ector(num5, !this.m_RenderAtmosphereVolumetrics ? 0.0f : ctx.m_HazeSecondaryScatteringRatio, fogScatteringScale, num6); Vector4 vector4_3; ((Vector4) ref vector4_3).\u002Ector(num1, num2, num3, 0.0f); Vector4 vector4_4; ((Vector4) ref vector4_4).\u002Ector(ctx.m_FogStartDistance, ctx.m_FogDensityHeightFalloff, ctx.m_FogOpacity, ctx.m_FogScatteringDirection); Vector4 vector4_5; ((Vector4) ref vector4_5).\u002Ector((float)this.m_GaussianDepthFalloff, this.m_UpsampleDepthThreshold * 0.01f, this.m_TemporalRejectionScale, this.m_TemporalBlendFactor); this.m_Material.SetVector("_SamplingParams", vector4_5); this.m_Material.SetVector("_InterleavedOffset", new Vector4(this.m_InterleavedOffsetIndex, 0.0f, 0.0f, 0.0f)); this.m_Material.SetMatrix("_PreviousViewProjMatrix", this.m_PreviousViewProjMatrix); this.m_Material.SetMatrix("_PreviousInvViewProjMatrix", this.m_PreviousInvViewProjMatrix); Shader.SetGlobalVector("_DS_BetaParams", vector4_2); Shader.SetGlobalVector("_DS_RBetaS", Vector4.op_Implicit(vector3_1)); Shader.SetGlobalVector("_DS_AirHazeParams", vector4_1); Shader.SetGlobalVector("_DS_FogParams", vector4_4); Shader.SetGlobalVector("_DS_InitialDensityParams", vector4_3); Vector3 vector3_2; Color color1; if (Object.op_Implicit((Object)this.m_DirectLight)) { vector3_2 = Vector3.op_UnaryNegation(((Component)this.m_DirectLight).get_transform().get_forward()); Color color2 = this.m_DirectLight.get_color(); color1 = Color.op_Multiply(((Color) ref color2).get_linear(), this.m_DirectLight.get_intensity()); Shader.SetGlobalColor("_DS_FogAmbientLight", Color.op_Multiply(((Color) ref ctx.m_FogAmbientColour).get_linear(), this.m_DirectLight.get_intensity())); Shader.SetGlobalColor("_DS_FogDirectLight", Color.op_Multiply(((Color) ref ctx.m_FogLightColour).get_linear(), this.m_DirectLight.get_intensity())); } else { vector3_2 = Vector3.get_up(); color1 = Color.get_white(); Shader.SetGlobalColor("_DS_FogAmbientLight", ((Color) ref ctx.m_FogAmbientColour).get_linear()); Shader.SetGlobalColor("_DS_FogDirectLight", ((Color) ref ctx.m_FogLightColour).get_linear()); } Shader.SetGlobalVector("_DS_LightDirection", Vector4.op_Implicit(vector3_2)); Shader.SetGlobalVector("_DS_LightColour", Color.op_Implicit(color1)); }