Updated embedded packages

Packages/com.unity.render-pipelines.core/CHANGELOG.md

 
 ## [7.1.1] - 2019-XX-XX
 
+### Added
+- Add separated debug mode in LookDev.
+
+### Changed
+- Replaced usage of ENABLE_VR in XRGraphics.cs by a version define (ENABLE_VR_MODULE) based on the presence of the built-in VR module
+- `ResourceReloader` now works on non-public fields.
+- Fixed shadow routines compilation errors when "real" type is a typedef on "half".
+- Removed debug menu in non development build.
+
 ## [7.0.1] - 2019-07-25
 
 ### Fixed

Packages/com.unity.render-pipelines.core/Editor/CameraEditorUtils.cs

                     return;
                 }
 
+                bool drawGizmo = sceneView.drawGizmos;
-                sceneView.drawGizmos = true;
+                sceneView.drawGizmos = drawGizmo;
                 Graphics.DrawTexture(cameraRect, previewCamera.targetTexture, new Rect(0, 0, 1, 1), 0, 0, 0, 0, GUI.color, GUITextureBlit2SRGBMaterial);
                 // We set target texture to null after this call otherwise if both sceneview and gameview are visible and we have a preview camera wwe
                 // get this error: "Releasing render texture that is set as Camera.targetTexture!"

Packages/com.unity.render-pipelines.core/Editor/CoreEditorUtils.cs

             
             if (isBoxed)
             {
-                rect.xMin = EditorGUIUtility.singleLineHeight - 2;
+                rect.xMin = EditorGUIUtility.singleLineHeight;
                 rect.width -= 1;
             }
 
                 labelRect.xMin += 5;
                 foldoutRect.xMin += 5;
                 backgroundRect.xMin = EditorGUIUtility.singleLineHeight;
-                backgroundRect.width -= 3;
+                backgroundRect.width -= 1;
             }
 
             // Background

Packages/com.unity.render-pipelines.core/Editor/Lighting/CoreLightEditorUtilities.cs

 using System;
