Fixed multi-editing with new light intensity slider (#2600)

adrien-de-tocqueville · web-flow · commit 96b49f51a58f · 2020-11-19T11:39:22.000+01:00
* Fixed multi-editing with new light intensity slider

* Only update floatValue when changed
diff --git a/com.unity.render-pipelines.high-definition/CHANGELOG.md b/com.unity.render-pipelines.high-definition/CHANGELOG.md
@@ -101,6 +101,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Fixed picking for materials with depth offset.
 - Fixed issue with exposure history being uninitialized on second frame.
 - Fixed issue when changing FoV with the physical camera fold-out closed.
+- Fixed multi-editing with new light intensity slider.
 
 ### Changed
 - Combined occlusion meshes into one to reduce draw calls and state changes with XR single-pass.
diff --git a/com.unity.render-pipelines.high-definition/Editor/Lighting/HDLightUI.cs b/com.unity.render-pipelines.high-definition/Editor/Lighting/HDLightUI.cs
@@ -630,6 +630,7 @@ static void DrawLightIntensityGUILayout(SerializedHDLight serialized, Editor own
             unitRect.width = k_UnitWidth + .5f;
 
             // Draw the unit textfield
+            EditorGUI.BeginChangeCheck();
             EditorGUI.PropertyField(valueRect, serialized.intensity, s_Styles.empty);
             DrawLightIntensityUnitPopup(unitRect, serialized, owner);
 
@@ -691,8 +692,6 @@ static void DrawEmissionContent(SerializedHDLight serialized, Editor owner)
                     EditorGUILayout.PropertyField(serialized.settings.color, s_Styles.color);
             }
 
-            EditorGUI.BeginChangeCheck();
-
             DrawLightIntensityGUILayout(serialized, owner);
 
             HDLightType lightType = serialized.type;
diff --git a/com.unity.render-pipelines.high-definition/Editor/Lighting/LightUnit/LightUnitSlider.cs b/com.unity.render-pipelines.high-definition/Editor/Lighting/LightUnit/LightUnitSlider.cs
@@ -42,16 +42,16 @@ public void SetSerializedObject(SerializedObject serialized)
             m_SerializedObject = serialized;
         }
 
-        public virtual void Draw(Rect rect, SerializedProperty value)
+        public virtual void Draw(Rect rect, SerializedProperty value, ref float floatValue)
         {
             BuildRects(rect, out var sliderRect, out var iconRect);
 
             if (m_Descriptor.clampValue)
-                ClampValue(value, m_Descriptor.sliderRange);
+                ClampValue(ref floatValue, m_Descriptor.sliderRange);
 
-            var level = CurrentRange(value.floatValue);
+            var level = CurrentRange(floatValue);
 
-            DoSlider(sliderRect, value, m_Descriptor.sliderRange, level.value);
+            DoSlider(sliderRect, ref floatValue, m_Descriptor.sliderRange, level.value);
 
             if (m_Descriptor.hasMarkers)
             {
@@ -66,9 +66,9 @@ public virtual void Draw(Rect rect, SerializedProperty value)
 
             var levelIconContent = level.content;
             var levelRange = level.value;
-            DoIcon(iconRect, levelIconContent, value, levelRange.y);
+            DoIcon(iconRect, levelIconContent, value, floatValue, levelRange.y);
 
-            var thumbValue = value.floatValue;
+            var thumbValue = floatValue;
             var thumbPosition = GetPositionOnSlider(thumbValue, level.value);
             var thumbTooltip = levelIconContent.tooltip;
             DoThumbTooltip(sliderRect, thumbPosition, thumbValue, thumbTooltip);
@@ -99,8 +99,8 @@ void BuildRects(Rect baseRect, out Rect sliderRect, out Rect iconRect)
             iconRect.width = EditorGUIUtility.singleLineHeight;
         }
 
-        void ClampValue(SerializedProperty value, Vector2 range) =>
-            value.floatValue = Mathf.Clamp(value.floatValue, range.x, range.y);
+        void ClampValue(ref float value, Vector2 range) =>
+            value = Mathf.Clamp(value, range.x, range.y);
 
         private static Color k_DarkThemeColor = new Color32(153, 153, 153, 255);
         private static Color k_LiteThemeColor = new Color32(97, 97, 97, 255);
@@ -143,7 +143,7 @@ void DoSliderMarker(Rect rect, float position, float value, string tooltip)
             EditorGUI.LabelField(markerTooltipRect, GetLightUnitTooltip(tooltip, value, m_Descriptor.unitName));
         }
 