+using UnityEditor.IMGUI.Controls;
+using UnityEngine.Rendering;
+        [Flags]
+        enum HandleDirections
+        {
+            Left = 1 << 0,
+            Up = 1 << 1,
+            Right = 1 << 2,
+            Down = 1 << 3,
+            All = Left | Up | Right | Down
+        }
+
+        static readonly Vector3[] directionalLightHandlesRayPositions =
+        {
+            new Vector3(1, 0, 0),
+            new Vector3(-1, 0, 0),
+            new Vector3(0, 1, 0),
+            new Vector3(0, -1, 0),
+            new Vector3(1, 1, 0).normalized,
+            new Vector3(1, -1, 0).normalized,
+            new Vector3(-1, 1, 0).normalized,
+            new Vector3(-1, -1, 0).normalized
+        };
+
+        /// <summary>
+        /// Draw a gizmo for a directional light.
+        /// </summary>
+        /// <param name="light">The light that is used for this gizmo.</param>
+        public static void DrawDirectionalLightGizmo(Light light)
+        {
+            // Sets the color of the Gizmo.
+            Color outerColor = GetLightAboveObjectWireframeColor(light.color);
+
+            Vector3 lightPos = light.transform.position;
+            float lightSize;
+            using (new Handles.DrawingScope(Matrix4x4.identity))    //be sure no matrix affect the size computation
+            {
+                lightSize = HandleUtility.GetHandleSize(lightPos);
+            }
+            float radius = lightSize * 0.2f;
+
+            using (new Handles.DrawingScope(outerColor))
+            {
+                Handles.DrawWireDisc(Vector3.zero, Vector3.forward, radius);
+                foreach (Vector3 normalizedPos in directionalLightHandlesRayPositions)
+                {
+                    Vector3 pos = normalizedPos * radius;
+                    Handles.DrawLine(pos, pos + new Vector3(0, 0, lightSize));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Draw a gizmo for a point light.
+        /// </summary>
+        /// <param name="light">The light that is used for this gizmo.</param>
+        public static void DrawPointLightGizmo(Light light)
+        {
+            // Sets the color of the Gizmo.
+            Color outerColor = GetLightAboveObjectWireframeColor(light.color);
+
+            // Drawing the point light
+            DrawPointLight(light, outerColor);
+
+            // Draw the handles and labels
+            DrawPointHandlesAndLabels(light);
+        }
+
+        static void DrawPointLight(Light light, Color outerColor)
+        {
+            float range = light.range;
+
+            using (new Handles.DrawingScope(outerColor))
+            {
+                EditorGUI.BeginChangeCheck();
+                //range = Handles.RadiusHandle(Quaternion.identity, light.transform.position, range, false, true);
+                range = DoPointHandles(range);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObject(light, "Adjust Point Light");
+                    light.range = range;
+                }
+            }
+        }
+
+        static void DrawPointHandlesAndLabels(Light light)
+        {
+            // Getting the first control on point handle
+            var firstControl = GUIUtility.GetControlID(s_PointLightHandle.GetHashCode(), FocusType.Passive) -6; // BoxBoundsHandle allocates 6 control IDs
+            if (Event.current.type != EventType.Repaint)
+                return;
+//            var firstControl = GUIUtility.GetControlID(k_RadiusHandleHash, FocusType.Passive) - 6;
+//            if (Event.current.type != EventType.Repaint)
+//                return;
+
+            // Adding label /////////////////////////////////////
+            Vector3 labelPosition = Vector3.zero;
+
+            if (GUIUtility.hotControl != 0)
+            {
+                switch (GUIUtility.hotControl - firstControl)
+                {
+                    case 0:
+                        labelPosition = Vector3.right * light.range;
+                        break;
+                    case 1:
+                        labelPosition = Vector3.left * light.range;
+                        break;
+                    case 2:
+                        labelPosition = Vector3.up * light.range;
+                        break;
+                    case 3:
+                        labelPosition = Vector3.down * light.range;
+                        break;
+                    case 4:
+                        labelPosition = Vector3.forward * light.range;
+                        break;
+                    case 5:
+                        labelPosition = Vector3.back * light.range;
+                        break;
+                    default:
+                        return;
+                }
+
+                string labelText = FormattableString.Invariant($"Range: {light.range:0.00}");
+                DrawHandleLabel(labelPosition, labelText);
+            }
+        }
+
+        /// <summary>
+        /// Draw a gizmo for an area/rectangle light.
+        /// </summary>
+        /// <param name="light">The light that is used for this gizmo.</param>
+        public static void DrawRectangleLightGizmo(Light light)
+        {
+            // Color to use for gizmo drawing
+            Color outerColor = GetLightAboveObjectWireframeColor(light.color);
+
+            // Drawing the gizmo
+            DrawRectangleLight(light, outerColor);
+
+            // Draw the handles and labels
+            DrawRectangleHandlesAndLabels(light);
+        }
+
+        static void DrawRectangleLight(Light light, Color outerColor)
+        {
+            Vector2 size = light.areaSize;
+            var range = light.range;
+            var innerColor = GetLightBehindObjectWireframeColor(light.color);
+            DrawZTestedLine(range, outerColor, innerColor);
+
+            using (new Handles.DrawingScope(outerColor))
+            {
+                EditorGUI.BeginChangeCheck();
+                size = DoRectHandles(size);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObject(light, "Adjust Area Rectangle Light");
+                    light.areaSize = size;
+                }
+            }
+        }
+
+        static void DrawRectangleHandlesAndLabels(Light light)
+        {
+            // Getting the first control on radius handle
+            var firstControl = GUIUtility.GetControlID(s_AreaLightHandle.GetHashCode(), FocusType.Passive) -6; // BoxBoundsHandle allocates 6 control IDs
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            // Adding label /////////////////////////////////////
+            Vector3 labelPosition = Vector3.zero;
+
+            if (GUIUtility.hotControl != 0)
+            {
+                switch (GUIUtility.hotControl - firstControl)
+                {
+                    case 0: // PositiveX
+                        labelPosition = Vector3.right * (light.areaSize.x / 2);
+                        break;
+                    case 1: // NegativeX
+                        labelPosition = Vector3.left * (light.areaSize.x / 2);
+                        break;
+                    case 2: // PositiveY
+                        labelPosition = Vector3.up * (light.areaSize.y / 2);
+                        break;
+                    case 3: // NegativeY
+                        labelPosition = Vector3.down * (light.areaSize.y / 2);
+                        break;
+                    default:
+                        return;
+                }
+                string labelText = FormattableString.Invariant($"w:{light.areaSize.x:0.00} x h:{light.areaSize.y:0.00}");
+                DrawHandleLabel(labelPosition, labelText);
+            }
+        }
+
+        /// <summary>
+        /// Draw a gizmo for a disc light.
+        /// </summary>
+        /// <param name="light">The light that is used for this gizmo.</param>
+        public static void DrawDiscLightGizmo(Light light)
+        {
+            // Color to use for gizmo drawing.
+            Color outerColor = GetLightAboveObjectWireframeColor(light.color);
+
+            // Drawing before objects
+            DrawDiscLight(light, outerColor);
+
+            // Draw handles
+            DrawDiscHandlesAndLabels(light);
+        }
+
+        static void DrawDiscLight(Light light, Color outerColor)
+        {
+            float radius = light.areaSize.x;
+            var range = light.range;
+            var innerColor = GetLightBehindObjectWireframeColor(light.color);
+            DrawZTestedLine(range, outerColor, innerColor);
+
+            using (new Handles.DrawingScope(outerColor))
+            {
+                EditorGUI.BeginChangeCheck();
+                radius = DoDiscHandles(radius);
+
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObject(light, "Adjust Area Disc Light");
+                    light.areaSize = new Vector2(radius, light.areaSize.y);
+                }
+            }
+        }
+
+        static void DrawDiscHandlesAndLabels(Light light)
+        {
+            // Getting the first control on radius handle
+            var firstControl = GUIUtility.GetControlID(s_DiscLightHandle.GetHashCode(), FocusType.Passive) -6; // BoxBoundsHandle allocates 6 control IDs
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            Vector3 labelPosition = Vector3.zero;
+
+            if (GUIUtility.hotControl != 0)
+            {
+                switch (GUIUtility.hotControl - firstControl)
+                {
+                    case 0: // PositiveX
+                        labelPosition = Vector3.right * light.areaSize.x;
+                        break;
+                    case 1: // NegativeX
+                        labelPosition = Vector3.left * light.areaSize.x;
+                        break;
+                    case 2: // PositiveY
+                        labelPosition = Vector3.up * light.areaSize.x;
+                        break;
+                    case 3: // NegativeY
+                        labelPosition = Vector3.down * light.areaSize.x;
+                        break;
+                    default:
+                        return;
+                }
+                string labelText = FormattableString.Invariant($"Radius: {light.areaSize.x:0.00}");
+                DrawHandleLabel(labelPosition, labelText);
+            }
+        }
+
+        static void DrawWithZTest(PrimitiveBoundsHandle primitiveHandle, float alpha = 0.2f)
+        {
+            primitiveHandle.center = Vector3.zero;
+
+            primitiveHandle.handleColor = Color.clear;
+            primitiveHandle.wireframeColor = Color.white;
+            Handles.zTest = CompareFunction.LessEqual;
+            primitiveHandle.DrawHandle();
+
+            primitiveHandle.wireframeColor = new Color(1f, 1f, 1f, alpha);
+            Handles.zTest = CompareFunction.Greater;
+            primitiveHandle.DrawHandle();
+
+            primitiveHandle.handleColor = Color.white;
+            primitiveHandle.wireframeColor = Color.clear;
+            Handles.zTest = CompareFunction.Always;
+            primitiveHandle.DrawHandle();
+        }
+
+        static void DrawZTestedLine(float range, Color outerColor, Color innerColor)
+        {
+            using (new Handles.DrawingScope(outerColor))
+            {
+                Handles.zTest = CompareFunction.LessEqual;
+                Handles.DrawLine(Vector3.zero, Vector3.forward * range);
+            }
+            using (new Handles.DrawingScope(innerColor))
+            {
+                Handles.zTest = CompareFunction.Greater;
+                Handles.DrawLine(Vector3.zero, Vector3.forward * range);
+            }
+            Handles.zTest = CompareFunction.Always;
+        }
+
+        static void DrawHandleLabel(Vector3 handlePosition, string labelText, float offsetFromHandle = 0.3f)
+        {
+            Vector3 labelPosition = Vector3.zero;
+
+            var style = new GUIStyle{normal = {background = Texture2D.whiteTexture}};
+            GUI.color = new Color(0.82f, 0.82f, 0.82f, 1);
+
+            labelPosition = handlePosition + Handles.inverseMatrix.MultiplyVector(Vector3.up) * HandleUtility.GetHandleSize(handlePosition) * offsetFromHandle;
+            Handles.Label(labelPosition, labelText, style);
+        }
+
+        static readonly BoxBoundsHandle s_AreaLightHandle =
+            new BoxBoundsHandle { axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y };
+
+        static Vector2 DoRectHandles(Vector2 size)
+        {
+            s_AreaLightHandle.center = Vector3.zero;
+            s_AreaLightHandle.size = size;
+            DrawWithZTest(s_AreaLightHandle);
+
+            return s_AreaLightHandle.size;
+        }
+
+        static readonly SphereBoundsHandle s_DiscLightHandle =
+            new SphereBoundsHandle { axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y } ;
+        static float DoDiscHandles(float radius)
+        {
+            s_DiscLightHandle.center = Vector3.zero;
+            s_DiscLightHandle.radius = radius;
+            DrawWithZTest(s_DiscLightHandle);
+
+            return s_DiscLightHandle.radius;
+        }
+
+        static readonly SphereBoundsHandle s_PointLightHandle =
+            new SphereBoundsHandle { axes = PrimitiveBoundsHandle.Axes.All };
+
+        static float DoPointHandles(float range)
+        {
+            s_PointLightHandle.radius = range;
+            DrawWithZTest(s_PointLightHandle);
+
+            return s_PointLightHandle.radius;
+        }
+
+        static bool drawInnerConeAngle = true;
+
+        /// <summary>
+        /// Draw a gizmo for a spot light.
+        /// </summary>
+        /// <param name="light">The light that is used for this gizmo.</param>
+        public static void DrawSpotLightGizmo(Light light)
+        {
+            // Saving the default colors
+            var defColor = Handles.color;
+            var defZTest = Handles.zTest;
+
+            // Default Color for outer cone will be Yellow if nothing has been provided.
+            Color outerColor = GetLightAboveObjectWireframeColor(light.color);
+
+            // The default z-test outer color will be 20% opacity of the outer color
+            Color outerColorZTest = GetLightBehindObjectWireframeColor(outerColor);
+
+            // Default Color for inner cone will be Yellow-ish if nothing has been provided.
+            Color innerColor = GetLightInnerConeColor(light.color);
+
+            // The default z-test outer color will be 20% opacity of the inner color
+            Color innerColorZTest = GetLightBehindObjectWireframeColor(innerColor);
+
+            // Drawing before objects
+            Handles.zTest = CompareFunction.LessEqual;
+            DrawSpotlightWireframe(light, outerColor, innerColor);
+
+            // Drawing behind objects
+            Handles.zTest = CompareFunction.Greater;
+            DrawSpotlightWireframe(light, outerColorZTest, innerColorZTest);
+
+            // Resets the compare function to always
+            Handles.zTest = CompareFunction.Always;
+
+            // Draw handles
+            if (!Event.current.alt)
+            {
+                DrawHandlesAndLabels(light, outerColor);
+            }
+
+            // Resets the handle colors
+            Handles.color = defColor;
+            Handles.zTest = defZTest;
+        }
+
+        static void DrawHandlesAndLabels(Light light, Color color)
+        {
+            // Zero position vector3
+            Vector3 zeroPos = Vector3.zero;
+
+            // Variable for which direction to draw the handles
+            HandleDirections DrawHandleDirections;
+
+            // Draw the handles ///////////////////////////////
+            Handles.color = color;
+
+            // Draw Center Handle
+            float range = light.range;
+            var id = GUIUtility.GetControlID(FocusType.Passive);
+            EditorGUI.BeginChangeCheck();
+            range = SliderLineHandle(id, Vector3.zero, Vector3.forward, range, "Range: ");
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObjects(new[] { light }, "Undo range change.");
+            }
+
+            // Draw outer handles
+            DrawHandleDirections = HandleDirections.Down | HandleDirections.Up;
+            const string outerLabel = "Outer Angle: ";
+
+            EditorGUI.BeginChangeCheck();
+            float outerAngle = DrawConeHandles(zeroPos, light.spotAngle, range, DrawHandleDirections, outerLabel);
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObjects(new[] { light }, "Undo outer angle change.");
+            }
+
+            // Draw inner handles
+            float innerAngle = 0;
+            const string innerLabel = "Inner Angle: ";
+            if (light.innerSpotAngle > 0f && drawInnerConeAngle)
+            {
+                DrawHandleDirections = HandleDirections.Left | HandleDirections.Right;
+                EditorGUI.BeginChangeCheck();
+                innerAngle = DrawConeHandles(zeroPos, light.innerSpotAngle, range, DrawHandleDirections, innerLabel);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObjects(new[] { light }, "Undo inner angle change.");
+                }
+            }
+
+            // Draw Near Plane Handle
+            float nearPlaneRange = light.shadowNearPlane;
+            if(light.shadows != LightShadows.None && light.lightmapBakeType != LightmapBakeType.Baked)
+            {
+                EditorGUI.BeginChangeCheck();
+                nearPlaneRange = SliderLineHandle(GUIUtility.GetControlID(FocusType.Passive), Vector3.zero, Vector3.forward, nearPlaneRange, "Near Plane: ");
+                if (EditorGUI.EndChangeCheck())
+                {
+                    Undo.RecordObjects(new[] { light }, "Undo shadow near plane change.");
+                    nearPlaneRange = Mathf.Clamp(nearPlaneRange, 0.1f, light.range);
+                }
+            }
+
+            // If changes has been made we update the corresponding property
+            if (GUI.changed)
+            {
+                light.spotAngle = outerAngle;
+                light.innerSpotAngle = innerAngle;
+                light.range = Math.Max(range, 0.01f);
+                light.shadowNearPlane = Mathf.Clamp(nearPlaneRange, 0.1f, light.range);
+            }
+        }
+
+        static Color GetLightInnerConeColor(Color wireframeColor)
+        {
+            Color color = wireframeColor;
+            color.a = 0.4f;
+            return RemapLightColor(CoreUtils.ConvertLinearToActiveColorSpace(color.linear));
+        }
+
+        static Color GetLightAboveObjectWireframeColor(Color wireframeColor)
+        {
+            Color color = wireframeColor;
+            color.a = 1f;
+           return RemapLightColor(CoreUtils.ConvertLinearToActiveColorSpace(color.linear));
+        }
+
+        public static Color GetLightBehindObjectWireframeColor(Color wireframeColor)
+        {
+            Color color = wireframeColor;
+            color.a = 0.2f;
+            return RemapLightColor(CoreUtils.ConvertLinearToActiveColorSpace(color.linear));
+        }
+
+        static Color RemapLightColor(Color src)
+        {
+            Color color = src;
+            float max = Mathf.Max( Mathf.Max(color.r, color.g), color.b);
+            if (max > 0f)
+            {
+                float mult = 1f / max;
+                color.r *= mult;
+                color.g *= mult;
+                color.b *= mult;
+            }
+            else
+            {
+                color = Color.white;
+            }
+
+            return color;
+        }
+
+        static void DrawSpotlightWireframe(Light spotlight, Color outerColor, Color innerColor)
+        {
+            // Variable for which direction to draw the handles
+            HandleDirections DrawHandleDirections;
+
+            float outerAngle = spotlight.spotAngle;
+            float innerAngle = spotlight.innerSpotAngle;
+            float range = spotlight.range;
+
+            var outerDiscRadius = range * Mathf.Sin(outerAngle * Mathf.Deg2Rad * 0.5f);
+            var outerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * outerAngle * 0.5f) * range;
+            var vectorLineUp = Vector3.Normalize(Vector3.forward * outerDiscDistance + Vector3.up * outerDiscRadius);
+            var vectorLineLeft = Vector3.Normalize(Vector3.forward * outerDiscDistance + Vector3.left * outerDiscRadius);
+
+            // Need to check if we need to draw inner angle
+            // Need to disable this for now until we get all the inner angle baking working.
+            if(innerAngle > 0f && drawInnerConeAngle)
+            {
+                DrawHandleDirections = HandleDirections.Up | HandleDirections.Down;
+                var innerDiscRadius = range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
+                var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * range;
+
+                // Drawing the inner Cone and also z-testing it to draw another color if behind
+                Handles.color = innerColor;
+                DrawConeWireframe(innerDiscRadius, innerDiscDistance, DrawHandleDirections);
+            }
+
+            // Draw range line
+            Handles.color = innerColor;
+            var rangeCenter = Vector3.forward * range;
+            Handles.DrawLine(Vector3.zero, rangeCenter);
+
+            // Drawing the outer Cone and also z-testing it to draw another color if behind
+            Handles.color = outerColor;
+
+            DrawHandleDirections = HandleDirections.Left | HandleDirections.Right;
+            DrawConeWireframe(outerDiscRadius, outerDiscDistance, DrawHandleDirections);
+
+            // Bottom arcs, making a nice rounded shape
+            Handles.DrawWireArc(Vector3.zero, Vector3.right, vectorLineUp, outerAngle, range);
+            Handles.DrawWireArc(Vector3.zero, Vector3.up, vectorLineLeft, outerAngle, range);
+
+            // If we are using shadows we draw the near plane for shadows
+            if(spotlight.shadows != LightShadows.None && spotlight.lightmapBakeType != LightmapBakeType.Baked)
+            {
+                DrawShadowNearPlane(spotlight, innerColor);
+            }
+        }
+
+        static void DrawShadowNearPlane(Light spotlight, Color color)
+        {
+            Color previousColor = Handles.color;
+            Handles.color = color;
+
+            var shadowDiscRadius = Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f) * spotlight.shadowNearPlane;
+            var shadowDiscDistance = spotlight.shadowNearPlane ;
+            Handles.DrawWireDisc(Vector3.forward * shadowDiscDistance, Vector3.forward, shadowDiscRadius);
+            Handles.DrawLine(Vector3.forward * shadowDiscDistance, (Vector3.right * shadowDiscRadius) + (Vector3.forward * shadowDiscDistance));
+            Handles.DrawLine(Vector3.forward * shadowDiscDistance, (-Vector3.right * shadowDiscRadius) + (Vector3.forward * shadowDiscDistance));
+
+            Handles.color = previousColor;
+        }
+
+        static void DrawConeWireframe(float radius, float height, HandleDirections handleDirections)
+        {
+            var rangeCenter = Vector3.forward * height;
+            if (handleDirections.HasFlag(HandleDirections.Up))
+            {
+                var rangeUp = rangeCenter + Vector3.up * radius;
+                Handles.DrawLine(Vector3.zero, rangeUp);
+            }
+
+            if (handleDirections.HasFlag(HandleDirections.Down))
+            {
+                var rangeDown = rangeCenter - Vector3.up * radius;
+                Handles.DrawLine(Vector3.zero, rangeDown);
+            }
+
+            if (handleDirections.HasFlag(HandleDirections.Right))
+            {
+                var rangeRight = rangeCenter + Vector3.right * radius;
+                Handles.DrawLine(Vector3.zero, rangeRight);
+            }
+
+            if (handleDirections.HasFlag(HandleDirections.Left))
+            {
+                var rangeLeft = rangeCenter - Vector3.right * radius;
+                Handles.DrawLine(Vector3.zero, rangeLeft);
+            }
+
+            //Draw Circle
+            Handles.DrawWireDisc(rangeCenter, Vector3.forward, radius);
+        }
+
+        static float DrawConeHandles(Vector3 position, float angle, float range, HandleDirections handleDirections, string controlName)
+        {
+            if(handleDirections.HasFlag(HandleDirections.Left))
+            {
+                angle = SizeSliderSpotAngle(position, Vector3.forward, -Vector3.right, range, angle, controlName);
+            }
+            if(handleDirections.HasFlag(HandleDirections.Up))
+            {
+                angle = SizeSliderSpotAngle(position, Vector3.forward, Vector3.up, range, angle, controlName);
+            }
+            if(handleDirections.HasFlag(HandleDirections.Right))
+            {
+                angle = SizeSliderSpotAngle(position, Vector3.forward, Vector3.right, range, angle, controlName);
+            }
+            if(handleDirections.HasFlag(HandleDirections.Down))
+            {
+                angle = SizeSliderSpotAngle(position, Vector3.forward, -Vector3.up, range, angle, controlName);
+            }
+            return angle;
+        }
+
         static Vector2 SliderPlaneHandle(Vector3 origin, Vector3 axis1, Vector3 axis2, Vector2 position)
         {
             Vector3 pos = origin + position.x * axis1 + position.y * axis2;
 
         static float SliderLineHandle(Vector3 position, Vector3 direction, float value)
         {
+            return SliderLineHandle(GUIUtility.GetControlID(FocusType.Passive), position, direction, value, "");
+        }
+        static float SliderLineHandle(int id, Vector3 position, Vector3 direction, float value, string labelText = "")
+        {
-            pos = Handles.Slider(pos, direction, sizeHandle * 0.03f, Handles.DotHandleCap, 0f);
+            pos = Handles.Slider(id, pos, direction, sizeHandle * 0.03f, Handles.DotHandleCap, 0f);
+
+            if (GUIUtility.hotControl == id && !String.IsNullOrEmpty(labelText))
+            {
+                labelText += FormattableString.Invariant($"{value:0.00}");
+                DrawHandleLabel(pos, labelText);
+            }
+
             return value;
         }
 
             return angleValue;
         }
 
-        static int s_SliderSpotAngleId;
-
-        static float SizeSliderSpotAngle(Vector3 position, Vector3 forward, Vector3 axis, float range, float spotAngle)
+        static float SizeSliderSpotAngle(Vector3 position, Vector3 forward, Vector3 axis, float range, float spotAngle, string controlName)
-            if (Math.Abs(spotAngle) <= 0.05f && GUIUtility.hotControl != s_SliderSpotAngleId)
+            if (Math.Abs(spotAngle) <= 0.05f)
-            var newMagnitude = Mathf.Max(0f, SliderLineHandle(position + forward * range, centerToLeftOnSphere.normalized, centerToLeftOnSphere.magnitude));
+            var handlePosition = position + forward * range;
+            var id = GUIUtility.GetControlID(FocusType.Passive);
+            var newMagnitude = Mathf.Max(0f, SliderLineHandle(id, handlePosition, centerToLeftOnSphere.normalized, centerToLeftOnSphere.magnitude));
-                s_SliderSpotAngleId = GUIUtility.hotControl;
                 centerToLeftOnSphere = centerToLeftOnSphere.normalized * newMagnitude;
                 angledForward = (centerToLeftOnSphere + (position + forward * range) - position).normalized;
                 spotAngle = Mathf.Clamp(Mathf.Acos(Vector3.Dot(forward, angledForward)) * Mathf.Rad2Deg * 2, 0f, 179f);
             GUI.changed |= temp;
+
+            if (GUIUtility.hotControl == id)
+            {
+                var pos = handlePosition + centerToLeftOnSphere.normalized * newMagnitude;
+                string labelText = FormattableString.Invariant($"{controlName} {spotAngle:0.00}");
+                DrawHandleLabel(pos, labelText);
+            }
+
             return spotAngle;
         }
 
             return (QualitySettings.activeColorSpace == ColorSpace.Linear) ? color.linear : color;
         }
 
-        public static Color GetLightBehindObjectWireframeColor(Color wireframeColor)
-        {
-            Color color = wireframeColor;
-            color.a = 0.2f;
-            return (QualitySettings.activeColorSpace == ColorSpace.Linear) ? color.linear : color;
-        }
-
         // Don't use Handles.Disc as it break the highlight of the gizmo axis, use our own draw disc function instead for gizmo
         public static void DrawWireDisc(Quaternion q, Vector3 position, Vector3 axis, float radius)
         {
             Gizmos.DrawLine(pos, lastPos);
         }
 
+        public static Vector3 DrawSpotlightHandle(Vector3 outerAngleInnerAngleRange)
+        {
+            float outerAngle = outerAngleInnerAngleRange.x;
+            float innerAngle = outerAngleInnerAngleRange.y;
+            float range = outerAngleInnerAngleRange.z;
+
+            if (innerAngle > 0f)
+            {
+                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.right, range, innerAngle, String.Empty);
+                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.left, range, innerAngle, String.Empty);
+                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.up, range, innerAngle, String.Empty);
+                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.down, range, innerAngle, String.Empty);
+            }
+
+            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.right, range, outerAngle, String.Empty);
+            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.left, range, outerAngle, String.Empty);
+            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.up, range, outerAngle, String.Empty);
+            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.down, range, outerAngle, String.Empty);
+
+            range = SliderLineHandle(Vector3.zero, Vector3.forward, range);
+
+            return new Vector3(outerAngle, innerAngle, range);
+        }
+
         public static void DrawSpotlightWireframe(Vector3 outerAngleInnerAngleRange, float shadowPlaneDistance = -1f)
         {
             float outerAngle = outerAngleInnerAngleRange.x;
             Handles.DrawLine(Vector3.zero, rangeLeft);
 
             Handles.DrawWireDisc(Vector3.forward * height, Vector3.forward, radius);
-        }
-
-        public static Vector3 DrawSpotlightHandle(Vector3 outerAngleInnerAngleRange)
-        {
-            float outerAngle = outerAngleInnerAngleRange.x;
-            float innerAngle = outerAngleInnerAngleRange.y;
-            float range = outerAngleInnerAngleRange.z;
-
-            if (innerAngle > 0f)
-            {
-                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.right, range, innerAngle);
-                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.left, range, innerAngle);
-                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.up, range, innerAngle);
-                innerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.down, range, innerAngle);
-            }
-
-            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.right, range, outerAngle);
-            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.left, range, outerAngle);
-            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.up, range, outerAngle);
-            outerAngle = SizeSliderSpotAngle(Vector3.zero, Vector3.forward, Vector3.down, range, outerAngle);
-
-            range = SliderLineHandle(Vector3.zero, Vector3.forward, range);
-
-            return new Vector3(outerAngle, innerAngle, range);
         }
 
         public static void DrawAreaLightWireframe(Vector2 rectangleSize)

Packages/com.unity.render-pipelines.core/Editor/Lighting/CoreLightEditorUtilities.cs.meta

 fileFormatVersion: 2
-guid: 8f89186f308429942b61ec29b405e2dd
+guid: 430e769b36b6f62439bef2eb5c3eaf79
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Packages/com.unity.render-pipelines.core/Editor/LookDev/Compositor.cs

 
             m_RenderTextures.UpdateSize(renderingData.viewPort, index, m_Renderer.pixelPerfect, renderingData.stage.camera);
 
+            int debugMode = m_Contexts.GetViewContent(index).debug.viewMode;
+            if (debugMode != -1)
+                LookDev.dataProvider.UpdateDebugMode(debugMode);
+
             renderingData.output = m_RenderTextures[index, ShadowCompositionPass.WithSun];
             m_Renderer.Acquire(renderingData, RenderingPass.First);
             
 
             if (env != null)
                 m_DataProvider.UpdateSky(renderingData.stage.camera, env.sky, renderingData.stage.runtimeInterface);
+
+            if (debugMode != -1)
+                LookDev.dataProvider.UpdateDebugMode(-1);
         }
 
         void RenderSingleAndOutput(ViewIndex index)
         void RenderCompositeAndOutput()
         {
             Rect viewport = m_Displayer.GetRect(ViewCompositionIndex.Composite);
-
             AcquireDataForView(ViewIndex.First, viewport);
             AcquireDataForView(ViewIndex.Second, viewport);
             Compositing(viewport, 2 /*split*/, CompositionFinal.First);
         void Compositing(Rect rect, int pass, CompositionFinal finalBufferIndex)
         {
+            bool skipShadowComposition0 = !m_Contexts.GetViewContent(ViewIndex.First).debug.shadow;
+            bool skipShadowComposition1 = !m_Contexts.GetViewContent(ViewIndex.Second).debug.shadow;
+
-                        || m_RenderTextures[ViewIndex.First, ShadowCompositionPass.WithoutSun] == null
-                        || m_RenderTextures[ViewIndex.First, ShadowCompositionPass.ShadowMask] == null))
+                        || (!skipShadowComposition0
+                            && ( m_RenderTextures[ViewIndex.First, ShadowCompositionPass.WithoutSun] == null
+                                || m_RenderTextures[ViewIndex.First, ShadowCompositionPass.ShadowMask] == null))))
-                        || m_RenderTextures[ViewIndex.Second, ShadowCompositionPass.WithoutSun] == null
-                        || m_RenderTextures[ViewIndex.Second, ShadowCompositionPass.ShadowMask] == null)))
+                        || (!skipShadowComposition1
+                            && ( m_RenderTextures[ViewIndex.Second, ShadowCompositionPass.WithoutSun] == null
+                                || m_RenderTextures[ViewIndex.Second, ShadowCompositionPass.ShadowMask] == null)))))
             {
                 m_RenderTextures[finalBufferIndex] = null;
                 return;
             float isCurrentlyLeftEditting = m_Contexts.layout.lastFocusedView == ViewIndex.First ? 1f : -1f;
             float dragAndDropContext = 0f; //1f left, -1f right, 0f neither
             float toneMapEnabled = -1f; //1f true, -1f false
-            float shadowMultiplier0 = env0?.shadowIntensity ?? 0f;
-            float shadowMultiplier1 = env1?.shadowIntensity ?? 0f;
+            float shadowMultiplier0 = skipShadowComposition0 ? -1f : env0?.shadowIntensity ?? 0f;
+            float shadowMultiplier1 = skipShadowComposition1 ? -1f : env1?.shadowIntensity ?? 0f;
             Color shadowColor0 = env0?.shadow.color ?? Color.white;
             Color shadowColor1 = env1?.shadow.color ?? Color.white;
 

Packages/com.unity.render-pipelines.core/Editor/LookDev/Compositor.shader

         // To create the lerp mask we render the scene with a white diffuse material and a single shadow casting directional light.
         // This will create a mask where the shadowed area is 0 and the lit area is 1 with a smooth NDotL transition in-between.
         // However, the DNotL will create an unwanted darkening of the scene (it's not actually part of the lighting equation)
-        // so we sqrt it in order to avoid too much darkening.
+        // so we sort it in order to avoid too much darkening.
-        float3 colorWithoutsun = tex2D(texWithoutSun, texcoord).rgb;
-        float3 shadowMask = sqrt(tex2D(texShadowMask, texcoord).rgb);
-        return lerp(colorWithoutsun * shadowColor.rgb * shadowMultiplier, color, saturate(shadowMask.r));
+        if (shadowMultiplier < 0.0)
+        {
+            // no need to composite as we do not want shadow in this case
+            return color;
+        }
+        else
+        {
+            float3 colorWithoutsun = tex2D(texWithoutSun, texcoord).rgb;
+            float3 shadowMask = sqrt(tex2D(texShadowMask, texcoord).rgb);
+            return lerp(colorWithoutsun * shadowColor.rgb * shadowMultiplier, color, saturate(shadowMask.r));
+        }
     }
 
     ENDCG

Packages/com.unity.render-pipelines.core/Editor/LookDev/Context.cs

     }
 
     /// <summary>
-    /// Statis of the side panel of the LookDev window
+    /// Status of the side panel of the LookDev window
+    [Flags]
-        None = -1,
-        Environment,
-        Debug
+        Environment = 1,
+        DebugView1 = 2,
+        DebugView2 = 4,
+        DebugViewBoth = 6,
     }
 
     /// <summary>
 
         [SerializeField]
         internal ComparisonGizmoState gizmoState = new ComparisonGizmoState();
-        
+
         internal bool isSimpleView => viewLayout == Layout.FullFirstView || viewLayout == Layout.FullSecondView;
         internal bool isMultiView => viewLayout == Layout.HorizontalSplit || viewLayout == Layout.VerticalSplit;
         internal bool isCombinedView => viewLayout == Layout.CustomSplit;
         public CameraState camera { get; private set; } = new CameraState();
         
         /// <summary>The currently viewed debugState</summary>
-        [field: SerializeField]
         public DebugContext debug { get; private set; } = new DebugContext();
 
         //Environment asset, sub-asset (under a library) or cubemap
     /// <summary>
     /// Class that will contain debug value used.
     /// </summary>
-    [System.Serializable]
+        /// <summary>Display shadows in view.</summary>
+        public bool shadow = true;
+
+        /// <summary>Debug mode displayed. -1 means none.</summary
+        public int viewMode = -1;
+
         ///// <summary>Display the debug grey balls</summary>
         //public bool greyBalls;
 

Packages/com.unity.render-pipelines.core/Editor/LookDev/DisplayWindow-PersonalSkin.uss

     background-color: #CBCBCB;
 }
 
+.list-environment-overlay > ToolbarButton:hover
+{
+    background-color: #e8e8e8;
+}
+
 #inspector-header
 {
     background-color: #CBCBCB;
 {
     border-color: #3A72B0;
 }
+
+#environmentContainer
+{
+    border-color: #999999;
+}
+
+#debugContainer
+{
+    border-color: #999999;
+}
+
+MultipleSourcePopupField > MultipleDifferentValue
+{
+    background-color: #DFDFDF;
+}
+
+MultipleSourcePopupField > MultipleDifferentValue:hover
+{
+    background-color: #e8e8e8;
+}
+
+#sunToBrightestButton:hover
+{
+    background-color: #e8e8e8;
+}

Packages/com.unity.render-pipelines.core/Editor/LookDev/DisplayWindow.cs

 using System;
-using System.Collections.Generic;
-using System.Linq;
 using UnityEditor.UIElements;
 using UnityEngine;
 using UnityEngine.UIElements;
 
         event Action OnUpdateRequested;
     }