-        void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float range)
+        void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float floatValue, float range)
         {
             // Draw the context menu feedback before the icon
             GUI.Box(rect, GUIContent.none, SliderStyles.k_IconButton);
@@ -162,20 +162,20 @@ void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float range)
                 if (rect.Contains(e.mousePosition))
                 {
                     var menuPosition = rect.position + rect.size;
-                    DoContextMenu(menuPosition, value);
+                    DoContextMenu(menuPosition, value, floatValue);
                     e.Use();
                 }
             }
         }
 
-        void DoContextMenu(Vector2 pos, SerializedProperty value)
+        void DoContextMenu(Vector2 pos, SerializedProperty value, float floatValue)
         {
             var menu = new GenericMenu();
 
             foreach (var preset in m_Descriptor.valueRanges)
             {
                 // Indicate a checkmark if the value is within this preset range.
-                var isInPreset = CurrentRange(value.floatValue).value == preset.value;
+                var isInPreset = CurrentRange(floatValue).value == preset.value;
 
                 menu.AddItem(EditorGUIUtility.TrTextContent(preset.content.tooltip), isInPreset, () => SetValueToPreset(value, preset));
             }
@@ -218,17 +218,17 @@ protected virtual GUIContent GetLightUnitTooltip(string baseTooltip, float value
             return new GUIContent(string.Empty, tooltip);
         }
 
-        protected virtual void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange, Vector2 valueRange)
+        protected virtual void DoSlider(Rect rect, ref float value, Vector2 sliderRange, Vector2 valueRange)
         {
-            DoSlider(rect, value, sliderRange);
+            DoSlider(rect, ref value, sliderRange);
         }
 
         /// <summary>
         /// Draws a linear slider mapped to the min/max value range. Override this for different slider behavior (texture background, power).
         /// </summary>
-        protected virtual void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange)
+        protected virtual void DoSlider(Rect rect, ref float value, Vector2 sliderRange)
         {
-            value.floatValue = GUI.HorizontalSlider(rect, value.floatValue, sliderRange.x, sliderRange.y);
+            value = GUI.HorizontalSlider(rect, value, sliderRange.x, sliderRange.y);
         }
 
         // Remaps value in the domain { Min0, Max0 } to { Min1, Max1 } (by default, normalizes it to (0, 1).
@@ -338,36 +338,36 @@ bool UpdatePiece(ref Piece piece, float x)
             return false;
         }
 
-        void SliderOutOfBounds(Rect rect, SerializedProperty value)
+        void SliderOutOfBounds(Rect rect, ref float value)
         {
             EditorGUI.BeginChangeCheck();
-            var internalValue = GUI.HorizontalSlider(rect, value.floatValue, 0f, 1f);
+            var internalValue = GUI.HorizontalSlider(rect, value, 0f, 1f);
             if (EditorGUI.EndChangeCheck())
             {
                 Piece p = new Piece();
                 UpdatePiece(ref p, internalValue);
-                value.floatValue = SliderToValue(p, internalValue);
+                value = SliderToValue(p, internalValue);
             }
         }
 
-        protected override void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange, Vector2 valueRange)
+        protected override void DoSlider(Rect rect, ref float value, Vector2 sliderRange, Vector2 valueRange)
         {
             // Map the internal slider value to the current piecewise function
             if (!m_PiecewiseFunctionMap.TryGetValue(valueRange, out var piece))
             {
                 // Assume that if the piece is not found, that means the unit value is out of bounds.
-                SliderOutOfBounds(rect, value);
+                SliderOutOfBounds(rect, ref value);
                 return;
             }
 
             // Maintain an internal value to support a single linear continuous function
             EditorGUI.BeginChangeCheck();
-            var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(piece, value.floatValue), 0f, 1f);
+            var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(piece, value), 0f, 1f);
             if (EditorGUI.EndChangeCheck())
             {
                 // Ensure that the current function piece is being used to transform the value
                 UpdatePiece(ref piece, internalValue);
-                value.floatValue = SliderToValue(piece, internalValue);
+                value = SliderToValue(piece, internalValue);
             }
         }
     }