-
-    /// <summary>Interface that must implement the EnvironmentLibrary view to communicate with the data management</summary>
-    public interface IEnvironmentDisplayer
-    {
-        void Repaint();
-        
-        event Action<EnvironmentLibrary> OnChangingEnvironmentLibrary;
-    }
-    class DisplayWindow : EditorWindow, IViewDisplayer, IEnvironmentDisplayer
+    partial class DisplayWindow : EditorWindow, IViewDisplayer
-        static class Style
+        static partial class Style
-            public static readonly GUIContent WindowTitleAndIcon = EditorGUIUtility.TrTextContentWithIcon("Look Dev", CoreEditorUtils.LoadIcon(k_IconFolder, "LookDevMainIcon", forceLowRes: true));
-        }
+            internal static readonly GUIContent k_WindowTitleAndIcon = EditorGUIUtility.TrTextContentWithIcon("Look Dev", CoreEditorUtils.LoadIcon(k_IconFolder, "LookDev", forceLowRes: true));
+
+            internal static readonly Texture2D k_Layout1Icon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "Layout1", forceLowRes: true);
+            internal static readonly Texture2D k_Layout2Icon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "Layout2", forceLowRes: true);
+            internal static readonly Texture2D k_LayoutVerticalIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LayoutVertical", forceLowRes: true);
+            internal static readonly Texture2D k_LayoutHorizontalIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LayoutHorizontal", forceLowRes: true);
+            internal static readonly Texture2D k_LayoutStackIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LayoutCustom", forceLowRes: true);
-        // /!\ WARNING:
-        //The following const are used in the uss.
-        //If you change them, update the uss file too.
-        const string k_MainContainerName = "mainContainer";
-        const string k_EnvironmentContainerName = "environmentContainer";
-        const string k_ShowEnvironmentPanelClass = "showEnvironmentPanel";
-        const string k_ViewContainerName = "viewContainer";
-        const string k_FirstViewName = "firstView";
-        const string k_SecondViewName = "secondView";
-        const string k_ToolbarName = "toolbar";
-        const string k_ToolbarRadioName = "toolbarRadio";
-        const string k_TabsRadioName = "tabsRadio";
-        const string k_SideToolbarName = "sideToolbar";
-        const string k_SharedContainerClass = "container";
-        const string k_FirstViewClass = "firstView";
-        const string k_SecondViewsClass = "secondView";
-        const string k_VerticalViewsClass = "verticalSplit";
-        const string k_DebugContainerName = "debugContainer";
-        const string k_ShowDebugPanelClass = "showDebugPanel";
+            internal static readonly Texture2D k_Camera1Icon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "Camera1", forceLowRes: true);
+            internal static readonly Texture2D k_Camera2Icon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "Camera2", forceLowRes: true);
+            internal static readonly Texture2D k_LinkIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "Link", forceLowRes: true);
+            internal static readonly Texture2D k_RightIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "RightArrow", forceLowRes: true);
+            internal static readonly Texture2D k_LeftIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LeftArrow", forceLowRes: true);
+
+            internal static readonly Texture2D k_RenderdocIcon = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "RenderDoc", forceLowRes: true);
+            internal const string k_RenderDocLabel = " Content";
+
+            internal const string k_CameraMenuSync1On2 = "Align Camera 1 with Camera 2";
+            internal const string k_CameraMenuSync2On1 = "Align Camera 2 with Camera 1";
+            internal const string k_CameraMenuReset = "Reset Cameras";
+            
+            internal const string k_EnvironmentSidePanelName = "Environment";
+            internal const string k_DebugSidePanelName = "Debug";
+
+            internal const string k_DragAndDropObject = "Drag and drop object here";
+            internal const string k_DragAndDropEnvironment = "Drag and drop environment from side panel here";
+
+            // /!\ WARNING:
+            //The following const are used in the uss.
+            //If you change them, update the uss file too.
+            internal const string k_MainContainerName = "mainContainer";
+            internal const string k_ViewContainerName = "viewContainer";
+            internal const string k_FirstViewName = "firstView";
+            internal const string k_SecondViewName = "secondView";
+            internal const string k_ToolbarName = "toolbar";
+            internal const string k_ToolbarRadioName = "toolbarRadio";
+            internal const string k_TabsRadioName = "tabsRadio";
+            internal const string k_SideToolbarName = "sideToolbar";
+            internal const string k_SharedContainerClass = "container";
+            internal const string k_FirstViewClass = "firstView";
+            internal const string k_SecondViewsClass = "secondView";
+            internal const string k_VerticalViewsClass = "verticalSplit";
+            internal const string k_DebugContainerName = "debugContainer";
+            internal const string k_ShowDebugPanelClass = "showDebugPanel";
+
+            internal const string k_EnvironmentContainerName = "environmentContainer";
+            internal const string k_ShowEnvironmentPanelClass = "showEnvironmentPanel";
+
+            internal const string k_CameraMenuName = "cameraMenu";
+            internal const string k_CameraButtonName = "cameraButton";
+            internal const string k_CameraSeparatorName = "cameraSeparator";
+
+            internal const string k_RenderDocContentName = "renderdoc-content";
+        }
-        PopupField<string> m_DebugView;
-        VisualElement m_EnvironmentContainer;
-        ListView m_EnvironmentList;
-        EnvironmentElement m_EnvironmentInspector;
-        Toolbar m_EnvironmentListToolbar;
+        
+        LayoutContext layout
+            => LookDev.currentContext.layout;
-        Layout layout
+        Layout viewLayout
-            get => LookDev.currentContext.layout.viewLayout;
+            get => layout.viewLayout;
-                if (LookDev.currentContext.layout.viewLayout != value)
+                if (layout.viewLayout != value)
-                    OnLayoutChangedInternal?.Invoke(value, sidePanel);
+                    OnLayoutChangedInternal?.Invoke(value, layout.showedSidePanel);
-        SidePanel sidePanel
+        bool environmentSidePanel
-            get => LookDev.currentContext.layout.showedSidePanel;
+            get => (layout.showedSidePanel & SidePanel.Environment) != 0;
+            set
+            {
+                bool stored = (layout.showedSidePanel & SidePanel.Environment) != 0;
+                if (value != stored)
+                {
+                    if (value)
+                        layout.showedSidePanel |= SidePanel.Environment;
+                    else
+                        layout.showedSidePanel &= ~SidePanel.Environment;
+                    ApplySidePanelChange(layout.showedSidePanel);
+                }
+            }
+        }
+
+        bool debugView1SidePanel
+        { 
+            get => (layout.showedSidePanel & SidePanel.DebugView1) != 0;
-                if (LookDev.currentContext.layout.showedSidePanel != value)
+                bool stored = (layout.showedSidePanel & SidePanel.DebugView1) != 0;
+                if (value != stored)
-                    OnLayoutChangedInternal?.Invoke(layout, value);
-                    ApplySidePanelChange(value);
+                    if (value)
+                        layout.showedSidePanel |= SidePanel.DebugView1;
+                    else
+                        layout.showedSidePanel &= ~SidePanel.DebugView1;
+                    ApplySidePanelChange(layout.showedSidePanel);
+                }
+            }
+        }
+
+        bool debugView2SidePanel
+        { 
+            get => (layout.showedSidePanel & SidePanel.DebugView2) != 0;
+            set
+            {
+                bool stored = (layout.showedSidePanel & SidePanel.DebugView2) != 0;
+                if (value != stored)
+                {
+                    if (value)
+                        layout.showedSidePanel |= SidePanel.DebugView2;
+                    else
+                        layout.showedSidePanel &= ~SidePanel.DebugView2;
+                    ApplySidePanelChange(layout.showedSidePanel);
+
+        bool debugOneOfViewSidePanel
+            => (layout.showedSidePanel & SidePanel.DebugViewBoth) != 0;
 
         event Action<Layout, SidePanel> OnLayoutChangedInternal;
         event Action<Layout, SidePanel> IViewDisplayer.OnLayoutChanged
             remove => OnClosedInternal -= value;
         }
 
-        //event Action<UnityEngine.Object> OnAddingEnvironmentInternal;
-        //event Action<UnityEngine.Object> IEnvironmentDisplayer.OnAddingEnvironment
-        //{
-        //    add => OnAddingEnvironmentInternal += value;
-        //    remove => OnAddingEnvironmentInternal -= value;
-        //}
-
-        //event Action<int> OnRemovingEnvironmentInternal;
-        //event Action<int> IEnvironmentDisplayer.OnRemovingEnvironment
-        //{
-        //    add => OnRemovingEnvironmentInternal += value;
-        //    remove => OnRemovingEnvironmentInternal -= value;
-        //}
-
-        event Action<EnvironmentLibrary> OnChangingEnvironmentLibraryInternal;
-        event Action<EnvironmentLibrary> IEnvironmentDisplayer.OnChangingEnvironmentLibrary
-        {
-            add => OnChangingEnvironmentLibraryInternal += value;
-            remove => OnChangingEnvironmentLibraryInternal -= value;
-        }
-
         event Action OnUpdateRequestedInternal;
         event Action IViewDisplayer.OnUpdateRequested
         {
             if (!LookDev.open)
                 LookDev.Open();
 
-            titleContent = Style.WindowTitleAndIcon;
+            titleContent = Style.k_WindowTitleAndIcon;
 
             rootVisualElement.styleSheets.Add(
                 AssetDatabase.LoadAssetAtPath<StyleSheet>(Style.k_uss));
 
             CreateToolbar();
 
-            m_MainContainer = new VisualElement() { name = k_MainContainerName };
-            m_MainContainer.AddToClassList(k_SharedContainerClass);
+            m_MainContainer = new VisualElement() { name = Style.k_MainContainerName };
+            m_MainContainer.AddToClassList(Style.k_SharedContainerClass);
             rootVisualElement.Add(m_MainContainer);
 
             CreateViews();
 
-            ApplyLayout(layout);
-            ApplySidePanelChange(sidePanel);
+            ApplyLayout(viewLayout);
+            ApplySidePanelChange(layout.showedSidePanel);
         }
 
         void OnDisable() => OnClosedInternal?.Invoke();
             // Layout swapper part
-            var layoutRadio = new ToolbarRadio() { name = k_ToolbarRadioName };
+            var layoutRadio = new ToolbarRadio() { name = Style.k_ToolbarRadioName };
-                CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Layout1", forceLowRes: true),
-                CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Layout2", forceLowRes: true),
-                CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_LayoutVertical", forceLowRes: true),
-                CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_LayoutHorizontal", forceLowRes: true),
-                CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_LayoutCustom", forceLowRes: true)
+                Style.k_Layout1Icon,
+                Style.k_Layout2Icon,
+                Style.k_LayoutVerticalIcon,
+                Style.k_LayoutHorizontalIcon,
+                Style.k_LayoutStackIcon,
-                => layout = (Layout)evt.newValue);
-            layoutRadio.SetValueWithoutNotify((int)layout);
+                => viewLayout = (Layout)evt.newValue);
+            layoutRadio.SetValueWithoutNotify((int)viewLayout);
-            var cameraMenu = new ToolbarMenu() { name = "cameraMenu" };
+            var cameraMenu = new ToolbarMenu() { name = Style.k_CameraMenuName };
-            var cameraToggle = new ToolbarToggle() { name = "cameraButton" };
+            var cameraToggle = new ToolbarToggle() { name = Style.k_CameraButtonName };
             cameraToggle.value = LookDev.currentContext.cameraSynced;
 
             //Note: when having Image on top of the Toggle nested in the Menu, RegisterValueChangedCallback is not called
                 cameraToggle.SetValueWithoutNotify(LookDev.currentContext.cameraSynced);
             });
 
-            var cameraSeparator = new ToolbarToggle() { name = "cameraSeparator" };
-            var texCamera1 = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Camera1", forceLowRes: true);
-            var texCamera2 = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Camera2", forceLowRes: true);
-            var texLink = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Link", forceLowRes: true);
-            var texRight = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Right", forceLowRes: true);
-            var texLeft = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_Left", forceLowRes: true);
-            cameraToggle.Add(new Image() { image = texCamera1 });
-            cameraToggle.Add(new Image() { image = texLink });
-            cameraToggle.Add(new Image() { image = texCamera2 });
+            var cameraSeparator = new ToolbarToggle() { name = Style.k_CameraSeparatorName };
+            cameraToggle.Add(new Image() { image = Style.k_Camera1Icon });
+            cameraToggle.Add(new Image() { image = Style.k_LinkIcon });
+            cameraToggle.Add(new Image() { image = Style.k_Camera2Icon });
-            cameraMenu.menu.AppendAction("Align Camera 1 with Camera 2",
+            cameraMenu.menu.AppendAction(Style.k_CameraMenuSync1On2,
-            cameraMenu.menu.AppendAction("Align Camera 2 with Camera 1",
+            cameraMenu.menu.AppendAction(Style.k_CameraMenuSync2On1,
-            cameraMenu.menu.AppendAction("Reset Cameras",
+            cameraMenu.menu.AppendAction(Style.k_CameraMenuReset,
                 (DropdownMenuAction a) =>
                 {
                     LookDev.currentContext.GetViewContent(ViewIndex.First).ResetCameraState();
 
             // Side part
-            var sideRadio = new ToolbarRadio(canDeselectAll: true) { name = k_TabsRadioName };
-            sideRadio.AddRadios(new[] {
-                "Environment",
-                "Debug"
-            });
-            sideRadio.RegisterCallback((ChangeEvent<int> evt) =>
+            var sideEnvironmentToggle = new ToolbarToggle()
+            {
+                text = Style.k_EnvironmentSidePanelName,
+                name = Style.k_TabsRadioName
+            };
+            sideEnvironmentToggle.SetValueWithoutNotify(environmentSidePanel);
+            sideEnvironmentToggle.RegisterCallback((ChangeEvent<bool> evt)
+                => environmentSidePanel = evt.newValue);
+
+            var sideDebugToggleView1 = new ToolbarToggle()
+            {
+                name = Style.k_TabsRadioName
+            };
+            var sideDebugToggleView1Container = sideDebugToggleView1.Q(className:"unity-toggle__input");
+            sideDebugToggleView1Container.Add(new Label(Style.k_DebugSidePanelName));
+            sideDebugToggleView1Container.Add(new Image() { image = Style.k_Camera1Icon });
+            sideDebugToggleView1.SetValueWithoutNotify(debugView1SidePanel);
+            sideDebugToggleView1.RegisterCallback((ChangeEvent<bool> evt)
+                => debugView1SidePanel = evt.newValue);
+
+            var sideDebugToggleView2 = new ToolbarToggle()
-                sidePanel = (SidePanel)evt.newValue;
-                if (sidePanel == SidePanel.Debug)
-                    RefreshDebugViews();
-            });
-            sideRadio.SetValueWithoutNotify((int)sidePanel);
+                name = Style.k_TabsRadioName
+            };
+            var sideDebugToggleView2Container = sideDebugToggleView2.Q(className: "unity-toggle__input");
+            sideDebugToggleView2Container.Add(new Label(Style.k_DebugSidePanelName));
+            sideDebugToggleView2Container.Add(new Image() { image = Style.k_Camera2Icon });
+            sideDebugToggleView2.SetValueWithoutNotify(debugView2SidePanel);
+            sideDebugToggleView2.RegisterCallback((ChangeEvent<bool> evt)
+                => debugView2SidePanel = evt.newValue);
-            var sideToolbar = new Toolbar() { name = k_SideToolbarName };
-            sideToolbar.Add(sideRadio);
+            var sideToolbar = new Toolbar() { name = Style.k_SideToolbarName };
+            sideToolbar.Add(sideEnvironmentToggle);
+            sideToolbar.Add(sideDebugToggleView1);
+            sideToolbar.Add(sideDebugToggleView2);
-            var toolbar = new Toolbar() { name = k_ToolbarName };
+            var toolbar = new Toolbar() { name = Style.k_ToolbarName };
             toolbar.Add(layoutRadio);
             toolbar.Add(new ToolbarSpacer());
             toolbar.Add(cameraMenu);
             {
                 var renderDocButton = new ToolbarButton(() => OnRenderDocAcquisitionTriggeredInternal?.Invoke())
                 {
-                    name = "renderdoc-content"
+                    name = Style.k_RenderDocContentName
-                renderDocButton.Add(new Image()
-                {
-                    image = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "renderdoc", forceLowRes: true)
-                });
-                renderDocButton.Add(new Label() { text = " Content" });
+                renderDocButton.Add(new Image() { image = Style.k_RenderdocIcon });
+                renderDocButton.Add(new Label() { text = Style.k_RenderDocLabel });
+                toolbar.Add(new ToolbarSpacer());
             }
             toolbar.Add(sideToolbar);
             rootVisualElement.Add(toolbar);
             if (m_MainContainer == null || m_MainContainer.Equals(null))
                 throw new System.MemberAccessException("m_MainContainer should be assigned prior CreateViews()");
 
-            m_ViewContainer = new VisualElement() { name = k_ViewContainerName };
-            m_ViewContainer.AddToClassList(LookDev.currentContext.layout.isMultiView ? k_SecondViewsClass : k_FirstViewClass);
-            m_ViewContainer.AddToClassList(k_SharedContainerClass);
+            m_ViewContainer = new VisualElement() { name = Style.k_ViewContainerName };
+            m_ViewContainer.AddToClassList(LookDev.currentContext.layout.isMultiView ? Style.k_SecondViewsClass : Style.k_FirstViewClass);
+            m_ViewContainer.AddToClassList(Style.k_SharedContainerClass);
-            m_Views[(int)ViewIndex.First] = new Image() { name = k_FirstViewName, image = Texture2D.blackTexture };
+            m_Views[(int)ViewIndex.First] = new Image() { name = Style.k_FirstViewName, image = Texture2D.blackTexture };
-            m_Views[(int)ViewIndex.Second] = new Image() { name = k_SecondViewName, image = Texture2D.blackTexture };
+            m_Views[(int)ViewIndex.Second] = new Image() { name = Style.k_SecondViewName, image = Texture2D.blackTexture };
             m_ViewContainer.Add(m_Views[(int)ViewIndex.Second]);
 
             var firstOrCompositeManipulator = new SwitchableCameraController(
                 {
                     LookDev.currentContext.SetFocusedCamera(index);
                     var environment = LookDev.currentContext.GetViewContent(index).environment;
-                    if (sidePanel == SidePanel.Environment && environment != null)
+                    if (environmentSidePanel && environment != null)
                         m_EnvironmentList.selectedIndex = LookDev.currentContext.environmentLibrary.IndexOf(environment);
                 });
             var secondManipulator = new CameraController(
                 {
                     LookDev.currentContext.SetFocusedCamera(ViewIndex.Second);
                     var environment = LookDev.currentContext.GetViewContent(ViewIndex.Second).environment;
-                    if (sidePanel == SidePanel.Environment && environment != null)
+                    if (environmentSidePanel && environment != null)
                         m_EnvironmentList.selectedIndex = LookDev.currentContext.environmentLibrary.IndexOf(environment);
                 });
             var gizmoManipulator = new ComparisonGizmoController(LookDev.currentContext.layout.gizmoState, firstOrCompositeManipulator);
 
-            m_NoObject1 = new Label("Drag'n'drop object here");
+            m_NoObject1 = new Label(Style.k_DragAndDropObject);
-            m_NoObject2 = new Label("Drag'n'drop object here");
+            m_NoObject2 = new Label(Style.k_DragAndDropObject);
-            m_NoEnvironment1 = new Label("Drag'n'drop environment from side panel here");
+            m_NoEnvironment1 = new Label(Style.k_DragAndDropEnvironment);
-            m_NoEnvironment2 = new Label("Drag'n'drop environment from side panel here");
+            m_NoEnvironment2 = new Label(Style.k_DragAndDropEnvironment);
             m_NoEnvironment2.style.flexGrow = 1;
             m_NoEnvironment2.style.unityTextAlign = TextAnchor.MiddleCenter;
             m_Views[(int)ViewIndex.First].Add(m_NoObject1);
             // GameObject or Prefab in view
             new DropArea(new[] { typeof(GameObject) }, m_Views[(int)ViewIndex.First], (obj, localPos) =>
             {
-                if (layout == Layout.CustomSplit)
+                if (viewLayout == Layout.CustomSplit)
                     OnChangingObjectInViewInternal?.Invoke(obj as GameObject, ViewCompositionIndex.Composite, localPos);
                 else
                     OnChangingObjectInViewInternal?.Invoke(obj as GameObject, ViewCompositionIndex.First, localPos);
             // Environment in view
             new DropArea(new[] { typeof(Environment), typeof(Cubemap) }, m_Views[(int)ViewIndex.First], (obj, localPos) =>
             {
-                if (layout == Layout.CustomSplit)
+                if (viewLayout == Layout.CustomSplit)
                     OnChangingEnvironmentInViewInternal?.Invoke(obj, ViewCompositionIndex.Composite, localPos);
                 else
                     OnChangingEnvironmentInViewInternal?.Invoke(obj, ViewCompositionIndex.First, localPos);
             });
         }
 
-        void CreateDebug()
-        {
-            if (m_MainContainer == null || m_MainContainer.Equals(null))
-                throw new System.MemberAccessException("m_MainContainer should be assigned prior CreateEnvironment()");
-
-            m_DebugContainer = new VisualElement() { name = k_DebugContainerName };
-            m_MainContainer.Add(m_DebugContainer);
-            if (sidePanel == SidePanel.Debug)
-                m_MainContainer.AddToClassList(k_ShowDebugPanelClass);
-
-
-            //[TODO: finish]
-            //Toggle greyBalls = new Toggle("Grey balls");
-            //greyBalls.SetValueWithoutNotify(LookDev.currentContext.GetViewContent(LookDev.currentContext.layout.lastFocusedView).debug.greyBalls);
-            //greyBalls.RegisterValueChangedCallback(evt =>
-            //{
-            //    LookDev.currentContext.GetViewContent(LookDev.currentContext.layout.lastFocusedView).debug.greyBalls = evt.newValue;
-            //});
-            //m_DebugContainer.Add(greyBalls);
-
-            //[TODO: debug why list sometimes empty on resource reloading]
-            //[TODO: display only per view]
-
-            RefreshDebugViews();
-        }
-
-        void RefreshDebugViews()
-        {
-            if (m_DebugView != null && m_DebugContainer.Contains(m_DebugView))
-                m_DebugContainer.Remove(m_DebugView);
-
-            List<string> list = new List<string>(LookDev.dataProvider?.supportedDebugModes ?? Enumerable.Empty<string>());
-            list.Insert(0, "None");
-            m_DebugView = new PopupField<string>("Debug view mode", list, 0);
-            m_DebugView.RegisterValueChangedCallback(evt
-                => LookDev.dataProvider.UpdateDebugMode(list.IndexOf(evt.newValue) - 1));
-            m_DebugContainer.Add(m_DebugView);
-        }
-
-        static int FirstVisibleIndex(ListView listView)
-            => (int)(listView.Q<ScrollView>().scrollOffset.y / listView.itemHeight);
-
-        void CreateEnvironment()
-        {
-            if (m_MainContainer == null || m_MainContainer.Equals(null))
-                throw new System.MemberAccessException("m_MainContainer should be assigned prior CreateEnvironment()");
-
-            m_EnvironmentContainer = new VisualElement() { name = k_EnvironmentContainerName };
-            m_MainContainer.Add(m_EnvironmentContainer);
-            if (sidePanel == SidePanel.Environment)
-                m_MainContainer.AddToClassList(k_ShowEnvironmentPanelClass);
-
-            m_EnvironmentInspector = new EnvironmentElement(withPreview: false, () =>
-            {
-                LookDev.SaveContextChangeAndApply(ViewIndex.First);
-                LookDev.SaveContextChangeAndApply(ViewIndex.Second);
-            });
-            m_EnvironmentList = new ListView();
-            m_EnvironmentList.AddToClassList("list-environment");
-            m_EnvironmentList.selectionType = SelectionType.Single;
-            m_EnvironmentList.itemHeight = EnvironmentElement.k_SkyThumbnailHeight;
-            m_EnvironmentList.makeItem = () =>
-            {
-                var preview = new Image();
-                preview.AddManipulator(new EnvironmentPreviewDragger(this, m_ViewContainer));
-                return preview;
-            };
-            m_EnvironmentList.bindItem = (e, i) =>
-            {
-                (e as Image).image = EnvironmentElement.GetLatLongThumbnailTexture(
-                    LookDev.currentContext.environmentLibrary[i],
-                    EnvironmentElement.k_SkyThumbnailWidth);
-            };
-            m_EnvironmentList.onSelectionChanged += objects =>
-            {
-                if (objects.Count == 0 || (LookDev.currentContext.environmentLibrary?.Count ?? 0) == 0)
-                {
-                    m_EnvironmentInspector.style.visibility = Visibility.Hidden;
-                    m_EnvironmentInspector.style.height = 0;
-                }
-                else
-                {
-                    m_EnvironmentInspector.style.visibility = Visibility.Visible;
-                    m_EnvironmentInspector.style.height = new StyleLength(StyleKeyword.Auto);
-                    int firstVisibleIndex = FirstVisibleIndex(m_EnvironmentList);
-                    Environment environment = LookDev.currentContext.environmentLibrary[m_EnvironmentList.selectedIndex];
-                    var container = m_EnvironmentList.Q("unity-content-container");
-                    if (m_EnvironmentList.selectedIndex - firstVisibleIndex >= container.childCount || m_EnvironmentList.selectedIndex < firstVisibleIndex)
-                    {
-                        m_EnvironmentList.ScrollToItem(m_EnvironmentList.selectedIndex);
-                        firstVisibleIndex = FirstVisibleIndex(m_EnvironmentList);
-                    }
-                    Image deportedLatLong = container[m_EnvironmentList.selectedIndex - firstVisibleIndex] as Image;
-                    m_EnvironmentInspector.Bind(environment, deportedLatLong);
-                }
-            };
-            m_EnvironmentList.onItemChosen += obj =>
-                EditorGUIUtility.PingObject(LookDev.currentContext.environmentLibrary[(int)obj]);
-            m_NoEnvironmentList = new Label("Drag'n'drop EnvironmentLibrary here");
-            m_NoEnvironmentList.style.flexGrow = 1;
-            m_NoEnvironmentList.style.unityTextAlign = TextAnchor.MiddleCenter;
-            m_EnvironmentContainer.Add(m_EnvironmentInspector);
-
-            m_EnvironmentListToolbar = new Toolbar();
-            ToolbarButton addEnvironment = new ToolbarButton(() =>
-            {
-                LookDev.currentContext.environmentLibrary.Add();
-                RefreshLibraryDisplay();
-                m_EnvironmentList.ScrollToItem(-1); //-1: scroll to end
-                m_EnvironmentList.selectedIndex = LookDev.currentContext.environmentLibrary.Count - 1;
-                ScrollToEnd();
-            })
-            {
-                name = "add",
-                tooltip = "Add new empty environment"
-            };
-            addEnvironment.Add(new Image() { image = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_EnvironmentAdd", forceLowRes: true) });
-            ToolbarButton removeEnvironment = new ToolbarButton(() =>
-            {
-                if (m_EnvironmentList.selectedIndex == -1)
-                    return;
-                LookDev.currentContext.environmentLibrary.Remove(m_EnvironmentList.selectedIndex);
-                RefreshLibraryDisplay();
-                m_EnvironmentList.selectedIndex = -1;
-            })
-            {
-                name = "remove",
-                tooltip = "Remove environment currently selected"
-            };
-            removeEnvironment.Add(new Image() { image = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_EnvironmentDelete", forceLowRes: true) });
-            ToolbarButton duplicateEnvironment = new ToolbarButton(() =>
-            {
-                if (m_EnvironmentList.selectedIndex == -1)
-                    return;
-                LookDev.currentContext.environmentLibrary.Duplicate(m_EnvironmentList.selectedIndex);
-                RefreshLibraryDisplay();
-                m_EnvironmentList.ScrollToItem(-1); //-1: scroll to end
-                m_EnvironmentList.selectedIndex = LookDev.currentContext.environmentLibrary.Count - 1;
-                ScrollToEnd();
-            })
-            {
-                name = "duplicate",
-                tooltip = "Duplicate environment currently selected"
-            };
-            duplicateEnvironment.Add(new Image() { image = CoreEditorUtils.LoadIcon(Style.k_IconFolder, "LookDev_EnvironmentDuplicate", forceLowRes: true) });
-            m_EnvironmentListToolbar.Add(addEnvironment);
-            m_EnvironmentListToolbar.Add(removeEnvironment);
-            m_EnvironmentListToolbar.Add(duplicateEnvironment);
-            m_EnvironmentListToolbar.AddToClassList("list-environment-overlay");
-
-            var m_EnvironmentInspectorSeparator = new VisualElement() { name = "separator-line" };
-            m_EnvironmentInspectorSeparator.Add(new VisualElement() { name = "separator" });
-            m_EnvironmentContainer.Add(m_EnvironmentInspectorSeparator);
-
-            VisualElement listContainer = new VisualElement();
-            listContainer.AddToClassList("list-environment");
-            listContainer.Add(m_EnvironmentList);
-            listContainer.Add(m_EnvironmentListToolbar);
-
-            var environmentListCreationToolbar = new Toolbar()
-            {
-                name = "environmentListCreationToolbar"
-            };
-            environmentListCreationToolbar.Add(new ToolbarButton(()
-                => EnvironmentLibraryCreator.Create())
-            {
-                text = "New Library",
-                tooltip = "Create a new EnvironmentLibrary"
-            });
-            environmentListCreationToolbar.Add(new ToolbarButton(()
-                => EnvironmentLibraryLoader.Load(RefreshLibraryDisplay))
-            {
-                text = "Load Library",
-                tooltip = "Load an existing EnvironmentLibrary"
-            });
-
-            m_EnvironmentContainer.Add(listContainer);
-            m_EnvironmentContainer.Add(m_NoEnvironmentList);
-            m_EnvironmentContainer.Add(environmentListCreationToolbar);
-
-            //add ability to unselect
-            m_EnvironmentList.RegisterCallback<MouseDownEvent>(evt =>
-            {
-                var clickedIndex = (int)(evt.localMousePosition.y / m_EnvironmentList.itemHeight);
-                if (clickedIndex >= m_EnvironmentList.itemsSource.Count)
-                {
-                    m_EnvironmentList.selectedIndex = -1;
-                    evt.StopPropagation();
-                }
-            });
-
-            RefreshLibraryDisplay();
-        }
-
-        //necessary as the scrollview need to be updated which take some editor frames.
-        void ScrollToEnd(int attemptRemaining = 5)
-        {
-            m_EnvironmentList.ScrollToItem(-1); //-1: scroll to end
-            if (attemptRemaining > 0)
-                EditorApplication.delayCall += () => ScrollToEnd(--attemptRemaining);
-        }
-
-        void RefreshLibraryDisplay()
-        {
-            int itemMax = LookDev.currentContext.environmentLibrary?.Count ?? 0;
-            if (itemMax == 0 || m_EnvironmentList.selectedIndex == -1)
-            {
-                m_EnvironmentInspector.style.visibility = Visibility.Hidden;
-                m_EnvironmentInspector.style.height = 0;
-            }
-            else
-            {
-                m_EnvironmentInspector.style.visibility = Visibility.Visible;
-                m_EnvironmentInspector.style.height = new StyleLength(StyleKeyword.Auto);
-            }
-            var items = new List<int>(itemMax);
-            for (int i = 0; i < itemMax; i++)
-                items.Add(i);
-            m_EnvironmentList.itemsSource = items;
-            if (LookDev.currentContext.environmentLibrary == null)
-            {
-                m_EnvironmentList
-                    .Q(className: "unity-scroll-view__vertical-scroller")
-                    .Q("unity-dragger")
-                    .style.visibility = Visibility.Hidden;
-                m_EnvironmentListToolbar.style.visibility = Visibility.Hidden;
-                m_NoEnvironmentList.style.display = DisplayStyle.Flex;
-            }
-            else
-            {
-                m_EnvironmentList
-                    .Q(className: "unity-scroll-view__vertical-scroller")
-                    .Q("unity-dragger")
-                    .style.visibility = itemMax == 0
-                        ? Visibility.Hidden
-                        : Visibility.Visible;
-                m_EnvironmentListToolbar.style.visibility = Visibility.Visible;
-                m_NoEnvironmentList.style.display = DisplayStyle.None;
-            }
-        }
-
-        DraggingContext StartDragging(VisualElement item, Vector2 worldPosition)
-            => new DraggingContext(
-                rootVisualElement,
-                item as Image,
-                //note: this even can come before the selection event of the
-                //ListView. Reconstruct index by looking at target of the event.
-                (int)item.layout.y / m_EnvironmentList.itemHeight,
-                worldPosition);
-
-        void EndDragging(DraggingContext context, Vector2 mouseWorldPosition)
-        {
-            Environment environment = LookDev.currentContext.environmentLibrary[context.draggedIndex];
-            if (m_Views[(int)ViewIndex.First].ContainsPoint(mouseWorldPosition))
-            {
-                if (layout == Layout.CustomSplit)
-                    OnChangingEnvironmentInViewInternal?.Invoke(environment, ViewCompositionIndex.Composite, mouseWorldPosition);
-                else
-                    OnChangingEnvironmentInViewInternal?.Invoke(environment, ViewCompositionIndex.First, mouseWorldPosition);
-            }
-            else
-                OnChangingEnvironmentInViewInternal?.Invoke(environment, ViewCompositionIndex.Second, mouseWorldPosition);
-        }
-
-        class DraggingContext : IDisposable
-        {
-            const string k_CursorFollowerName = "cursorFollower";
-            public readonly int draggedIndex;
-            readonly Image cursorFollower;
-            readonly Vector2 cursorOffset;
-            readonly VisualElement windowContent;
-
-            public DraggingContext(VisualElement windowContent, Image draggedElement, int draggedIndex, Vector2 worldPosition)
-            {
-                this.windowContent = windowContent;
-                this.draggedIndex = draggedIndex;
-                cursorFollower = new Image()
-                {
-                    name = k_CursorFollowerName,
-                    image = draggedElement.image
-                };
-                cursorFollower.tintColor = new Color(1f, 1f, 1f, .5f);
-                windowContent.Add(cursorFollower);
-                cursorOffset = draggedElement.WorldToLocal(worldPosition);
-
-                cursorFollower.style.position = Position.Absolute;
-                UpdateCursorFollower(worldPosition);
-            }
-
-            public void UpdateCursorFollower(Vector2 mouseWorldPosition)
-            {
-                Vector2 windowLocalPosition = windowContent.WorldToLocal(mouseWorldPosition);
-                cursorFollower.style.left = windowLocalPosition.x - cursorOffset.x;
-                cursorFollower.style.top = windowLocalPosition.y - cursorOffset.y;
-            }
-
-            public void Dispose()
-            {
-                if (windowContent.Contains(cursorFollower))
-                    windowContent.Remove(cursorFollower);
-            }
-        }
-
-        class EnvironmentPreviewDragger : Manipulator
-        {
-            VisualElement m_DropArea;
-            DisplayWindow m_Window;
-
-            //Note: static as only one drag'n'drop at a time
-            static DraggingContext s_Context;
-
-            public EnvironmentPreviewDragger(DisplayWindow window, VisualElement dropArea)
-            {
-                m_Window = window;
-                m_DropArea = dropArea;
-            }
-
-            protected override void RegisterCallbacksOnTarget()
-            {
-                target.RegisterCallback<MouseDownEvent>(OnMouseDown);
-                target.RegisterCallback<MouseUpEvent>(OnMouseUp);
-            }
-
-            protected override void UnregisterCallbacksFromTarget()
-            {
-                target.UnregisterCallback<MouseDownEvent>(OnMouseDown);
-                target.UnregisterCallback<MouseUpEvent>(OnMouseUp);
-            }
-
-            void Release()
-            {
-                target.UnregisterCallback<MouseMoveEvent>(OnMouseMove);
-                s_Context.Dispose();
-                target.ReleaseMouse();
-                s_Context = null;
-            }
-
-            void OnMouseDown(MouseDownEvent evt)
-            {
-                if (evt.button == 0)
-                {
-                    target.CaptureMouse();
-                    target.RegisterCallback<MouseMoveEvent>(OnMouseMove);
-                    s_Context = m_Window.StartDragging(target, evt.mousePosition);
-                    //do not stop event as we still need to propagate it to the ListView for selection
-                }
-            }
-
-            void OnMouseUp(MouseUpEvent evt)
-            {
-                if (evt.button != 0)
-                    return;
-                if (m_DropArea.ContainsPoint(m_DropArea.WorldToLocal(Event.current.mousePosition)))
-                {
-                    m_Window.EndDragging(s_Context, evt.mousePosition);
-                    evt.StopPropagation();
-                }
-                Release();
-            }
-
-            void OnMouseMove(MouseMoveEvent evt)
-            {
-                evt.StopPropagation();
-                s_Context.UpdateCursorFollower(evt.mousePosition);
-            }
-        }
-
         Rect IViewDisplayer.GetRect(ViewCompositionIndex index)
         {
             switch (index)
         }
         
         void IViewDisplayer.Repaint() => Repaint();
-        
-        void IEnvironmentDisplayer.Repaint()
-            => RefreshLibraryDisplay();
 
         void ApplyLayout(Layout value)
         {
             {
                 case Layout.HorizontalSplit:
                 case Layout.VerticalSplit:
-                    if (!m_ViewContainer.ClassListContains(k_FirstViewClass))
-                        m_ViewContainer.AddToClassList(k_FirstViewClass);
-                    if (!m_ViewContainer.ClassListContains(k_SecondViewsClass))
-                        m_ViewContainer.AddToClassList(k_SecondViewsClass);
+                    if (!m_ViewContainer.ClassListContains(Style.k_FirstViewClass))
+                        m_ViewContainer.AddToClassList(Style.k_FirstViewClass);
+                    if (!m_ViewContainer.ClassListContains(Style.k_SecondViewsClass))
+                        m_ViewContainer.AddToClassList(Style.k_SecondViewsClass);
-                        m_ViewContainer.AddToClassList(k_VerticalViewsClass);
-                        if (!m_ViewContainer.ClassListContains(k_VerticalViewsClass))
-                            m_ViewContainer.AddToClassList(k_FirstViewClass);
+                        m_ViewContainer.AddToClassList(Style.k_VerticalViewsClass);
+                        if (!m_ViewContainer.ClassListContains(Style.k_VerticalViewsClass))
+                            m_ViewContainer.AddToClassList(Style.k_FirstViewClass);
                     }
                     for (int i = 0; i < 2; ++i)
                         m_Views[i].style.display = DisplayStyle.Flex;
-                    if (!m_ViewContainer.ClassListContains(k_FirstViewClass))
-                        m_ViewContainer.AddToClassList(k_FirstViewClass);
-                    if (m_ViewContainer.ClassListContains(k_SecondViewsClass))
-                        m_ViewContainer.RemoveFromClassList(k_SecondViewsClass);
+                    if (!m_ViewContainer.ClassListContains(Style.k_FirstViewClass))
+                        m_ViewContainer.AddToClassList(Style.k_FirstViewClass);
+                    if (m_ViewContainer.ClassListContains(Style.k_SecondViewsClass))
+                        m_ViewContainer.RemoveFromClassList(Style.k_SecondViewsClass);
-                    if (m_ViewContainer.ClassListContains(k_FirstViewClass))
-                        m_ViewContainer.RemoveFromClassList(k_FirstViewClass);
-                    if (!m_ViewContainer.ClassListContains(k_SecondViewsClass))
-                        m_ViewContainer.AddToClassList(k_SecondViewsClass);
+                    if (m_ViewContainer.ClassListContains(Style.k_FirstViewClass))
+                        m_ViewContainer.RemoveFromClassList(Style.k_FirstViewClass);
+                    if (!m_ViewContainer.ClassListContains(Style.k_SecondViewsClass))
+                        m_ViewContainer.AddToClassList(Style.k_SecondViewsClass);
                     m_Views[0].style.display = DisplayStyle.None;
                     m_Views[1].style.display = DisplayStyle.Flex;
                     break;
 
             //Add flex direction here
             if (value == Layout.VerticalSplit)
-                m_ViewContainer.AddToClassList(k_VerticalViewsClass);
-            else if (m_ViewContainer.ClassListContains(k_VerticalViewsClass))
-                m_ViewContainer.RemoveFromClassList(k_VerticalViewsClass);
+                m_ViewContainer.AddToClassList(Style.k_VerticalViewsClass);
+            else if (m_ViewContainer.ClassListContains(Style.k_VerticalViewsClass))
+                m_ViewContainer.RemoveFromClassList(Style.k_VerticalViewsClass);
-            switch (sidePanel)
+            IStyle GetEnvironmentContenairDraggerStyle()
+                => m_EnvironmentContainer.Q(className: "unity-base-slider--vertical").Q("unity-dragger").style;
+
+            if (environmentSidePanel)
+            {
+                if (!m_MainContainer.ClassListContains(Style.k_ShowEnvironmentPanelClass))
+                    m_MainContainer.AddToClassList(Style.k_ShowEnvironmentPanelClass);
+
+                if (m_EnvironmentList.selectedIndex != -1)
+                    m_EnvironmentContainer.Q<EnvironmentElement>().style.visibility = Visibility.Visible;
+                GetEnvironmentContenairDraggerStyle().display = DisplayStyle.Flex;
+                m_EnvironmentContainer.style.display = DisplayStyle.Flex;
+            }
+            else
+            {
+                if (m_MainContainer.ClassListContains(Style.k_ShowEnvironmentPanelClass))
+                    m_MainContainer.RemoveFromClassList(Style.k_ShowEnvironmentPanelClass);
+
+                m_EnvironmentContainer.Q<EnvironmentElement>().style.visibility = Visibility.Hidden;
+                GetEnvironmentContenairDraggerStyle().display = DisplayStyle.None;
+                m_EnvironmentContainer.style.display = DisplayStyle.None;
+            }
+
+            if (debugOneOfViewSidePanel)
-                case SidePanel.None:
-                    if (m_MainContainer.ClassListContains(k_ShowEnvironmentPanelClass))
-                        m_MainContainer.RemoveFromClassList(k_ShowEnvironmentPanelClass);
-                    if (m_MainContainer.ClassListContains(k_ShowDebugPanelClass))
-                        m_MainContainer.RemoveFromClassList(k_ShowDebugPanelClass);
-                    m_EnvironmentContainer.Q<EnvironmentElement>().style.visibility = Visibility.Hidden;
-                    m_EnvironmentContainer.Q(className: "unity-base-slider--vertical").Q("unity-dragger").style.display = DisplayStyle.None;
-                    m_EnvironmentContainer.style.display = DisplayStyle.None;
-                    break;
-                case SidePanel.Environment:
-                    if (!m_MainContainer.ClassListContains(k_ShowEnvironmentPanelClass))
-                        m_MainContainer.AddToClassList(k_ShowEnvironmentPanelClass);
-                    if (m_MainContainer.ClassListContains(k_ShowDebugPanelClass))
-                        m_MainContainer.RemoveFromClassList(k_ShowDebugPanelClass);
-                    if (m_EnvironmentList.selectedIndex != -1)
-                        m_EnvironmentContainer.Q<EnvironmentElement>().style.visibility = Visibility.Visible;
-                    m_EnvironmentContainer.Q(className: "unity-base-slider--vertical").Q("unity-dragger").style.display = DisplayStyle.Flex;
-                    m_EnvironmentContainer.style.display = DisplayStyle.Flex;
-                    break;
-                case SidePanel.Debug:
-                    if (m_MainContainer.ClassListContains(k_ShowEnvironmentPanelClass))
-                        m_MainContainer.RemoveFromClassList(k_ShowEnvironmentPanelClass);
-                    if (!m_MainContainer.ClassListContains(k_ShowDebugPanelClass))
-                        m_MainContainer.AddToClassList(k_ShowDebugPanelClass);
-                    m_EnvironmentContainer.Q<EnvironmentElement>().style.visibility = Visibility.Hidden;
-                    m_EnvironmentContainer.Q(className: "unity-base-slider--vertical").Q("unity-dragger").style.display = DisplayStyle.None;
-                    m_EnvironmentContainer.style.display = DisplayStyle.None;
-                    break;
-                default:
-                    throw new ArgumentException("Unknown SidePanel");
+                if (!m_MainContainer.ClassListContains(Style.k_ShowDebugPanelClass))
+                    m_MainContainer.AddToClassList(Style.k_ShowDebugPanelClass);
+                UpdateSideDebugPanelProperties();
+            }
+            else
+            {
+                if (m_MainContainer.ClassListContains(Style.k_ShowDebugPanelClass))
+                    m_MainContainer.RemoveFromClassList(Style.k_ShowDebugPanelClass);
             }
         }
 

Packages/com.unity.render-pipelines.core/Editor/LookDev/DisplayWindow.uss

 	width: 0px;
     visibility: hidden;
     flex-direction: column-reverse;
+    border-color: #232323;
+    border-left-width: 1px;
 }
 
 #debugContainer
+    border-color: #232323;
+    border-left-width: 1px;
 }
 
 #environmentContainer > EnvironmentElement
 
 .showEnvironmentPanel > #environmentContainer
 {
-	width: 250px; /*219px;*/
+	width: 249px;
     visibility: visible;
 }
 
     -unity-text-align: middle-center;
 }
 
+#environmentListCreationToolbar > ObjectField > Label
+{
+    min-width: 60px;
+    width: 60px;
+}
+
+#environmentListCreationToolbar > ToolbarButton
+{
+    min-width: 40px;
+    width: 40px;
+    flex: 0;
+    border-left-width: 1px;
+    border-right-width: 0px;
+    margin-right: -1px;
+}
+
+ObjectFieldDisplay > Label
+{
+    -unity-text-align: middle-left;
+}
+
+ObjectFieldDisplay > Image
+{
+    min-width: 12px;
+}
+
 ToolbarButton
 {
     border-left-width: 0px;
     min-width: 20px;
     -unity-text-align: middle-center;
     background-color: #3c3c3c;
+    padding-left: 2px;
+    padding-right: 2px;
+}
+
+.list-environment-overlay > ToolbarButton:hover
+{
+    background-color: #585858;
 }
 
 .list-environment-overlay > #duplicate
-
-
 
 Image.unity-list-view__item
 {
 #separator
 {
     flex: 1;
-    width: 190px;
+    width: 188px;
     border-bottom-width: 1px;
     border-color: #232323;
     height: 0;
     margin-right: 1px;
 }
 
+#sunToBrightestButton:hover
+{
+    background-color: #585858;
+}
+
+/* /////// */
+/* /DEBUG/ */
+/* /////// */
+
+MultipleDifferentValue
+{
+    -unity-font-style: bold;
+    font-size: 15px;
+    -unity-text-align: middle-center;
+}
+
+MultipleSourcePopupField > MultipleDifferentValue
+{
+    -unity-text-align: middle-left;
+    width: 120px;
+    background-color: #515151;
+    position: absolute;
+    left: 103px;
+    bottom: 1px;
+}
+
+MultipleSourcePopupField > MultipleDifferentValue:hover
+{
+    background-color: #585858;
+}
+
+#debugToolbarLine > Label
+{
+    -unity-text-align: middle-left;
+    margin-left: 3px;
+}
+
+#debugToolbarLine > ToolbarRadio
+{
+    width: 63px;
+    border-bottom-width: 1px;
+    border-color: #232323;
+}
+
+#debugToolbarLine
+{
+    flex-direction: row;
+}
+
 /* /////// */
 /* TOOLBAR */
 /* /////// */
     flex-direction: row;
 }
 
-#toolbar > #toolbarRadio
+#toolbarRadio
 {
     flex-direction: row;
 }
     padding: 2px;
-}
-
-#toolbar > * > .unity-label
-{
-    padding-top: 3px;
-    padding-bottom: 0px;
-    min-width: 30px;
 }
 
 #sideToolbar
 
-#sideToolbar > #tabsRadio
+#sideToolbar > #tabsRadio 
+    padding-left: 3px;
+    padding-right: 3px;
+    border-left-width: 1px;
+    border-right-width: 0px;
+}
+
+#sideToolbar > #tabsRadio > * > #unity-checkmark
+{
+    height: auto;
+    min-width: 0;
+    width: 0;
+}
+
+#sideToolbar > #tabsRadio > * > Label
+{
+    min-width: 50px;
+    width: auto;
+    align-self: center;
 }
 
 .unity-toolbar-toggle
     max-width: 80px;
     flex-shrink: 0;
     min-width: 24px;
+    border-left-width: 1px;
 }
 
 #renderdoc-content > Label
+    padding-top: 0px;
 }
 
 #renderdoc-content > Image
+    min-height: 16px;
 }
 
 #cameraMenu

Packages/com.unity.render-pipelines.core/Editor/LookDev/Environment.cs

             VisualElement header = new VisualElement() { name = "inspector-header" };
             header.Add(new Image()
             {
-                image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "LookDev_EnvironmentHDR", forceLowRes: true)
+                image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "Environment", forceLowRes: true)
             });
             environmentName = new TextField();
             environmentName.isDelayed = true;
             };
             sunToBrightess.Add(new Image()
             {
-                image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "LookDev_SunPosition", forceLowRes: true)
+                image = CoreEditorUtils.LoadIcon(@"Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/", "SunPosition", forceLowRes: true)
             });
             sunToBrightess.AddToClassList("sun-to-brightest-button");
             var vector2Input = sunPosition.Q(className: "unity-vector2-field__input");

Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/RightArrow.png.meta

   serializedVersion: 10
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
-    filterMode: -1
+    filterMode: 0
-    wrapU: -1
-    wrapV: -1
+    wrapU: 1
+    wrapV: 1
-  nPOTScale: 1
+  nPOTScale: 0
-  spriteMode: 0
+  spriteMode: 1
   spriteExtrude: 1
   spriteMeshType: 1
   alignment: 0
   spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