@@ -404,18 +404,15 @@ public void Setup(LightUnit unit, SerializedHDLight light, Editor owner)
             m_SpotReflectorEnabled = light.enableSpotReflector.boolValue;
         }
 
-        public override void Draw(Rect rect, SerializedProperty value)
+        public override void Draw(Rect rect, SerializedProperty value, ref float floatValue)
         {
             // Convert the incoming unit value into Lumen as the punctual slider is always in these terms (internally)
-            value.floatValue = UnitToLumen(value.floatValue);
+            float convertedValue = UnitToLumen(floatValue);
 
-            base.Draw(rect, value);
-
-            value.floatValue = LumenToUnit(value.floatValue);
-
-            // Must apply properties here to ensure proper undo/redo functionality.
-            // The reason this is likely necessary is due to how we handle the internal unit conversion into lumen.
-            m_Light.Apply();
+            EditorGUI.BeginChangeCheck();
+            base.Draw(rect, value, ref convertedValue);
+            if (EditorGUI.EndChangeCheck())
+                floatValue = LumenToUnit(convertedValue);
         }
 
         protected override GUIContent GetLightUnitTooltip(string baseTooltip, float value, string unit)
@@ -551,27 +548,27 @@ protected override void SetValueToPreset(SerializedProperty value, LightUnitSlid
             m_Settings.ApplyModifiedProperties();
         }
 
-        protected override void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange)
+        protected override void DoSlider(Rect rect, ref float value, Vector2 sliderRange)
         {
-            SliderWithTextureNoTextField(rect, value, sliderRange, m_Settings);
+            SliderWithTextureNoTextField(rect, ref value, sliderRange, m_Settings);
         }
 
         // Note: We could use the internal SliderWithTexture, however: the internal slider func forces a text-field (and no ability to opt-out of it).
-        void SliderWithTextureNoTextField(Rect rect, SerializedProperty value, Vector2 range, LightEditor.Settings settings)
+        void SliderWithTextureNoTextField(Rect rect, ref float value, Vector2 range, LightEditor.Settings settings)
         {
             GUI.DrawTexture(rect, GetKelvinGradientTexture(settings));
 
             EditorGUI.BeginChangeCheck();
 
             // Draw the exponential slider that fits 6500K to the white point on the gradient texture.
-            var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(value.floatValue), 0f, 1f, SliderStyles.k_TemperatureBorder, SliderStyles.k_TemperatureThumb);
+            var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(value), 0f, 1f, SliderStyles.k_TemperatureBorder, SliderStyles.k_TemperatureThumb);
 
             // Map the value back into kelvin.
-            value.floatValue = SliderToValue(internalValue);
+            value = SliderToValue(internalValue);
 
             // Round to nearest since so much precision is not necessary for kelvin while sliding.
             if (EditorGUI.EndChangeCheck())
-                value.floatValue = Mathf.Round(value.floatValue);
+                value = Mathf.Round(value);
         }
     }
 