-  alphaIsTransparency: 0
+  alphaIsTransparency: 1
-  textureType: 0
+  textureType: 8
   textureShape: 1
   singleChannelComponent: 0
   maxTextureSizeSet: 0
   - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
+    maxTextureSize: 32
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 32
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 32
     resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     outline: []
     physicsShape: []
     bones: []
-    spriteID: 
+    spriteID: 5e97eb03825dee720800000000000000
     internalID: 0
     vertices: []
     indices: 

Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/RightArrow@2x.png.meta

   serializedVersion: 10
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
-    filterMode: -1
+    filterMode: 0
-    wrapU: -1
-    wrapV: -1
+    wrapU: 1
+    wrapV: 1
-  nPOTScale: 1
+  nPOTScale: 0
-  spriteMode: 0
+  spriteMode: 1
   spriteExtrude: 1
   spriteMeshType: 1
   alignment: 0
   spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
-  alphaIsTransparency: 0
+  alphaIsTransparency: 1
-  textureType: 0
+  textureType: 8
   textureShape: 1
   singleChannelComponent: 0
   maxTextureSizeSet: 0
   - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
+    maxTextureSize: 64
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 64
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 64
     resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     outline: []
     physicsShape: []
     bones: []
-    spriteID: 
+    spriteID: 5e97eb03825dee720800000000000000
     internalID: 0
     vertices: []
     indices: 

Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/d_RightArrow.png.meta

   serializedVersion: 10
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
-    filterMode: -1
+    filterMode: 0
-    wrapU: -1
-    wrapV: -1
+    wrapU: 1
+    wrapV: 1
-  nPOTScale: 1
+  nPOTScale: 0
-  spriteMode: 0
+  spriteMode: 1
   spriteExtrude: 1
   spriteMeshType: 1
   alignment: 0
   spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