@@ -620,20 +617,30 @@ public void Draw(HDLightType type, LightUnit lightUnit, SerializedProperty value
 
         void DrawDirectionalUnitSlider(SerializedProperty value, Rect rect)
         {
-            k_DirectionalLightUnitSlider.Draw(rect, value);
+            float val = value.floatValue;
+            k_DirectionalLightUnitSlider.Draw(rect, value, ref val);
+            if (val != value.floatValue)
+                value.floatValue = val;
         }
 
         void DrawPunctualLightUnitSlider(LightUnit lightUnit, SerializedProperty value, Rect rect, SerializedHDLight light, Editor owner)
         {
             k_PunctualLightUnitSlider.Setup(lightUnit, light, owner);
-            k_PunctualLightUnitSlider.Draw(rect, value);
+
+            float val = value.floatValue;
+            k_PunctualLightUnitSlider.Draw(rect, value, ref val);
+            if (val != value.floatValue)
+                value.floatValue = val;
         }
 
         public void DrawExposureSlider(SerializedProperty value, Rect rect)
         {
             using (new EditorGUI.IndentLevelScope(-EditorGUI.indentLevel))
             {
-                k_ExposureSlider.Draw(rect, value);
+                float val = value.floatValue;
+                k_ExposureSlider.Draw(rect, value, ref val);
+                if (val != value.floatValue)
+                    value.floatValue = val;
             }
         }
 
@@ -642,7 +649,11 @@ public void DrawTemperatureSlider(LightEditor.Settings settings, SerializedPrope
             using (new EditorGUI.IndentLevelScope(-EditorGUI.indentLevel))
             {
                 k_TemperatureSlider.Setup(settings);
-                k_TemperatureSlider.Draw(rect, value);
+
+                float val = value.floatValue;
+                k_TemperatureSlider.Draw(rect, value, ref val);
+                if (val != value.floatValue)
+                    value.floatValue = val;
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -42,16 +42,16 @@ public void SetSerializedObject(SerializedObject serialized)`
`42`	`42`	`m_SerializedObject = serialized;`
`43`	`43`	`}`
`44`	`44`
`45`		`- public virtual void Draw(Rect rect, SerializedProperty value)`
	`45`	`+ public virtual void Draw(Rect rect, SerializedProperty value, ref float floatValue)`
`46`	`46`	`{`
`47`	`47`	`BuildRects(rect, out var sliderRect, out var iconRect);`
`48`	`48`
`49`	`49`	`if (m_Descriptor.clampValue)`
`50`		`- ClampValue(value, m_Descriptor.sliderRange);`
	`50`	`+ ClampValue(ref floatValue, m_Descriptor.sliderRange);`
`51`	`51`
`52`		`- var level = CurrentRange(value.floatValue);`
	`52`	`+ var level = CurrentRange(floatValue);`
`53`	`53`
`54`		`- DoSlider(sliderRect, value, m_Descriptor.sliderRange, level.value);`
	`54`	`+ DoSlider(sliderRect, ref floatValue, m_Descriptor.sliderRange, level.value);`
`55`	`55`
`56`	`56`	`if (m_Descriptor.hasMarkers)`
`57`	`57`	`{`
`@@ -66,9 +66,9 @@ public virtual void Draw(Rect rect, SerializedProperty value)`
`66`	`66`
`67`	`67`	`var levelIconContent = level.content;`
`68`	`68`	`var levelRange = level.value;`
`69`		`- DoIcon(iconRect, levelIconContent, value, levelRange.y);`
	`69`	`+ DoIcon(iconRect, levelIconContent, value, floatValue, levelRange.y);`
`70`	`70`
`71`		`- var thumbValue = value.floatValue;`
	`71`	`+ var thumbValue = floatValue;`
`72`	`72`	`var thumbPosition = GetPositionOnSlider(thumbValue, level.value);`
`73`	`73`	`var thumbTooltip = levelIconContent.tooltip;`
`74`	`74`	`DoThumbTooltip(sliderRect, thumbPosition, thumbValue, thumbTooltip);`
`@@ -99,8 +99,8 @@ void BuildRects(Rect baseRect, out Rect sliderRect, out Rect iconRect)`
`99`	`99`	`iconRect.width = EditorGUIUtility.singleLineHeight;`
`100`	`100`	`}`
`101`	`101`
`102`		`- void ClampValue(SerializedProperty value, Vector2 range) =>`
`103`		`- value.floatValue = Mathf.Clamp(value.floatValue, range.x, range.y);`
	`102`	`+ void ClampValue(ref float value, Vector2 range) =>`
	`103`	`+ value = Mathf.Clamp(value, range.x, range.y);`
`104`	`104`
`105`	`105`	`private static Color k_DarkThemeColor = new Color32(153, 153, 153, 255);`
`106`	`106`	`private static Color k_LiteThemeColor = new Color32(97, 97, 97, 255);`
`@@ -143,7 +143,7 @@ void DoSliderMarker(Rect rect, float position, float value, string tooltip)`
`143`	`143`	`EditorGUI.LabelField(markerTooltipRect, GetLightUnitTooltip(tooltip, value, m_Descriptor.unitName));`
`144`	`144`	`}`
`145`	`145`
`146`		`- void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float range)`
	`146`	`+ void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float floatValue, float range)`
`147`	`147`	`{`
`148`	`148`	`// Draw the context menu feedback before the icon`
`149`	`149`	`GUI.Box(rect, GUIContent.none, SliderStyles.k_IconButton);`
`@@ -162,20 +162,20 @@ void DoIcon(Rect rect, GUIContent icon, SerializedProperty value, float range)`
`162`	`162`	`if (rect.Contains(e.mousePosition))`
`163`	`163`	`{`
`164`	`164`	`var menuPosition = rect.position + rect.size;`
`165`		`- DoContextMenu(menuPosition, value);`
	`165`	`+ DoContextMenu(menuPosition, value, floatValue);`
`166`	`166`	`e.Use();`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`	`}`
`170`	`170`
`171`		`- void DoContextMenu(Vector2 pos, SerializedProperty value)`
	`171`	`+ void DoContextMenu(Vector2 pos, SerializedProperty value, float floatValue)`
`172`	`172`	`{`
`173`	`173`	`var menu = new GenericMenu();`
`174`	`174`
`175`	`175`	`foreach (var preset in m_Descriptor.valueRanges)`
`176`	`176`	`{`
`177`	`177`	`// Indicate a checkmark if the value is within this preset range.`
`178`		`- var isInPreset = CurrentRange(value.floatValue).value == preset.value;`
	`178`	`+ var isInPreset = CurrentRange(floatValue).value == preset.value;`
`179`	`179`
`180`	`180`	`menu.AddItem(EditorGUIUtility.TrTextContent(preset.content.tooltip), isInPreset, () => SetValueToPreset(value, preset));`
`181`	`181`	`}`
`@@ -218,17 +218,17 @@ protected virtual GUIContent GetLightUnitTooltip(string baseTooltip, float value`
`218`	`218`	`return new GUIContent(string.Empty, tooltip);`
`219`	`219`	`}`
`220`	`220`
`221`		`- protected virtual void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange, Vector2 valueRange)`
	`221`	`+ protected virtual void DoSlider(Rect rect, ref float value, Vector2 sliderRange, Vector2 valueRange)`
`222`	`222`	`{`
`223`		`- DoSlider(rect, value, sliderRange);`
	`223`	`+ DoSlider(rect, ref value, sliderRange);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`/// <summary>`
`227`	`227`	`/// Draws a linear slider mapped to the min/max value range. Override this for different slider behavior (texture background, power).`
`228`	`228`	`/// </summary>`
`229`		`- protected virtual void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange)`
	`229`	`+ protected virtual void DoSlider(Rect rect, ref float value, Vector2 sliderRange)`
`230`	`230`	`{`
`231`		`- value.floatValue = GUI.HorizontalSlider(rect, value.floatValue, sliderRange.x, sliderRange.y);`
	`231`	`+ value = GUI.HorizontalSlider(rect, value, sliderRange.x, sliderRange.y);`
`232`	`232`	`}`
`233`	`233`
`234`	`234`	`// Remaps value in the domain { Min0, Max0 } to { Min1, Max1 } (by default, normalizes it to (0, 1).`
`@@ -338,36 +338,36 @@ bool UpdatePiece(ref Piece piece, float x)`
`338`	`338`	`return false;`
`339`	`339`	`}`
`340`	`340`
`341`		`- void SliderOutOfBounds(Rect rect, SerializedProperty value)`
	`341`	`+ void SliderOutOfBounds(Rect rect, ref float value)`
`342`	`342`	`{`
`343`	`343`	`EditorGUI.BeginChangeCheck();`
`344`		`- var internalValue = GUI.HorizontalSlider(rect, value.floatValue, 0f, 1f);`
	`344`	`+ var internalValue = GUI.HorizontalSlider(rect, value, 0f, 1f);`
`345`	`345`	`if (EditorGUI.EndChangeCheck())`
`346`	`346`	`{`
`347`	`347`	`Piece p = new Piece();`
`348`	`348`	`UpdatePiece(ref p, internalValue);`
`349`		`- value.floatValue = SliderToValue(p, internalValue);`
	`349`	`+ value = SliderToValue(p, internalValue);`
`350`	`350`	`}`
`351`	`351`	`}`
`352`	`352`
`353`		`- protected override void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange, Vector2 valueRange)`
	`353`	`+ protected override void DoSlider(Rect rect, ref float value, Vector2 sliderRange, Vector2 valueRange)`
`354`	`354`	`{`
`355`	`355`	`// Map the internal slider value to the current piecewise function`
`356`	`356`	`if (!m_PiecewiseFunctionMap.TryGetValue(valueRange, out var piece))`
`357`	`357`	`{`
`358`	`358`	`// Assume that if the piece is not found, that means the unit value is out of bounds.`
`359`		`- SliderOutOfBounds(rect, value);`
	`359`	`+ SliderOutOfBounds(rect, ref value);`
`360`	`360`	`return;`
`361`	`361`	`}`
`362`	`362`
`363`	`363`	`// Maintain an internal value to support a single linear continuous function`
`364`	`364`	`EditorGUI.BeginChangeCheck();`
`365`		`- var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(piece, value.floatValue), 0f, 1f);`
	`365`	`+ var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(piece, value), 0f, 1f);`
`366`	`366`	`if (EditorGUI.EndChangeCheck())`
`367`	`367`	`{`
`368`	`368`	`// Ensure that the current function piece is being used to transform the value`
`369`	`369`	`UpdatePiece(ref piece, internalValue);`
`370`		`- value.floatValue = SliderToValue(piece, internalValue);`
	`370`	`+ value = SliderToValue(piece, internalValue);`
`371`	`371`	`}`
`372`	`372`	`}`
`373`	`373`	`}`
`@@ -404,18 +404,15 @@ public void Setup(LightUnit unit, SerializedHDLight light, Editor owner)`
`404`	`404`	`m_SpotReflectorEnabled = light.enableSpotReflector.boolValue;`
`405`	`405`	`}`
`406`	`406`
`407`		`- public override void Draw(Rect rect, SerializedProperty value)`
	`407`	`+ public override void Draw(Rect rect, SerializedProperty value, ref float floatValue)`
`408`	`408`	`{`
`409`	`409`	`// Convert the incoming unit value into Lumen as the punctual slider is always in these terms (internally)`
`410`		`- value.floatValue = UnitToLumen(value.floatValue);`
	`410`	`+ float convertedValue = UnitToLumen(floatValue);`
`411`	`411`
`412`		`- base.Draw(rect, value);`
`413`		`-`
`414`		`- value.floatValue = LumenToUnit(value.floatValue);`
`415`		`-`
`416`		`- // Must apply properties here to ensure proper undo/redo functionality.`
`417`		`- // The reason this is likely necessary is due to how we handle the internal unit conversion into lumen.`
`418`		`- m_Light.Apply();`
	`412`	`+ EditorGUI.BeginChangeCheck();`
	`413`	`+ base.Draw(rect, value, ref convertedValue);`
	`414`	`+ if (EditorGUI.EndChangeCheck())`
	`415`	`+ floatValue = LumenToUnit(convertedValue);`
`419`	`416`	`}`
`420`	`417`
`421`	`418`	`protected override GUIContent GetLightUnitTooltip(string baseTooltip, float value, string unit)`
`@@ -551,27 +548,27 @@ protected override void SetValueToPreset(SerializedProperty value, LightUnitSlid`
`551`	`548`	`m_Settings.ApplyModifiedProperties();`
`552`	`549`	`}`
`553`	`550`
`554`		`- protected override void DoSlider(Rect rect, SerializedProperty value, Vector2 sliderRange)`
	`551`	`+ protected override void DoSlider(Rect rect, ref float value, Vector2 sliderRange)`
`555`	`552`	`{`
`556`		`- SliderWithTextureNoTextField(rect, value, sliderRange, m_Settings);`
	`553`	`+ SliderWithTextureNoTextField(rect, ref value, sliderRange, m_Settings);`
`557`	`554`	`}`
`558`	`555`
`559`	`556`	`// Note: We could use the internal SliderWithTexture, however: the internal slider func forces a text-field (and no ability to opt-out of it).`
`560`		`- void SliderWithTextureNoTextField(Rect rect, SerializedProperty value, Vector2 range, LightEditor.Settings settings)`
	`557`	`+ void SliderWithTextureNoTextField(Rect rect, ref float value, Vector2 range, LightEditor.Settings settings)`
`561`	`558`	`{`
`562`	`559`	`GUI.DrawTexture(rect, GetKelvinGradientTexture(settings));`
`563`	`560`
`564`	`561`	`EditorGUI.BeginChangeCheck();`
`565`	`562`
`566`	`563`	`// Draw the exponential slider that fits 6500K to the white point on the gradient texture.`
`567`		`- var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(value.floatValue), 0f, 1f, SliderStyles.k_TemperatureBorder, SliderStyles.k_TemperatureThumb);`
	`564`	`+ var internalValue = GUI.HorizontalSlider(rect, ValueToSlider(value), 0f, 1f, SliderStyles.k_TemperatureBorder, SliderStyles.k_TemperatureThumb);`
`568`	`565`
`569`	`566`	`// Map the value back into kelvin.`
`570`		`- value.floatValue = SliderToValue(internalValue);`
	`567`	`+ value = SliderToValue(internalValue);`
`571`	`568`
`572`	`569`	`// Round to nearest since so much precision is not necessary for kelvin while sliding.`
`573`	`570`	`if (EditorGUI.EndChangeCheck())`
`574`		`- value.floatValue = Mathf.Round(value.floatValue);`
	`571`	`+ value = Mathf.Round(value);`
`575`	`572`	`}`
`576`	`573`	`}`
`577`	`574`
`@@ -620,20 +617,30 @@ public void Draw(HDLightType type, LightUnit lightUnit, SerializedProperty value`
`620`	`617`
`621`	`618`	`void DrawDirectionalUnitSlider(SerializedProperty value, Rect rect)`
`622`	`619`	`{`
`623`		`- k_DirectionalLightUnitSlider.Draw(rect, value);`
	`620`	`+ float val = value.floatValue;`
	`621`	`+ k_DirectionalLightUnitSlider.Draw(rect, value, ref val);`
	`622`	`+ if (val != value.floatValue)`
	`623`	`+ value.floatValue = val;`
`624`	`624`	`}`
`625`	`625`
`626`	`626`	`void DrawPunctualLightUnitSlider(LightUnit lightUnit, SerializedProperty value, Rect rect, SerializedHDLight light, Editor owner)`
`627`	`627`	`{`
`628`	`628`	`k_PunctualLightUnitSlider.Setup(lightUnit, light, owner);`
`629`		`- k_PunctualLightUnitSlider.Draw(rect, value);`
	`629`	`+`
	`630`	`+ float val = value.floatValue;`
	`631`	`+ k_PunctualLightUnitSlider.Draw(rect, value, ref val);`
	`632`	`+ if (val != value.floatValue)`
	`633`	`+ value.floatValue = val;`
`630`	`634`	`}`
`631`	`635`
`632`	`636`	`public void DrawExposureSlider(SerializedProperty value, Rect rect)`
`633`	`637`	`{`
`634`	`638`	`using (new EditorGUI.IndentLevelScope(-EditorGUI.indentLevel))`
`635`	`639`	`{`
`636`		`- k_ExposureSlider.Draw(rect, value);`
	`640`	`+ float val = value.floatValue;`
	`641`	`+ k_ExposureSlider.Draw(rect, value, ref val);`
	`642`	`+ if (val != value.floatValue)`
	`643`	`+ value.floatValue = val;`
`637`	`644`	`}`
`638`	`645`	`}`
`639`	`646`
`@@ -642,7 +649,11 @@ public void DrawTemperatureSlider(LightEditor.Settings settings, SerializedPrope`
`642`	`649`	`using (new EditorGUI.IndentLevelScope(-EditorGUI.indentLevel))`
`643`	`650`	`{`
`644`	`651`	`k_TemperatureSlider.Setup(settings);`
`645`		`- k_TemperatureSlider.Draw(rect, value);`
	`652`	`+`
	`653`	`+ float val = value.floatValue;`
	`654`	`+ k_TemperatureSlider.Draw(rect, value, ref val);`
	`655`	`+ if (val != value.floatValue)`
	`656`	`+ value.floatValue = val;`
`646`	`657`	`}`
`647`	`658`	`}`
`648`	`659`	`}`