-  alphaIsTransparency: 0
+  alphaIsTransparency: 1
-  textureType: 0
+  textureType: 8
   textureShape: 1
   singleChannelComponent: 0
   maxTextureSizeSet: 0
   - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
+    maxTextureSize: 32
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 32
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 32
     resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     outline: []
     physicsShape: []
     bones: []
-    spriteID: 
+    spriteID: 5e97eb03825dee720800000000000000
     internalID: 0
     vertices: []
     indices: 

Packages/com.unity.render-pipelines.core/Editor/LookDev/Icons/d_RightArrow@2x.png.meta

   serializedVersion: 10
   mipmaps:
     mipMapMode: 0
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
   maxTextureSize: 2048
   textureSettings:
     serializedVersion: 2
-    filterMode: -1
+    filterMode: 0
-    wrapU: -1
-    wrapV: -1
+    wrapU: 1
+    wrapV: 1
-  nPOTScale: 1
+  nPOTScale: 0
-  spriteMode: 0
+  spriteMode: 1
   spriteExtrude: 1
   spriteMeshType: 1
   alignment: 0
   spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
-  alphaIsTransparency: 0
+  alphaIsTransparency: 1
-  textureType: 0
+  textureType: 8
   textureShape: 1
   singleChannelComponent: 0
   maxTextureSizeSet: 0
   - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
-    maxTextureSize: 2048
+    maxTextureSize: 64
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Standalone
+    maxTextureSize: 64
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  - serializedVersion: 3
+    buildTarget: Windows Store Apps
+    maxTextureSize: 64
     resizeAlgorithm: 0
     textureFormat: -1
     textureCompression: 1
     outline: []
     physicsShape: []
     bones: []
-    spriteID: 
+    spriteID: 5e97eb03825dee720800000000000000
     internalID: 0
     vertices: []
     indices: 

Packages/com.unity.render-pipelines.core/Editor/Resources/Advanced_Pressed_mini.png.meta

 TextureImporter:
   internalIDToNameTable: []
   externalObjects: {}
-  serializedVersion: 9
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0

Packages/com.unity.render-pipelines.core/Editor/Resources/Advanced_UnPressed_mini.png.meta

 TextureImporter:
   internalIDToNameTable: []
   externalObjects: {}
-  serializedVersion: 9
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0

Packages/com.unity.render-pipelines.core/Runtime/Common/CoreUnsafeUtils.cs

         internal struct DefaultKeyGetter<T> : IKeyGetter<T, T>
         { public T Get(ref T v) { return v; } }
 
+        // Note: this is a workaround needed to circumvent some AOT issues when building for xbox
+        internal struct UintKeyGetter : IKeyGetter<uint, uint>
+        { public uint Get(ref uint v) { return v; } }
+
+
         public static void CopyTo<T>(this List<T> list, void* dest, int count)
             where T : struct
         {
         public static unsafe void QuickSort(uint[] arr, int left, int right)
         {
             fixed (uint* ptr = arr)
-                CoreUnsafeUtils.QuickSort<uint, uint, DefaultKeyGetter<uint>>(ptr, left, right);
+                CoreUnsafeUtils.QuickSort<uint, uint, UintKeyGetter>(ptr, left, right);
         }
 
         public static void QuickSort<T>(int count, void* data)

Packages/com.unity.render-pipelines.core/Runtime/Common/XRGraphics.cs

 using System;
 using UnityEditor;
-
-#if ENABLE_VR
-
-#if UNITY_2017_2_OR_NEWER
-using XRSettings = UnityEngine.XR.XRSettings;
-#elif UNITY_5_6_OR_NEWER
-using UnityEngine.VR;
-using XRSettings = UnityEngine.VR.VRSettings;
-#endif
-
-#endif // ENABLE_VR
+    // XRGraphics insulates SRP from API changes across platforms, Editor versions, and as XR transitions into XR SDK
-    { // XRGraphics insulates SRP from API changes across platforms, Editor versions, and as XR transitions into XR SDK
-
+    {
         public enum StereoRenderingMode
         {
             MultiPass = 0,
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.eyeTextureResolutionScale;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.renderViewportScale;
 #endif
 
 #if UNITY_EDITOR
+        // TryEnable gets updated before "play" is pressed- we use this for updating GUI only.
-        { // TryEnable gets updated before "play" is pressed- we use this for updating GUI only.
+        {
+        // SRP should use this to safely determine whether XR is enabled at runtime.
-        { // SRP should use this to safely determine whether XR is enabled at runtime.
+        {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 return XRSettings.enabled;
 #else
                 return false;
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.isDeviceActive;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.loadedDeviceName;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.supportedDevices;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
-                {
-    #if UNITY_2018_3_OR_NEWER
-    #else // Reverse engineer it
-                    if (eyeTextureDesc.vrUsage == VRTextureUsage.TwoEyes)
-                    {
-                        if (eyeTextureDesc.dimension == UnityEngine.Rendering.TextureDimension.Tex2DArray)
-                            return StereoRenderingMode.SinglePassInstanced;
-                        return StereoRenderingMode.SinglePassDoubleWide;
-                    }
-                    else
-                        return StereoRenderingMode.MultiPass;
-    #endif // UNITY_2018_3_OR_NEWER
-                }
-#endif // ENABLE_VR
+#endif
 
                 return StereoRenderingMode.SinglePass;
             }
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.eyeTextureDesc;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.eyeTextureWidth;
 #endif
         {
             get
             {
-#if ENABLE_VR
+#if ENABLE_VR_MODULE
                 if (enabled)
                     return XRSettings.eyeTextureHeight;
 #endif

Packages/com.unity.render-pipelines.core/Runtime/Debugging/DebugManager.cs

 
         DebugManager()
         {
+            if (!Debug.isDebugBuild)
+                return;
+
             RegisterInputs();
             RegisterActions();
         }
         }
 
         // TODO: Optimally we should use a query path here instead of a display name
-        public DebugUI.Panel GetPanel(string displayName, bool createIfNull = false, int groupIndex = 0)
+        public DebugUI.Panel GetPanel(string displayName, bool createIfNull = false, int groupIndex = 0, bool overrideIfExist = false)
+            DebugUI.Panel p = null;
+
-                    return panel;
+                {
+                    p = panel;
+                    break;
+                }
-            DebugUI.Panel p = null;
+            if (p != null)
+            {
+                if (overrideIfExist)
+                {
+                    p.onSetDirty -= OnPanelDirty;
+                    RemovePanel(p);
+                    p = null;
+                }
+                else
+                    return p;
+            }
 
             if (createIfNull)
             {

Packages/com.unity.render-pipelines.core/Runtime/Debugging/DebugUpdater.cs

 {
     class DebugUpdater : MonoBehaviour
     {
-        //[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
-            if (FindObjectOfType<DebugUpdater>() != null)
+            if (!Debug.isDebugBuild || FindObjectOfType<DebugUpdater>() != null)
                 return;
 
             var go = new GameObject { name = "[Debug Updater]" };

Packages/com.unity.render-pipelines.core/Runtime/Debugging/Prefabs/Textures/UIArrowDown.png.meta

 fileFormatVersion: 2
 guid: f224bfd122877a34aa49c63693fc317b
 TextureImporter:
-  fileIDToRecycleName: {}
+  internalIDToNameTable: []
-  serializedVersion: 5
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0
     heightScale: 0.25
     normalMapFilter: 0
   isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
   grayScaleToAlpha: 0
   generateCubemap: 6
   cubemapConvolution: 0
     serializedVersion: 2
     filterMode: 0
     aniso: -1
-    mipBias: -1
+    mipBias: -100
     wrapU: 1
     wrapV: 1
     wrapW: -1
   spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   compressionQualitySet: 0
   textureFormatSet: 0
   platformSettings:
-  - serializedVersion: 2
+  - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
-  - serializedVersion: 2
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
     buildTarget: Standalone
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
   spriteSheet:
     serializedVersion: 2
     sprites: []
     spriteID: 90c9d85a941678d4baaa88ac23dfb063
+    internalID: 0
+    secondaryTextures: []
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Packages/com.unity.render-pipelines.core/Runtime/Debugging/Prefabs/Textures/UIElement8px.png.meta

 fileFormatVersion: 2
 guid: d49e78756811bfa4aafb8b6535417991
 TextureImporter:
-  fileIDToRecycleName: {}
+  internalIDToNameTable: []
-  serializedVersion: 5
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0
     heightScale: 0.25
     normalMapFilter: 0
   isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
   grayScaleToAlpha: 0
   generateCubemap: 6
   cubemapConvolution: 0
     serializedVersion: 2
     filterMode: 0
     aniso: -1
-    mipBias: -1
+    mipBias: -100
     wrapU: 1
     wrapV: 1
     wrapW: -1
   spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   compressionQualitySet: 0
   textureFormatSet: 0
   platformSettings:
-  - serializedVersion: 2
+  - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
-  - serializedVersion: 2
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
     buildTarget: Standalone
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
   spriteSheet:
     serializedVersion: 2
     sprites: []
     spriteID: 7c2dae9776ad5504a9e88720c35e70fb
+    internalID: 0
+    secondaryTextures: []
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Packages/com.unity.render-pipelines.core/Runtime/Debugging/Prefabs/Textures/UIFoldoutClosed.png.meta

 fileFormatVersion: 2
 guid: 7a0568d5e3330b84687e307992be3030
 TextureImporter:
-  fileIDToRecycleName: {}
+  internalIDToNameTable: []
-  serializedVersion: 5
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0
     heightScale: 0.25
     normalMapFilter: 0
   isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
   grayScaleToAlpha: 0
   generateCubemap: 6
   cubemapConvolution: 0
     serializedVersion: 2
     filterMode: 0
     aniso: -1
-    mipBias: -1
+    mipBias: -100
     wrapU: 1
     wrapV: 1
     wrapW: -1
   spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   compressionQualitySet: 0
   textureFormatSet: 0
   platformSettings:
-  - serializedVersion: 2
+  - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
-  - serializedVersion: 2
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
     buildTarget: Standalone
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
   spriteSheet:
     serializedVersion: 2
     sprites: []
     spriteID: 6d12128010a42ec4aa299147a8ff2f59
+    internalID: 0
+    secondaryTextures: []
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Packages/com.unity.render-pipelines.core/Runtime/Debugging/Prefabs/Textures/UIFoldoutOpened.png.meta

 fileFormatVersion: 2
 guid: a674720496c1ed248a5b7ea3e22a11fd
 TextureImporter:
-  fileIDToRecycleName: {}
+  internalIDToNameTable: []
-  serializedVersion: 5
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0
     heightScale: 0.25
     normalMapFilter: 0
   isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
   grayScaleToAlpha: 0
   generateCubemap: 6
   cubemapConvolution: 0
     serializedVersion: 2
     filterMode: 0
     aniso: -1
-    mipBias: -1
+    mipBias: -100
     wrapU: 1
     wrapV: 1
     wrapW: -1
   spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   compressionQualitySet: 0
   textureFormatSet: 0
   platformSettings:
-  - serializedVersion: 2
+  - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
-  - serializedVersion: 2
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
     buildTarget: Standalone
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
   spriteSheet:
     serializedVersion: 2
     sprites: []
     spriteID: da3c03fbffbf20a409999f3c408813dc
+    internalID: 0
+    secondaryTextures: []
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Packages/com.unity.render-pipelines.core/Runtime/Debugging/Prefabs/Textures/White1px.png.meta

 fileFormatVersion: 2
 guid: 127279d577f25ac4ea17dae3782e5074
 TextureImporter:
-  fileIDToRecycleName: {}
+  internalIDToNameTable: []
-  serializedVersion: 5
+  serializedVersion: 10
   mipmaps:
     mipMapMode: 0
     enableMipMap: 0
     heightScale: 0.25
     normalMapFilter: 0
   isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
   grayScaleToAlpha: 0
   generateCubemap: 6
   cubemapConvolution: 0
     serializedVersion: 2
     filterMode: -1
     aniso: -1
-    mipBias: -1
+    mipBias: -100
     wrapU: 1
     wrapV: 1
     wrapW: -1
   spriteMeshType: 0
   alignment: 0
   spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
-  spritePixelsToUnits: 100
+  spriteGenerateFallbackPhysicsShape: 1
   alphaUsage: 1
   alphaIsTransparency: 1
   spriteTessellationDetail: -1
   compressionQualitySet: 0
   textureFormatSet: 0
   platformSettings:
-  - serializedVersion: 2
+  - serializedVersion: 3
     buildTarget: DefaultTexturePlatform
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
-  - serializedVersion: 2
+    forceMaximumCompressionQuality_BC6H_BC7: 1
+  - serializedVersion: 3
     buildTarget: Standalone
     maxTextureSize: 32
     resizeAlgorithm: 1
     allowsAlphaSplitting: 0
     overridden: 0
     androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 1
   spriteSheet:
     serializedVersion: 2
     sprites: []
     spriteID: eec12fb14a4bf99489cbcab7362ea366
+    internalID: 0
+    secondaryTextures: []
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Packages/com.unity.render-pipelines.core/Runtime/RendererList/RendererList.cs

             if (desc.overrideMaterial != null)
             {
                 drawSettings.overrideMaterial = desc.overrideMaterial;
-                drawSettings.overrideMaterialPassIndex = 0;
+                drawSettings.overrideMaterialPassIndex = desc.overrideMaterialPassIndex;
-            var filterSettings = new FilteringSettings(desc.renderQueueRange)
+            var filterSettings = new FilteringSettings(desc.renderQueueRange, desc.layerMask)
             {
                 excludeMotionVectorObjects = desc.excludeObjectMotionVectors
             };
         public RenderStateBlock? stateBlock;
         public Material overrideMaterial;
         public bool excludeObjectMotionVectors;
+        public int layerMask;
+        public int overrideMaterialPassIndex;
 
         // Mandatory parameters passed through constructors
         public CullingResults cullingResult { get; private set; }
             this.passNames = null;
             this.cullingResult = cullingResult;
             this.camera = camera;
+            this.layerMask = -1;
+            this.overrideMaterialPassIndex = 0;
         }
 
         public RendererListDesc(ShaderTagId[] passNames, CullingResults cullingResult, Camera camera)
             this.passName = ShaderTagId.none;
             this.cullingResult = cullingResult;
             this.camera = camera;
+            this.layerMask = -1;
+            this.overrideMaterialPassIndex = 0;
         }
 
         public bool IsValid()

Packages/com.unity.render-pipelines.core/Runtime/Textures/TextureXR.cs

         {
             set
             {
-                //if (value > HighDefinition.ShaderConfig.s_XrMaxViews)
-                //    throw new System.NotImplementedException("Invalid XR setup for single-pass instancing: you must increase ShaderConfig.XrMaxViews");
-                //else
-                    m_MaxViews = value;
+                m_MaxViews = value;
             }
         }
 

Packages/com.unity.render-pipelines.core/Runtime/Unity.RenderPipelines.Core.Runtime.asmdef

     "precompiledReferences": [],
     "autoReferenced": true,
     "defineConstraints": [],
-    "versionDefines": []
+    "versionDefines": [
+        {
+            "name": "com.unity.modules.vr",
+            "expression": "1.0.0",
+            "define": "ENABLE_VR_MODULE"
+        },
+        {
+            "name": "com.unity.modules.xr",
+            "expression": "1.0.0",
+            "define": "ENABLE_XR_MODULE"
+        }
+    ],
+    "noEngineReferences": false
 }

Packages/com.unity.render-pipelines.core/Runtime/Utilities/ResourceReloader.cs

             if (IsNull(container))
                 return;
 
-            foreach (var fieldInfo in container.GetType().GetFields())
+            foreach (var fieldInfo in container.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static))
             {
                 //Recurse on sub-containers
                 if (IsReloadGroup(fieldInfo))

Packages/com.unity.render-pipelines.core/Runtime/Volume/Volume.cs

                 // everything is dynamic in Unity and can be changed at anytime, it's hard to keep
                 // track of changes in an elegant way (which we'd need to implement a nice cache
                 // system for generated volume meshes).
-                var type = collider.GetType();
-
-                if (type == typeof(BoxCollider))
-                {
-                    var c = (BoxCollider)collider;
-                    Gizmos.DrawCube(c.center, c.size);
-                    Gizmos.DrawWireCube(c.center, c.size + invScale * blendDistance * 2f);
-                }
-                else if (type == typeof(SphereCollider))
+                switch (collider)
-                    var c = (SphereCollider)collider;
-                    Gizmos.DrawSphere(c.center, c.radius);
-                    Gizmos.DrawWireSphere(c.center, c.radius + invScale.x * blendDistance);
-                }
-                else if (type == typeof(MeshCollider))
-                {
-                    var c = (MeshCollider)collider;
-
-                    // Only convex mesh colliders are allowed
-                    if (!c.convex)
-                        c.convex = true;
+                    case BoxCollider c:
+                        Gizmos.DrawCube(c.center, c.size);
+                        break;
+                    case SphereCollider c:
+                        // For sphere the only scale that is used is the transform.x
+                        Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one * scale.x);
+                        Gizmos.DrawSphere(c.center, c.radius);
+                        break;
+                    case MeshCollider c:
+                        // Only convex mesh m_Colliders are allowed
+                        if (!c.convex)
+                            c.convex = true;
-                    // Mesh pivot should be centered or this won't work
-                    Gizmos.DrawMesh(c.sharedMesh);
-                    Gizmos.DrawWireMesh(c.sharedMesh, Vector3.zero, Quaternion.identity, Vector3.one + invScale * blendDistance * 2f);
+                        // Mesh pivot should be centered or this won't work
+                        Gizmos.DrawMesh(c.sharedMesh);
+                        break;
+                    default:
+                        // Nothing for capsule (DrawCapsule isn't exposed in Gizmo), terrain, wheel and
+                        // other m_Colliders...
+                        break;
-
-                // Nothing for capsule (DrawCapsule isn't exposed in Gizmo), terrain, wheel and
-                // other colliders...
             }
 
             colliders.Clear();