Merge pull request #449 from Unity-Technologies/refactor-episode-2

Refactoring: Episode 2 - The Editor Strikes Back

ScriptableRenderPipeline/Core/Camera/CameraSwitcher.cs

-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering

ScriptableRenderPipeline/Core/Camera/FreeCamera.cs

-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 

ScriptableRenderPipeline/Core/Debugging/DebugActionManager.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering

ScriptableRenderPipeline/Core/Debugging/DebugItemHandler.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 using System;
 

ScriptableRenderPipeline/Core/Debugging/DebugItemUI.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/DebugMenuManager.cs

 using System;
 using System.Linq;
 using System.Reflection;
-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 

ScriptableRenderPipeline/Core/Debugging/DebugMenuState.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 using System;
 

ScriptableRenderPipeline/Core/Debugging/DebugMenuUI.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering

ScriptableRenderPipeline/Core/Debugging/DebugMenuUpdater.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/DebugPanel.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 using System;
 

ScriptableRenderPipeline/Core/Debugging/DebugPanelUI.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 using System;
 

ScriptableRenderPipeline/Core/Debugging/Debugging.cs

-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 

ScriptableRenderPipeline/Core/Debugging/Editor/DebugMenuEditor.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using UnityEditor;
 
 namespace UnityEngine.Experimental.Rendering

ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateBool.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateColor.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateFloat.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateInt.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Debugging/Serialization/DebugItemStateUInt.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering
 {

ScriptableRenderPipeline/Core/Inputs/InputRegistering.cs

-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental

ScriptableRenderPipeline/Core/Singleton.cs

-using UnityEngine.SceneManagement;
-
 namespace UnityEngine.Experimental.Rendering
 {
     [ExecuteInEditMode]

ScriptableRenderPipeline/HDRenderPipeline/Camera/HDCamera.cs

             get { return nonJitteredProjMatrix * viewMatrix; }
         }
 
-        public bool isFirstFrame
-        {
-            get { return m_FirstFrame; }
-        }
+        // Always true for cameras that just got added to the pool - needed for previous matrices to
+        // avoid one-frame jumps/hiccups with temporal effects (motion blur, TAA...)
+        public bool isFirstFrame { get; private set; }
-            get { var p = projMatrix; return new Vector4(p.m20 / (p.m00 * p.m23), p.m21 / (p.m11 * p.m23), -1.0f / p.m23, (-p.m22 + p.m20 * p.m02 / p.m00 + p.m21 * p.m12 / p.m11) / p.m23); }
+            get
+            {
+                var p = projMatrix;
+                return new Vector4(
+                    p.m20 / (p.m00 * p.m23),
+                    p.m21 / (p.m11 * p.m23),
+                    -1f / p.m23,
+                    (-p.m22 + p.m20 * p.m02 / p.m00 + p.m21 * p.m12 / p.m11) / p.m23
+                );
+            }
         }
 
         // View-projection matrix from the previous frame.
         // happen, but you never know...
         int m_LastFrameActive;
 
-        // Always true for cameras that just got added to the pool - needed for previous matrices to
-        // avoid one-frame jumps/hiccups with temporal effects (motion blur, TAA...)
-        bool m_FirstFrame;
+        static Dictionary<Camera, HDCamera> s_Cameras = new Dictionary<Camera, HDCamera>();
+        static List<Camera> s_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
 
         public HDCamera(Camera cam)
         {
             bool taaEnabled = camera.cameraType == CameraType.Game
                 && CoreUtils.IsTemporalAntialiasingActive(postProcessLayer);
 
-            Matrix4x4 nonJitteredCameraProj = camera.projectionMatrix;
-            Matrix4x4 cameraProj = taaEnabled
+            var nonJitteredCameraProj = camera.projectionMatrix;
+            var cameraProj = taaEnabled
-            Matrix4x4 gpuProj = GL.GetGPUProjectionMatrix(cameraProj, true); // Had to change this from 'false'
-            Matrix4x4 gpuView = camera.worldToCameraMatrix;
-            Matrix4x4 gpuNonJitteredProj = GL.GetGPUProjectionMatrix(nonJitteredCameraProj, true);
+            var gpuProj = GL.GetGPUProjectionMatrix(cameraProj, true); // Had to change this from 'false'
+            var gpuView = camera.worldToCameraMatrix;
+            var gpuNonJitteredProj = GL.GetGPUProjectionMatrix(nonJitteredCameraProj, true);
-            Vector3 pos = camera.transform.position;
+            var pos = camera.transform.position;
 
             if (ShaderConfig.s_CameraRelativeRendering != 0)
             {
 
-            Matrix4x4 gpuVP = gpuNonJitteredProj * gpuView;
+            var gpuVP = gpuNonJitteredProj * gpuView;
-                if (m_FirstFrame)
+                if (isFirstFrame)
                 {
                     prevCameraPos = pos;
                     prevViewProjMatrix = gpuVP;
                     prevViewProjMatrix = nonJitteredViewProjMatrix;
                 }
 
-                m_FirstFrame = false;
+                isFirstFrame = false;
             }
 
             viewMatrix = gpuView;
             screenSize = new Vector4(camera.pixelWidth, camera.pixelHeight, 1.0f / camera.pixelWidth, 1.0f / camera.pixelHeight);
 
-            Plane[] planes = GeometryUtility.CalculateFrustumPlanes(viewProjMatrix);
+            var planes = GeometryUtility.CalculateFrustumPlanes(viewProjMatrix);
 
             for (int i = 0; i < 6; i++)
             {
         public void Reset()
         {
             m_LastFrameActive = -1;
-            m_FirstFrame = true;
+            isFirstFrame = true;
-        static Dictionary<Camera, HDCamera> m_Cameras = new Dictionary<Camera, HDCamera>();
-        static List<Camera> m_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
-
-            if (!m_Cameras.TryGetValue(camera, out hdcam))
+            if (!s_Cameras.TryGetValue(camera, out hdcam))
-                m_Cameras.Add(camera, hdcam);
+                s_Cameras.Add(camera, hdcam);
             }
 
             hdcam.Update(postProcessLayer);
         {
             int frameCheck = Time.frameCount - 1;
 
-            foreach (var kvp in m_Cameras)
+            foreach (var kvp in s_Cameras)
-                    m_Cleanup.Add(kvp.Key);
+                    s_Cleanup.Add(kvp.Key);
-            foreach (var cam in m_Cleanup)
-                m_Cameras.Remove(cam);
+            foreach (var cam in s_Cleanup)
+                s_Cameras.Remove(cam);
-            m_Cleanup.Clear();
+            s_Cleanup.Clear();
         }
 
         public void SetupGlobalParams(CommandBuffer cmd)

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 using System;

ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
+using UnityEngine;
 using System;
 
 #if UNITY_EDITOR

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

 using System;
 using System.Reflection;
-using System.Linq.Expressions;
 using UnityEditor;
 using UnityEditor.Experimental.Rendering;
 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

-using UnityEngine;
-using UnityEditor;
-using UnityEngine.SceneManagement;
-using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+    using UnityObject = UnityEngine.Object;
+
-        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
+        [MenuItem("HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
-            Light[] lights = GameObject.FindObjectsOfType(typeof(Light)) as Light[];
+            var lights = UnityObject.FindObjectsOfType(typeof(Light)) as Light[];
-            foreach (Light light in lights)
+            foreach (var light in lights)
-                {
-                }
-                {
-                }
-        [UnityEditor.MenuItem("HDRenderPipeline/Add \"Additional Camera Data\" (if not present)")]
+        [MenuItem("HDRenderPipeline/Add \"Additional Camera Data\" (if not present)")]
-            Camera[] cameras = GameObject.FindObjectsOfType(typeof(Camera)) as Camera[];
+            var cameras = UnityObject.FindObjectsOfType(typeof(Camera)) as Camera[];
-            foreach (Camera camera in cameras)
+            foreach (var camera in cameras)
-                {
-                }
             }
         }
 
         {
-            Object[] materials = Resources.FindObjectsOfTypeAll<Material>();
-            foreach (Object obj in materials)
+            var materials = Resources.FindObjectsOfTypeAll<Material>();
+
+            foreach (var mat in materials)
-                Material mat = obj as Material;
                 if (mat.shader.name == "HDRenderPipeline/LayeredLit" || mat.shader.name == "HDRenderPipeline/LayeredLitTessellation")
                 {
                     LayeredLitGUI.SynchronizeAllLayers(mat);
 
         static void RemoveMaterialKeywords(Material material)
         {
-            string[] keywordsToRemove = material.shaderKeywords;
-            foreach (var keyword in keywordsToRemove)
-            {
+            foreach (var keyword in material.shaderKeywords)
-            }
         }
 
         // The goal of this script is to help maintenance of data that have already been produced but need to update to the latest shader code change.
         {
             try
             {
-                Object[] materials = Resources.FindObjectsOfTypeAll<Material>();
+                var materials = Resources.FindObjectsOfTypeAll<Material>();
+
-                    Material mat = materials[i] as Material;
+                    var mat = materials[i];
 
                     EditorUtility.DisplayProgressBar(
                         "Setup materials Keywords...",
         [MenuItem("HDRenderPipeline/Test/Remove tessellation materials (not reversible)")]
         static void RemoveTessellationMaterials()
         {
-            Object[] materials = Resources.FindObjectsOfTypeAll<Material>();
+            var materials = Resources.FindObjectsOfTypeAll<Material>();
-            Shader litShader = Shader.Find("HDRenderPipeline/Lit");
-            Shader layeredLitShader = Shader.Find("HDRenderPipeline/LayeredLit");
+            var litShader = Shader.Find("HDRenderPipeline/Lit");
+            var layeredLitShader = Shader.Find("HDRenderPipeline/LayeredLit");
-            foreach (Object obj in materials)
+            foreach (var mat in materials)
-                Material mat = obj as Material;
                 if (mat.shader.name == "HDRenderPipeline/LitTessellation")
                 {
                     mat.shader = litShader;
         [MenuItem("HDRenderPipeline/Export Sky to Image")]
         static void ExportSkyToImage()
         {
-            HDRenderPipeline renderpipeline = UnityEngine.Experimental.Rendering.RenderPipelineManager.currentPipeline as HDRenderPipeline;
-            if(renderpipeline == null)
+            var renderpipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+            if (renderpipeline == null)
-            Texture2D result = renderpipeline.ExportSkyToTexture();
-            if(result == null)
-            {
+            var result = renderpipeline.ExportSkyToTexture();
+            if (result == null)
-            }
-            byte[] bytes = null;
-            bytes = result.EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
-            Object.DestroyImmediate(result);
+            byte[] bytes = result.EncodeToEXR(Texture2D.EXRFlags.CompressZIP);
+            UnityObject.DestroyImmediate(result);
 
             string assetPath = EditorUtility.SaveFilePanel("Export Sky", "Assets", "SkyExport", "exr");
             if (!string.IsNullOrEmpty(assetPath))
         [MenuItem("GameObject/HD Render Pipeline/Scene Settings", false, 10)]
         static void CreateCustomGameObject(MenuCommand menuCommand)
         {
-            GameObject sceneSettings = new GameObject("Scene Settings");
+            var sceneSettings = new GameObject("Scene Settings");
             GameObjectUtility.SetParentAndAlign(sceneSettings, menuCommand.context as GameObject);
             Undo.RegisterCreatedObjectUndo(sceneSettings, "Create " + sceneSettings.name);
             Selection.activeObject = sceneSettings;
-        class DoCreateNewAsset<AssetType> : UnityEditor.ProjectWindowCallback.EndNameEditAction where AssetType : ScriptableObject
+        class DoCreateNewAsset<TAssetType> : ProjectWindowCallback.EndNameEditAction where TAssetType : ScriptableObject
-                var newAsset  = ScriptableObject.CreateInstance<AssetType>();
-                newAsset.name = System.IO.Path.GetFileName(pathName);
+                var newAsset  = CreateInstance<TAssetType>();
+                newAsset.name = Path.GetFileName(pathName);
                 AssetDatabase.CreateAsset(newAsset, pathName);
                 ProjectWindowUtil.ShowCreatedAsset(newAsset);
             }
         class DoCreateNewAssetHDRISkySettings : DoCreateNewAsset<HDRISkySettings> {}
         class DoCreateNewAssetProceduralSkySettings : DoCreateNewAsset<ProceduralSkySettings> {}
         class DoCreateNewAssetSSAOSettings : DoCreateNewAsset<ScreenSpaceAmbientOcclusionSettings> {}
-
-            Texture2D icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetSSSProfile>(), "New SSS Profile.asset", icon, null);
         }
 
-            Texture2D icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetCommonSettings>(), "New CommonSettings.asset", icon, null);
         }
 
-            Texture2D icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetHDRISkySettings>(), "New HDRISkySettings.asset", icon, null);
         }
 
-            Texture2D icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetProceduralSkySettings>(), "New ProceduralSkySettings.asset", icon, null);
         }
 
-            Texture2D icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
             ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetSSAOSettings>(), "New AmbientOcclusionSettings.asset", icon, null);
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

 using System.Collections.Generic;
 using UnityEngine.Rendering;
 using System;
-using System.Linq;
+using System.Diagnostics;
 using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
 
         Material m_DebugViewMaterialGBuffer;
         Material m_DebugDisplayLatlong;
         Material m_DebugFullScreen;
-#if UNITY_EDITOR
-#endif
 
         // Various buffer
         readonly int m_CameraColorBuffer;
             m_DebugViewMaterialGBuffer = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugViewMaterialGBufferShader);
             m_DebugDisplayLatlong = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugDisplayLatlongShader);
             m_DebugFullScreen = CoreUtils.CreateEngineMaterial(m_Asset.renderPipelineResources.debugFullScreenShader);
-#if UNITY_EDITOR
-#endif
         }
 
         public void CreateSssMaterials(bool useDisneySSS)
             CoreUtils.Destroy(m_DebugViewMaterialGBuffer);
             CoreUtils.Destroy(m_DebugDisplayLatlong);
             CoreUtils.Destroy(m_DebugFullScreen);
-#if UNITY_EDITOR
-#endif
 
             m_SkyManager.Cleanup();
 
                 using (new ProfilingSample(cmd, "Forward"))
                 {
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.Color | ClearFlag.Depth);
-                    ShaderPassName[] arrayShaderPassName = { HDShaderPassNames.m_ForwardName };
+                    ShaderPassName[] arrayShaderPassName = { HDShaderPassNames.s_ForwardName };
                     RenderOpaqueRenderList(m_CullResults, camera, renderContext, cmd, arrayShaderPassName);
                     RenderTransparentRenderList(m_CullResults, camera, renderContext, cmd, arrayShaderPassName);
                 }
                 SubsurfaceScatteringPass(hdCamera, cmd, m_Asset.sssSettings);
 
                 RenderForward(m_CullResults, camera, renderContext, cmd, true);
-#if UNITY_EDITOR
-#endif
 
                 RenderLightingDebug(hdCamera, cmd, m_CameraColorBufferRT, m_CurrentDebugDisplaySettings);
 
 
                 // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                 RenderForward(m_CullResults, camera, renderContext, cmd, false);
-#if UNITY_EDITOR
-#endif
+
                 // Render volumetric lighting
                 VolumetricLightingPass(hdCamera, cmd);
 
                 // This is handeled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
                 CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
                 // Note: addDepthPrepass and addForwardOnlyOpaqueDepthPrepass can't be both true at the same time. And if we are here both are not false
-                RenderOpaqueRenderList(cull, camera, renderContext, cmd, addDepthPrepass ? HDShaderPassNames.m_DepthOnlyName : HDShaderPassNames.m_ForwardOnlyOpaqueDepthOnlyName, 0, renderQueueRange);
+                RenderOpaqueRenderList(cull, camera, renderContext, cmd, addDepthPrepass ? HDShaderPassNames.s_DepthOnlyName : HDShaderPassNames.s_ForwardOnlyOpaqueDepthOnlyName, 0, renderQueueRange);
             }
         }
 
                 if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                 {
                     // When doing debug display, the shader has the clip instruction regardless of the depth prepass so we can use regular depth test.
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferDebugDisplayName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
                 }
                 else
                 {
                         RenderQueueRange rangeOpaqueAlphaTest = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
 
                         // When using depth prepass for opaque alpha test only we need to use regular depth test for normal opaque objects.
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_Asset.renderingSettings.renderAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferWithPrepassName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, HDUtils.k_RendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.m_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, HDUtils.k_RendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
                     }
                 }
             }
                 {
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, ClearFlag.All, Color.black);
                     // Render Opaque forward
-                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.m_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderOpaqueRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
-                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.m_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cull, hdCamera.camera, renderContext, cmd, HDShaderPassNames.s_ForwardDisplayDebugName, HDUtils.k_RendererConfigurationBakedLighting);
                 }
             }
 
             string profileName;
             if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
             {
-                passName = addForwardPass ? HDShaderPassNames.m_ForwardDisplayDebugName :  HDShaderPassNames.m_ForwardOnlyOpaqueDisplayDebugName;
+                passName = addForwardPass ? HDShaderPassNames.s_ForwardDisplayDebugName :  HDShaderPassNames.s_ForwardOnlyOpaqueDisplayDebugName;
-                passName = addForwardPass ? HDShaderPassNames.m_ForwardName : HDShaderPassNames.m_ForwardOnlyOpaqueName;
+                passName = addForwardPass ? HDShaderPassNames.s_ForwardName : HDShaderPassNames.s_ForwardOnlyOpaqueName;
                 profileName = addForwardPass ? (renderOpaque ? "Forward Opaque" : "Forward Transparent") :  "Forward Only Opaque";
             }
 
                 m_LightLoop.RenderForward(camera, cmd, renderOpaque);
 
                 // The pass "SRPDefaultUnlit" is a fallback to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
-                ShaderPassName[] arrayNames = { passName, HDShaderPassNames.m_SRPDefaultUnlitName};
+                ShaderPassName[] arrayNames = { passName, HDShaderPassNames.s_SRPDefaultUnlitName};
 
                 if (renderOpaque)
                 {
             }
         }
 
-#if UNITY_EDITOR
+        [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
         void RenderForwardError(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
         {
             using (new ProfilingSample(cmd, "Render Forward Error"))
-                ShaderPassName[] arrayNames = { HDShaderPassNames.m_AlwaysName, HDShaderPassNames.m_ForwardBaseName, HDShaderPassNames.m_DeferredName, HDShaderPassNames.m_PrepassBaseName, HDShaderPassNames.m_VertexName, HDShaderPassNames.m_VertexLMRGBMName, HDShaderPassNames.m_VertexLMName };
+                ShaderPassName[] arrayNames = { HDShaderPassNames.s_AlwaysName, HDShaderPassNames.s_ForwardBaseName, HDShaderPassNames.s_DeferredName, HDShaderPassNames.s_PrepassBaseName, HDShaderPassNames.s_VertexName, HDShaderPassNames.s_VertexLMRGBMName, HDShaderPassNames.s_VertexLMName };
 
                 if (renderOpaque)
                 {
                 }
             }
         }
-#endif
 
         void RenderVelocity(CullResults cullResults, HDCamera hdcam, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
                 CoreUtils.DrawFullScreen(cmd, m_CameraMotionVectorsMaterial, m_VelocityBufferRT, null, 0);
                 cmd.SetRenderTarget(m_VelocityBufferRT, m_CameraDepthStencilBufferRT);
 
-                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, cmd, HDShaderPassNames.m_MotionVectorsName, RendererConfiguration.PerObjectMotionVectors);
+                RenderOpaqueRenderList(cullResults, hdcam.camera, renderContext, cmd, HDShaderPassNames.s_MotionVectorsName, RendererConfiguration.PerObjectMotionVectors);
 
                 PushFullScreenDebugTexture(cmd, m_VelocityBuffer, hdcam.camera, renderContext, FullScreenDebugMode.MotionVectors);
             }
                 cmd.ClearRenderTarget(false, true, Color.black); // TODO: can we avoid this clear for performance ?
 
                 // Only transparent object can render distortion vectors
-                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.m_DistortionVectorsName);
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.s_DistortionVectorsName);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs

-using UnityEngine.Rendering;
-using System;
-using System.Linq;
-using UnityEngine.Rendering.PostProcessing;
-#if UNITY_EDITOR
-using UnityEditor;
-#endif
-
-    // This HDRenderPipeline assume linear lighting. Don't work with gamma.
+    // The HDRenderPipeline assumes linear lighting. Doesn't work with gamma.
-#if UNITY_EDITOR
-        [MenuItem("RenderPipeline/HDRenderPipeline/Create Pipeline Asset", false, 16)]
-        static void CreateHDRenderPipeline()
+        HDRenderPipelineAsset()
-            var instance = CreateInstance<HDRenderPipelineAsset>();
-            AssetDatabase.CreateAsset(instance, HDUtils.GetHDRenderPipelinePath() + "HDRenderPipelineAsset.asset");
-
-            // If it exist, load renderPipelineResources
-            instance.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(RenderPipelineResources.GetRenderPipelineResourcesPath());
-#endif
-
-        private HDRenderPipelineAsset()
-        { }
 
         protected override IRenderPipeline InternalCreatePipeline()
         {
         [SerializeField]
-        private RenderPipelineResources m_RenderPipelineResources;
+        RenderPipelineResources m_RenderPipelineResources;
         public RenderPipelineResources renderPipelineResources
         {
             get { return m_RenderPipelineResources; }
-        // NOTE: All those properties are public because of how HDRenderPipelineInspector retrieve those properties via serialization/reflection
-        // Doing it this way allow to change parameters name and still retrieve correct serialized value
+        // NOTE: All those properties are public because of how HDRenderPipelineInspector retrieves those properties via serialization/reflection
+        // Doing it this way allows to change parameters name and still retrieve correct serialized values
 
         // Renderer Settings
         public RenderingSettings renderingSettings = new RenderingSettings();
         [SerializeField]
         Shader m_DefaultShader;
 
-        public Material DefaultDiffuseMaterial
+        public Material defaultDiffuseMaterial
-        public Shader DefaultShader
+        public Shader defaultShader
         {
             get { return m_DefaultShader; }
             private set { m_DefaultShader = value; }
         {
             return null;
         }
-
 
         public void OnValidate()
         {

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    static class HDShaderPassNames
+    public static class HDShaderPassNames
-        internal static readonly ShaderPassName s_EmptyName = new ShaderPassName("");
-        internal static readonly ShaderPassName m_ForwardName = new ShaderPassName("Forward");
-        internal static readonly ShaderPassName m_ForwardDisplayDebugName = new ShaderPassName("ForwardDisplayDebug");
-        internal static readonly ShaderPassName m_DepthOnlyName = new ShaderPassName("DepthOnly");
-        internal static readonly ShaderPassName m_ForwardOnlyOpaqueDepthOnlyName = new ShaderPassName("ForwardOnlyOpaqueDepthOnly");
-        internal static readonly ShaderPassName m_ForwardOnlyOpaqueName = new ShaderPassName("ForwardOnlyOpaque");
-        internal static readonly ShaderPassName m_ForwardOnlyOpaqueDisplayDebugName = new ShaderPassName("ForwardOnlyOpaqueDisplayDebug");
-        internal static readonly ShaderPassName m_GBufferName = new ShaderPassName("GBuffer");
-        internal static readonly ShaderPassName m_GBufferWithPrepassName = new ShaderPassName("GBufferWithPrepass");
-        internal static readonly ShaderPassName m_GBufferDebugDisplayName = new ShaderPassName("GBufferDebugDisplay");
-        internal static readonly ShaderPassName m_SRPDefaultUnlitName = new ShaderPassName("SRPDefaultUnlit");
-        internal static readonly ShaderPassName m_MotionVectorsName = new ShaderPassName("MotionVectors");
-        internal static readonly ShaderPassName m_DistortionVectorsName = new ShaderPassName("DistortionVectors");
+        public static readonly ShaderPassName s_EmptyName = new ShaderPassName("");
+        public static readonly ShaderPassName s_ForwardName = new ShaderPassName("Forward");
+        public static readonly ShaderPassName s_ForwardDisplayDebugName = new ShaderPassName("ForwardDisplayDebug");
+        public static readonly ShaderPassName s_DepthOnlyName = new ShaderPassName("DepthOnly");
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueDepthOnlyName = new ShaderPassName("ForwardOnlyOpaqueDepthOnly");
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueName = new ShaderPassName("ForwardOnlyOpaque");
+        public static readonly ShaderPassName s_ForwardOnlyOpaqueDisplayDebugName = new ShaderPassName("ForwardOnlyOpaqueDisplayDebug");
+        public static readonly ShaderPassName s_GBufferName = new ShaderPassName("GBuffer");
+        public static readonly ShaderPassName s_GBufferWithPrepassName = new ShaderPassName("GBufferWithPrepass");
+        public static readonly ShaderPassName s_GBufferDebugDisplayName = new ShaderPassName("GBufferDebugDisplay");
+        public static readonly ShaderPassName s_SRPDefaultUnlitName = new ShaderPassName("SRPDefaultUnlit");
+        public static readonly ShaderPassName s_MotionVectorsName = new ShaderPassName("MotionVectors");
+        public static readonly ShaderPassName s_DistortionVectorsName = new ShaderPassName("DistortionVectors");
-        internal static readonly ShaderPassName m_AlwaysName = new ShaderPassName("Always");
-        internal static readonly ShaderPassName m_ForwardBaseName = new ShaderPassName("ForwardBase");
-        internal static readonly ShaderPassName m_DeferredName = new ShaderPassName("Deferred");
-        internal static readonly ShaderPassName m_PrepassBaseName = new ShaderPassName("PrepassBase");
-        internal static readonly ShaderPassName m_VertexName = new ShaderPassName("Vertex");
-        internal static readonly ShaderPassName m_VertexLMRGBMName = new ShaderPassName("VertexLMRGBM");
-        internal static readonly ShaderPassName m_VertexLMName = new ShaderPassName("VertexLM");
+        public static readonly ShaderPassName s_AlwaysName = new ShaderPassName("Always");
+        public static readonly ShaderPassName s_ForwardBaseName = new ShaderPassName("ForwardBase");
+        public static readonly ShaderPassName s_DeferredName = new ShaderPassName("Deferred");
+        public static readonly ShaderPassName s_PrepassBaseName = new ShaderPassName("PrepassBase");
+        public static readonly ShaderPassName s_VertexName = new ShaderPassName("Vertex");
+        public static readonly ShaderPassName s_VertexLMRGBMName = new ShaderPassName("VertexLMRGBM");
+        public static readonly ShaderPassName s_VertexLMName = new ShaderPassName("VertexLM");
+
-    // fields names as in the shaders for ease of use... Would be nice to clean this up at some
-    // point.
-    static class HDShaderIDs
+    // fields names as in the shaders for ease of use...
+    // TODO: Would be nice to clean this up at some point
+    public static class HDShaderIDs
-        internal static readonly int _ShadowDatasExp = Shader.PropertyToID("_ShadowDatasExp");
-        internal static readonly int _ShadowPayloads = Shader.PropertyToID("_ShadowPayloads");
-        internal static readonly int _ShadowmapExp_VSM_0 = Shader.PropertyToID("_ShadowmapExp_VSM_0");
-        internal static readonly int _ShadowmapExp_VSM_1 = Shader.PropertyToID("_ShadowmapExp_VSM_1");
-        internal static readonly int _ShadowmapExp_VSM_2 = Shader.PropertyToID("_ShadowmapExp_VSM_2");
-        internal static readonly int _ShadowmapExp_PCF = Shader.PropertyToID("_ShadowmapExp_PCF");
+        public static readonly int _ShadowDatasExp = Shader.PropertyToID("_ShadowDatasExp");
+        public static readonly int _ShadowPayloads = Shader.PropertyToID("_ShadowPayloads");
+        public static readonly int _ShadowmapExp_VSM_0 = Shader.PropertyToID("_ShadowmapExp_VSM_0");
+        public static readonly int _ShadowmapExp_VSM_1 = Shader.PropertyToID("_ShadowmapExp_VSM_1");
+        public static readonly int _ShadowmapExp_VSM_2 = Shader.PropertyToID("_ShadowmapExp_VSM_2");
+        public static readonly int _ShadowmapExp_PCF = Shader.PropertyToID("_ShadowmapExp_PCF");
-        internal static readonly int g_LayeredSingleIdxBuffer = Shader.PropertyToID("g_LayeredSingleIdxBuffer");
-        internal static readonly int _EnvLightIndexShift = Shader.PropertyToID("_EnvLightIndexShift");
-        internal static readonly int g_isOrthographic = Shader.PropertyToID("g_isOrthographic");
-        internal static readonly int g_iNrVisibLights = Shader.PropertyToID("g_iNrVisibLights");
-        internal static readonly int g_mScrProjection = Shader.PropertyToID("g_mScrProjection");
-        internal static readonly int g_mInvScrProjection = Shader.PropertyToID("g_mInvScrProjection");
-        internal static readonly int g_iLog2NumClusters = Shader.PropertyToID("g_iLog2NumClusters");
-        internal static readonly int g_fNearPlane = Shader.PropertyToID("g_fNearPlane");
-        internal static readonly int g_fFarPlane = Shader.PropertyToID("g_fFarPlane");
-        internal static readonly int g_fClustScale = Shader.PropertyToID("g_fClustScale");
-        internal static readonly int g_fClustBase = Shader.PropertyToID("g_fClustBase");
-        internal static readonly int g_depth_tex = Shader.PropertyToID("g_depth_tex");
-        internal static readonly int g_vLayeredLightList = Shader.PropertyToID("g_vLayeredLightList");
-        internal static readonly int g_LayeredOffset = Shader.PropertyToID("g_LayeredOffset");
-        internal static readonly int g_vBigTileLightList = Shader.PropertyToID("g_vBigTileLightList");
-        internal static readonly int g_logBaseBuffer = Shader.PropertyToID("g_logBaseBuffer");
-        internal static readonly int g_vBoundsBuffer = Shader.PropertyToID("g_vBoundsBuffer");
-        internal static readonly int _LightVolumeData = Shader.PropertyToID("_LightVolumeData");
-        internal static readonly int g_data = Shader.PropertyToID("g_data");
-        internal static readonly int g_mProjection = Shader.PropertyToID("g_mProjection");
-        internal static readonly int g_mInvProjection = Shader.PropertyToID("g_mInvProjection");
-        internal static readonly int g_viDimensions = Shader.PropertyToID("g_viDimensions");
-        internal static readonly int g_vLightList = Shader.PropertyToID("g_vLightList");
+        public static readonly int g_LayeredSingleIdxBuffer = Shader.PropertyToID("g_LayeredSingleIdxBuffer");
+        public static readonly int _EnvLightIndexShift = Shader.PropertyToID("_EnvLightIndexShift");
+        public static readonly int g_isOrthographic = Shader.PropertyToID("g_isOrthographic");
+        public static readonly int g_iNrVisibLights = Shader.PropertyToID("g_iNrVisibLights");
+        public static readonly int g_mScrProjection = Shader.PropertyToID("g_mScrProjection");
+        public static readonly int g_mInvScrProjection = Shader.PropertyToID("g_mInvScrProjection");
+        public static readonly int g_iLog2NumClusters = Shader.PropertyToID("g_iLog2NumClusters");
+        public static readonly int g_fNearPlane = Shader.PropertyToID("g_fNearPlane");
+        public static readonly int g_fFarPlane = Shader.PropertyToID("g_fFarPlane");
+        public static readonly int g_fClustScale = Shader.PropertyToID("g_fClustScale");
+        public static readonly int g_fClustBase = Shader.PropertyToID("g_fClustBase");
+        public static readonly int g_depth_tex = Shader.PropertyToID("g_depth_tex");
+        public static readonly int g_vLayeredLightList = Shader.PropertyToID("g_vLayeredLightList");
+        public static readonly int g_LayeredOffset = Shader.PropertyToID("g_LayeredOffset");
+        public static readonly int g_vBigTileLightList = Shader.PropertyToID("g_vBigTileLightList");
+        public static readonly int g_logBaseBuffer = Shader.PropertyToID("g_logBaseBuffer");
+        public static readonly int g_vBoundsBuffer = Shader.PropertyToID("g_vBoundsBuffer");
+        public static readonly int _LightVolumeData = Shader.PropertyToID("_LightVolumeData");
+        public static readonly int g_data = Shader.PropertyToID("g_data");
+        public static readonly int g_mProjection = Shader.PropertyToID("g_mProjection");
+        public static readonly int g_mInvProjection = Shader.PropertyToID("g_mInvProjection");
+        public static readonly int g_viDimensions = Shader.PropertyToID("g_viDimensions");
+        public static readonly int g_vLightList = Shader.PropertyToID("g_vLightList");
-        internal static readonly int g_BaseFeatureFlags = Shader.PropertyToID("g_BaseFeatureFlags");
-        internal static readonly int g_TileFeatureFlags = Shader.PropertyToID("g_TileFeatureFlags");
+        public static readonly int g_BaseFeatureFlags = Shader.PropertyToID("g_BaseFeatureFlags");
+        public static readonly int g_TileFeatureFlags = Shader.PropertyToID("g_TileFeatureFlags");
-        internal static readonly int _GBufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
-        internal static readonly int _GBufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
-        internal static readonly int _GBufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
-        internal static readonly int _GBufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
+        public static readonly int _GBufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
+        public static readonly int _GBufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
+        public static readonly int _GBufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
+        public static readonly int _GBufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
-        internal static readonly int g_DispatchIndirectBuffer = Shader.PropertyToID("g_DispatchIndirectBuffer");
-        internal static readonly int g_TileList = Shader.PropertyToID("g_TileList");
-        internal static readonly int g_NumTiles = Shader.PropertyToID("g_NumTiles");
-        internal static readonly int g_NumTilesX = Shader.PropertyToID("g_NumTilesX");
+        public static readonly int g_DispatchIndirectBuffer = Shader.PropertyToID("g_DispatchIndirectBuffer");
+        public static readonly int g_TileList = Shader.PropertyToID("g_TileList");
+        public static readonly int g_NumTiles = Shader.PropertyToID("g_NumTiles");
+        public static readonly int g_NumTilesX = Shader.PropertyToID("g_NumTilesX");
-        internal static readonly int _NumTiles = Shader.PropertyToID("_NumTiles");
+        public static readonly int _NumTiles = Shader.PropertyToID("_NumTiles");
-        internal static readonly int _CookieTextures = Shader.PropertyToID("_CookieTextures");
-        internal static readonly int _CookieCubeTextures = Shader.PropertyToID("_CookieCubeTextures");
-        internal static readonly int _EnvTextures = Shader.PropertyToID("_EnvTextures");
-        internal static readonly int _DirectionalLightDatas = Shader.PropertyToID("_DirectionalLightDatas");
-        internal static readonly int _DirectionalLightCount = Shader.PropertyToID("_DirectionalLightCount");
-        internal static readonly int _LightDatas = Shader.PropertyToID("_LightDatas");
-        internal static readonly int _PunctualLightCount = Shader.PropertyToID("_PunctualLightCount");
-        internal static readonly int _AreaLightCount = Shader.PropertyToID("_AreaLightCount");
-        internal static readonly int g_vLightListGlobal = Shader.PropertyToID("g_vLightListGlobal");
-        internal static readonly int _EnvLightDatas = Shader.PropertyToID("_EnvLightDatas");
-        internal static readonly int _EnvLightCount = Shader.PropertyToID("_EnvLightCount");
-        internal static readonly int _ShadowDatas = Shader.PropertyToID("_ShadowDatas");
-        internal static readonly int _DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
-        internal static readonly int _NumTileFtplX = Shader.PropertyToID("_NumTileFtplX");
-        internal static readonly int _NumTileFtplY = Shader.PropertyToID("_NumTileFtplY");
-        internal static readonly int _NumTileClusteredX = Shader.PropertyToID("_NumTileClusteredX");
-        internal static readonly int _NumTileClusteredY = Shader.PropertyToID("_NumTileClusteredY");
+        public static readonly int _CookieTextures = Shader.PropertyToID("_CookieTextures");
+        public static readonly int _CookieCubeTextures = Shader.PropertyToID("_CookieCubeTextures");
+        public static readonly int _EnvTextures = Shader.PropertyToID("_EnvTextures");
+        public static readonly int _DirectionalLightDatas = Shader.PropertyToID("_DirectionalLightDatas");
+        public static readonly int _DirectionalLightCount = Shader.PropertyToID("_DirectionalLightCount");
+        public static readonly int _LightDatas = Shader.PropertyToID("_LightDatas");
+        public static readonly int _PunctualLightCount = Shader.PropertyToID("_PunctualLightCount");
+        public static readonly int _AreaLightCount = Shader.PropertyToID("_AreaLightCount");
+        public static readonly int g_vLightListGlobal = Shader.PropertyToID("g_vLightListGlobal");
+        public static readonly int _EnvLightDatas = Shader.PropertyToID("_EnvLightDatas");
+        public static readonly int _EnvLightCount = Shader.PropertyToID("_EnvLightCount");
+        public static readonly int _ShadowDatas = Shader.PropertyToID("_ShadowDatas");
+        public static readonly int _DirShadowSplitSpheres = Shader.PropertyToID("_DirShadowSplitSpheres");
+        public static readonly int _NumTileFtplX = Shader.PropertyToID("_NumTileFtplX");
+        public static readonly int _NumTileFtplY = Shader.PropertyToID("_NumTileFtplY");
+        public static readonly int _NumTileClusteredX = Shader.PropertyToID("_NumTileClusteredX");
+        public static readonly int _NumTileClusteredY = Shader.PropertyToID("_NumTileClusteredY");
-        internal static readonly int g_isLogBaseBufferEnabled = Shader.PropertyToID("g_isLogBaseBufferEnabled");
-        internal static readonly int g_vLayeredOffsetsBuffer = Shader.PropertyToID("g_vLayeredOffsetsBuffer");
+        public static readonly int g_isLogBaseBufferEnabled = Shader.PropertyToID("g_isLogBaseBufferEnabled");
+        public static readonly int g_vLayeredOffsetsBuffer = Shader.PropertyToID("g_vLayeredOffsetsBuffer");
-        internal static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
-        internal static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
+        public static readonly int _ViewTilesFlags = Shader.PropertyToID("_ViewTilesFlags");
+        public static readonly int _MousePixelCoord = Shader.PropertyToID("_MousePixelCoord");
-        internal static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
-        internal static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
-        internal static readonly int _DebugLightingAlbedo = Shader.PropertyToID("_DebugLightingAlbedo");
-        internal static readonly int _DebugLightingSmoothness = Shader.PropertyToID("_DebugLightingSmoothness");
-        internal static readonly int _AmbientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
+        public static readonly int _DebugViewMaterial = Shader.PropertyToID("_DebugViewMaterial");
+        public static readonly int _DebugLightingMode = Shader.PropertyToID("_DebugLightingMode");
+        public static readonly int _DebugLightingAlbedo = Shader.PropertyToID("_DebugLightingAlbedo");
+        public static readonly int _DebugLightingSmoothness = Shader.PropertyToID("_DebugLightingSmoothness");
+        public static readonly int _AmbientOcclusionTexture = Shader.PropertyToID("_AmbientOcclusionTexture");
-        internal static readonly int _UseTileLightList = Shader.PropertyToID("_UseTileLightList");
-        internal static readonly int _Time = Shader.PropertyToID("_Time");
-        internal static readonly int _SinTime = Shader.PropertyToID("_SinTime");
-        internal static readonly int _CosTime = Shader.PropertyToID("_CosTime");
-        internal static readonly int unity_DeltaTime = Shader.PropertyToID("unity_DeltaTime");
-        internal static readonly int _EnvLightSkyEnabled = Shader.PropertyToID("_EnvLightSkyEnabled");
-        internal static readonly int _AmbientOcclusionDirectLightStrenght = Shader.PropertyToID("_AmbientOcclusionDirectLightStrenght");
-        internal static readonly int _SkyTexture = Shader.PropertyToID("_SkyTexture");
+        public static readonly int _UseTileLightList = Shader.PropertyToID("_UseTileLightList");
+        public static readonly int _Time = Shader.PropertyToID("_Time");
+        public static readonly int _SinTime = Shader.PropertyToID("_SinTime");
+        public static readonly int _CosTime = Shader.PropertyToID("_CosTime");
+        public static readonly int unity_DeltaTime = Shader.PropertyToID("unity_DeltaTime");
+        public static readonly int _EnvLightSkyEnabled = Shader.PropertyToID("_EnvLightSkyEnabled");
+        public static readonly int _AmbientOcclusionDirectLightStrenght = Shader.PropertyToID("_AmbientOcclusionDirectLightStrenght");
+        public static readonly int _SkyTexture = Shader.PropertyToID("_SkyTexture");
-        internal static readonly int _UseDisneySSS = Shader.PropertyToID("_UseDisneySSS");
-        internal static readonly int _EnableSSSAndTransmission = Shader.PropertyToID("_EnableSSSAndTransmission");
-        internal static readonly int _TexturingModeFlags = Shader.PropertyToID("_TexturingModeFlags");
-        internal static readonly int _TransmissionFlags = Shader.PropertyToID("_TransmissionFlags");
-        internal static readonly int _ThicknessRemaps = Shader.PropertyToID("_ThicknessRemaps");
-        internal static readonly int _ShapeParams = Shader.PropertyToID("_ShapeParams");
-        internal static readonly int _HalfRcpVariancesAndWeights = Shader.PropertyToID("_HalfRcpVariancesAndWeights");
-        internal static readonly int _TransmissionTints = Shader.PropertyToID("_TransmissionTints");
-        internal static readonly int specularLightingUAV = Shader.PropertyToID("specularLightingUAV");
-        internal static readonly int diffuseLightingUAV = Shader.PropertyToID("diffuseLightingUAV");
+        public static readonly int _UseDisneySSS = Shader.PropertyToID("_UseDisneySSS");
+        public static readonly int _EnableSSSAndTransmission = Shader.PropertyToID("_EnableSSSAndTransmission");
+        public static readonly int _TexturingModeFlags = Shader.PropertyToID("_TexturingModeFlags");
+        public static readonly int _TransmissionFlags = Shader.PropertyToID("_TransmissionFlags");
+        public static readonly int _ThicknessRemaps = Shader.PropertyToID("_ThicknessRemaps");
+        public static readonly int _ShapeParams = Shader.PropertyToID("_ShapeParams");
+        public static readonly int _HalfRcpVariancesAndWeights = Shader.PropertyToID("_HalfRcpVariancesAndWeights");
+        public static readonly int _TransmissionTints = Shader.PropertyToID("_TransmissionTints");
+        public static readonly int specularLightingUAV = Shader.PropertyToID("specularLightingUAV");
+        public static readonly int diffuseLightingUAV = Shader.PropertyToID("diffuseLightingUAV");
-        internal static readonly int g_TileListOffset = Shader.PropertyToID("g_TileListOffset");
+        public static readonly int g_TileListOffset = Shader.PropertyToID("g_TileListOffset");
-        internal static readonly int _LtcData = Shader.PropertyToID("_LtcData");
-        internal static readonly int _PreIntegratedFGD = Shader.PropertyToID("_PreIntegratedFGD");
-        internal static readonly int _LtcGGXMatrix = Shader.PropertyToID("_LtcGGXMatrix");
-        internal static readonly int _LtcDisneyDiffuseMatrix = Shader.PropertyToID("_LtcDisneyDiffuseMatrix");
-        internal static readonly int _LtcMultiGGXFresnelDisneyDiffuse = Shader.PropertyToID("_LtcMultiGGXFresnelDisneyDiffuse");
+        public static readonly int _LtcData = Shader.PropertyToID("_LtcData");
+        public static readonly int _PreIntegratedFGD = Shader.PropertyToID("_PreIntegratedFGD");
+        public static readonly int _LtcGGXMatrix = Shader.PropertyToID("_LtcGGXMatrix");
+        public static readonly int _LtcDisneyDiffuseMatrix = Shader.PropertyToID("_LtcDisneyDiffuseMatrix");
+        public static readonly int _LtcMultiGGXFresnelDisneyDiffuse = Shader.PropertyToID("_LtcMultiGGXFresnelDisneyDiffuse");
-        internal static readonly int _MainDepthTexture = Shader.PropertyToID("_MainDepthTexture");
+        public static readonly int _MainDepthTexture = Shader.PropertyToID("_MainDepthTexture");
-        internal static readonly int _DeferredShadowTexture = Shader.PropertyToID("_DeferredShadowTexture");
-        internal static readonly int _DeferredShadowTextureUAV = Shader.PropertyToID("_DeferredShadowTextureUAV");
-        internal static readonly int _DirectionalShadowIndex = Shader.PropertyToID("_DirectionalShadowIndex");
+        public static readonly int _DeferredShadowTexture = Shader.PropertyToID("_DeferredShadowTexture");
+        public static readonly int _DeferredShadowTextureUAV = Shader.PropertyToID("_DeferredShadowTextureUAV");
+        public static readonly int _DirectionalShadowIndex = Shader.PropertyToID("_DirectionalShadowIndex");
-        internal static readonly int unity_OrthoParams = Shader.PropertyToID("unity_OrthoParams");
-        internal static readonly int _ZBufferParams = Shader.PropertyToID("_ZBufferParams");
-        internal static readonly int _ScreenParams = Shader.PropertyToID("_ScreenParams");
-        internal static readonly int _ProjectionParams = Shader.PropertyToID("_ProjectionParams");
-        internal static readonly int _WorldSpaceCameraPos = Shader.PropertyToID("_WorldSpaceCameraPos");
+        public static readonly int unity_OrthoParams = Shader.PropertyToID("unity_OrthoParams");
+        public static readonly int _ZBufferParams = Shader.PropertyToID("_ZBufferParams");
+        public static readonly int _ScreenParams = Shader.PropertyToID("_ScreenParams");
+        public static readonly int _ProjectionParams = Shader.PropertyToID("_ProjectionParams");
+        public static readonly int _WorldSpaceCameraPos = Shader.PropertyToID("_WorldSpaceCameraPos");
+        public static readonly int _StencilRef = Shader.PropertyToID("_StencilRef");
+        public static readonly int _StencilCmp = Shader.PropertyToID("_StencilCmp");
-        internal static readonly int _StencilRef = Shader.PropertyToID("_StencilRef");
-        internal static readonly int _StencilCmp = Shader.PropertyToID("_StencilCmp");
+        public static readonly int _SrcBlend = Shader.PropertyToID("_SrcBlend");
+        public static readonly int _DstBlend = Shader.PropertyToID("_DstBlend");
-        internal static readonly int _SrcBlend = Shader.PropertyToID("_SrcBlend");
-        internal static readonly int _DstBlend = Shader.PropertyToID("_DstBlend");
+        public static readonly int _HTile = Shader.PropertyToID("_HTile");
+        public static readonly int _StencilTexture = Shader.PropertyToID("_StencilTexture");
-        internal static readonly int _HTile = Shader.PropertyToID("_HTile");
-        internal static readonly int _StencilTexture = Shader.PropertyToID("_StencilTexture");
+        public static readonly int _ViewMatrix = Shader.PropertyToID("_ViewMatrix");
+        public static readonly int _InvViewMatrix = Shader.PropertyToID("_InvViewMatrix");
+        public static readonly int _ProjMatrix = Shader.PropertyToID("_ProjMatrix");
+        public static readonly int _InvProjMatrix = Shader.PropertyToID("_InvProjMatrix");
+        public static readonly int _NonJitteredViewProjMatrix = Shader.PropertyToID("_NonJitteredViewProjMatrix");
+        public static readonly int _ViewProjMatrix = Shader.PropertyToID("_ViewProjMatrix");
+        public static readonly int _InvViewProjMatrix = Shader.PropertyToID("_InvViewProjMatrix");
+        public static readonly int _InvProjParam = Shader.PropertyToID("_InvProjParam");
+        public static readonly int _ScreenSize = Shader.PropertyToID("_ScreenSize");
+        public static readonly int _PrevViewProjMatrix = Shader.PropertyToID("_PrevViewProjMatrix");
+        public static readonly int _FrustumPlanes = Shader.PropertyToID("_FrustumPlanes");
-        internal static readonly int _ViewMatrix = Shader.PropertyToID("_ViewMatrix");
-        internal static readonly int _InvViewMatrix = Shader.PropertyToID("_InvViewMatrix");
-        internal static readonly int _ProjMatrix = Shader.PropertyToID("_ProjMatrix");
-        internal static readonly int _InvProjMatrix = Shader.PropertyToID("_InvProjMatrix");
-        internal static readonly int _NonJitteredViewProjMatrix = Shader.PropertyToID("_NonJitteredViewProjMatrix");
-        internal static readonly int _ViewProjMatrix = Shader.PropertyToID("_ViewProjMatrix");
-        internal static readonly int _InvViewProjMatrix = Shader.PropertyToID("_InvViewProjMatrix");
-        internal static readonly int _InvProjParam = Shader.PropertyToID("_InvProjParam");
-        internal static readonly int _ScreenSize = Shader.PropertyToID("_ScreenSize");
-        internal static readonly int _PrevViewProjMatrix = Shader.PropertyToID("_PrevViewProjMatrix");
-        internal static readonly int _FrustumPlanes = Shader.PropertyToID("_FrustumPlanes");
+        public static readonly int _DepthTexture                   = Shader.PropertyToID("_DepthTexture");
+        public static readonly int _CameraColorTexture             = Shader.PropertyToID("_CameraColorTexture");
+        public static readonly int _CameraSssDiffuseLightingBuffer = Shader.PropertyToID("_CameraSssDiffuseLightingTexture");
+        public static readonly int _CameraFilteringBuffer          = Shader.PropertyToID("_CameraFilteringTexture");
+        public static readonly int _IrradianceSource               = Shader.PropertyToID("_IrradianceSource");
-        internal static readonly int _DepthTexture                   = Shader.PropertyToID("_DepthTexture");
-        internal static readonly int _CameraColorTexture             = Shader.PropertyToID("_CameraColorTexture");
-        internal static readonly int _CameraSssDiffuseLightingBuffer = Shader.PropertyToID("_CameraSssDiffuseLightingTexture");
-        internal static readonly int _CameraFilteringBuffer          = Shader.PropertyToID("_CameraFilteringTexture");
-        internal static readonly int _IrradianceSource               = Shader.PropertyToID("_IrradianceSource");
-
-        internal static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");
-        internal static readonly int _DistortionTexture = Shader.PropertyToID("_DistortionTexture");
-        internal static readonly int _GaussianPyramidColorTexture = Shader.PropertyToID("_GaussianPyramidColorTexture");
-        internal static readonly int _DepthPyramidTexture = Shader.PropertyToID("_PyramidDepthTexture");
-        internal static readonly int _GaussianPyramidColorMipSize = Shader.PropertyToID("_GaussianPyramidColorMipSize");
-        internal static readonly int[] _GaussianPyramidColorMips =
+        public static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");
+        public static readonly int _DistortionTexture = Shader.PropertyToID("_DistortionTexture");
+        public static readonly int _GaussianPyramidColorTexture = Shader.PropertyToID("_GaussianPyramidColorTexture");
+        public static readonly int _DepthPyramidTexture = Shader.PropertyToID("_PyramidDepthTexture");
+        public static readonly int _GaussianPyramidColorMipSize = Shader.PropertyToID("_GaussianPyramidColorMipSize");
+        public static readonly int[] _GaussianPyramidColorMips =
         {
             Shader.PropertyToID("_GaussianColorMip0"),
             Shader.PropertyToID("_GaussianColorMip1"),
             Shader.PropertyToID("_GaussianColorMip13"),
             Shader.PropertyToID("_GaussianColorMip14"),
         };
-        internal static readonly int _DepthPyramidMipSize = Shader.PropertyToID("_PyramidDepthMipSize");
-        internal static readonly int[] _DepthPyramidMips =
+        public static readonly int _DepthPyramidMipSize = Shader.PropertyToID("_PyramidDepthMipSize");
+        public static readonly int[] _DepthPyramidMips =
         {
             Shader.PropertyToID("_DepthPyramidMip0"),
             Shader.PropertyToID("_DepthPyramidMip1"),
             Shader.PropertyToID("_DepthPyramidMip13"),
             Shader.PropertyToID("_DepthPyramidMip14"),
         };
-        internal static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
+        public static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
-        internal static readonly int _WorldScales = Shader.PropertyToID("_WorldScales");
-        internal static readonly int _FilterKernels = Shader.PropertyToID("_FilterKernels");
-        internal static readonly int _FilterKernelsBasic = Shader.PropertyToID("_FilterKernelsBasic");
-        internal static readonly int _HalfRcpWeightedVariances = Shader.PropertyToID("_HalfRcpWeightedVariances");
+        public static readonly int _WorldScales = Shader.PropertyToID("_WorldScales");
+        public static readonly int _FilterKernels = Shader.PropertyToID("_FilterKernels");
+        public static readonly int _FilterKernelsBasic = Shader.PropertyToID("_FilterKernelsBasic");
+        public static readonly int _HalfRcpWeightedVariances = Shader.PropertyToID("_HalfRcpWeightedVariances");
-        internal static readonly int _CameraPosDiff = Shader.PropertyToID("_CameraPosDiff");
+        public static readonly int _CameraPosDiff = Shader.PropertyToID("_CameraPosDiff");
-        internal static readonly int _CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
-        internal static readonly int _CameraMotionVectorsTexture = Shader.PropertyToID("_CameraMotionVectorsTexture");
-        internal static readonly int _FullScreenDebugMode = Shader.PropertyToID("_FullScreenDebugMode");
+        public static readonly int _CameraDepthTexture = Shader.PropertyToID("_CameraDepthTexture");
+        public static readonly int _CameraMotionVectorsTexture = Shader.PropertyToID("_CameraMotionVectorsTexture");
+        public static readonly int _FullScreenDebugMode = Shader.PropertyToID("_FullScreenDebugMode");
-        internal static readonly int _InputCubemap = Shader.PropertyToID("_InputCubemap");
-        internal static readonly int _Mipmap = Shader.PropertyToID("_Mipmap");
+        public static readonly int _InputCubemap = Shader.PropertyToID("_InputCubemap");
+        public static readonly int _Mipmap = Shader.PropertyToID("_Mipmap");
+        public static readonly int _MaxRadius = Shader.PropertyToID("_MaxRadius");
+        public static readonly int _ShapeParam = Shader.PropertyToID("_ShapeParam");
+        public static readonly int _StdDev1 = Shader.PropertyToID("_StdDev1");
+        public static readonly int _StdDev2 = Shader.PropertyToID("_StdDev2");
+        public static readonly int _LerpWeight = Shader.PropertyToID("_LerpWeight");
+        public static readonly int _HalfRcpVarianceAndWeight1 = Shader.PropertyToID("_HalfRcpVarianceAndWeight1");
+        public static readonly int _HalfRcpVarianceAndWeight2 = Shader.PropertyToID("_HalfRcpVarianceAndWeight2");
+        public static readonly int _TransmissionTint = Shader.PropertyToID("_TransmissionTint");
+        public static readonly int _ThicknessRemap = Shader.PropertyToID("_ThicknessRemap");
-        internal static readonly int _MaxRadius = Shader.PropertyToID("_MaxRadius");
-        internal static readonly int _ShapeParam = Shader.PropertyToID("_ShapeParam");
-        internal static readonly int _StdDev1 = Shader.PropertyToID("_StdDev1");
-        internal static readonly int _StdDev2 = Shader.PropertyToID("_StdDev2");
-        internal static readonly int _LerpWeight = Shader.PropertyToID("_LerpWeight");
-        internal static readonly int _HalfRcpVarianceAndWeight1 = Shader.PropertyToID("_HalfRcpVarianceAndWeight1");
-        internal static readonly int _HalfRcpVarianceAndWeight2 = Shader.PropertyToID("_HalfRcpVarianceAndWeight2");
-        internal static readonly int _TransmissionTint = Shader.PropertyToID("_TransmissionTint");
-        internal static readonly int _ThicknessRemap = Shader.PropertyToID("_ThicknessRemap");
+        public static readonly int _Cubemap = Shader.PropertyToID("_Cubemap");
+        public static readonly int _SkyParam = Shader.PropertyToID("_SkyParam");
+        public static readonly int _PixelCoordToViewDirWS = Shader.PropertyToID("_PixelCoordToViewDirWS");
-        internal static readonly int _Cubemap = Shader.PropertyToID("_Cubemap");
-        internal static readonly int _SkyParam = Shader.PropertyToID("_SkyParam");
-        internal static readonly int _PixelCoordToViewDirWS = Shader.PropertyToID("_PixelCoordToViewDirWS");
-
-        internal static readonly int _GlobalFog_Extinction = Shader.PropertyToID("_GlobalFog_Extinction");
-        internal static readonly int _GlobalFog_Asymmetry  = Shader.PropertyToID("_GlobalFog_Asymmetry");
-        internal static readonly int _GlobalFog_Scattering = Shader.PropertyToID("_GlobalFog_Scattering");
+        public static readonly int _GlobalFog_Extinction = Shader.PropertyToID("_GlobalFog_Extinction");
+        public static readonly int _GlobalFog_Asymmetry  = Shader.PropertyToID("_GlobalFog_Asymmetry");
+        public static readonly int _GlobalFog_Scattering = Shader.PropertyToID("_GlobalFog_Scattering");
-        internal static readonly int _Size = Shader.PropertyToID("_Size");
-        internal static readonly int _Source4 = Shader.PropertyToID("_Source4");
-        internal static readonly int _Result1 = Shader.PropertyToID("_Result1");
+        public static readonly int _Size = Shader.PropertyToID("_Size");
+        public static readonly int _Source4 = Shader.PropertyToID("_Source4");
+        public static readonly int _Result1 = Shader.PropertyToID("_Result1");
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDUtils.cs

-#if UNITY_EDITOR
-using System.IO;
-using UnityEditor;
-using UnityEngine.Rendering;
-
-#endif
+using UnityEngine.Rendering;
-#if UNITY_EDITOR
-        public static string GetHDRenderPipelinePath()
-        {
-            // User can create their own directory for SRP, so we need to find the current path that they use.
-            // We know that DefaultHDMaterial exist and we know where it is, let's use that to find the current directory.
-            var guid = AssetDatabase.FindAssets("DefaultHDMaterial t:material");
-            string path = AssetDatabase.GUIDToAssetPath(guid[0]);
-            path = Path.GetDirectoryName(path); // Asset is in HDRenderPipeline/RenderPipelineResources/DefaultHDMaterial.mat
-            path = path.Replace("RenderPipelineResources", ""); // Keep only path with HDRenderPipeline
-
-            return path;
-        }
-
-        public static string GetPostProcessingPath()
-        {
-            var hdrpPath = GetHDRenderPipelinePath();
-            var fullPath = Path.GetFullPath(hdrpPath + "../../PostProcessing/PostProcessing");
-            var relativePath = fullPath.Substring(fullPath.IndexOf("Assets"));
-            return relativePath.Replace("\\", "/") + "/";
-        }
-
-        public static string GetCorePath()
-        {
-            var hdrpPath = GetHDRenderPipelinePath();
-            var fullPath = Path.GetFullPath(hdrpPath + "../Core");
-            var relativePath = fullPath.Substring(fullPath.IndexOf("Assets"));
-            return relativePath.Replace("\\", "/") + "/";
-        }
-#endif
-
         public const RendererConfiguration k_RendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
 
         public static Matrix4x4 GetViewProjectionMatrix(Matrix4x4 worldToViewMatrix, Matrix4x4 projectionMatrix)

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Editor/HDLightEditor.Styles.cs

 using System;
 using System.Linq;
+using UnityEngine;
-namespace UnityEngine.Experimental.Rendering.HDPipeline
+namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
     // TODO: Missing UI tooltips
     partial class HDLightEditor

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Editor/HDLightEditor.cs

 using System;
 using System.Linq;
-using UnityEditor;
-using UnityEditor.Experimental.Rendering;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
-namespace UnityEngine.Experimental.Rendering.HDPipeline
+namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
     // TODO: Simplify this editor once we can target 2018.1
     [CanEditMultipleObjects]
         bool m_IsRealtime { get { return m_BaseData.lightmapping.intValue == 4; } }
         Light light { get { return serializedObject.targetObject as Light; } }
         Texture m_Cookie { get { return m_BaseData.cookie.objectReferenceValue as Texture; } }
-        bool m_BakingWarningValue { get { return !Lightmapping.bakedGI && m_LightmappingTypeIsSame && !m_IsRealtime; } }
+        bool m_BakingWarningValue { get { return !UnityEditor.Lightmapping.bakedGI && m_LightmappingTypeIsSame && !m_IsRealtime; } }
         bool m_BounceWarningValue
         {
             get
             if (m_BaseData.shadowsType.enumValueIndex != (int)LightShadows.None)
                 DrawFoldout(m_BaseData.shadowsType, "Shadows", DrawShadows);
 
-            EditorLightUtilities.DrawSplitter();
+            CoreEditorUtils.DrawSplitter();
             EditorGUILayout.Space();
 
             m_SerializedAdditionalShadowData.ApplyModifiedProperties();
 
         void DrawFoldout(SerializedProperty foldoutProperty, string title, Action func)
         {
-            EditorLightUtilities.DrawSplitter();
+            CoreEditorUtils.DrawSplitter();
-            state = EditorLightUtilities.DrawHeaderFoldout(title, state);
+            state = CoreEditorUtils.DrawHeaderFoldout(title, state);
 
             if (state)
             {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/EditorLightUtilities.cs

-using System.Collections;
-using System.Collections.Generic;
-using UnityEngine;
-using UnityEngine.Rendering;
-using Object = UnityEngine.Object;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
             Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * -gizmoSize / m_transform.localScale.y));
             Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * gizmoSize / m_transform.localScale.x));
             Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * -gizmoSize / m_transform.localScale.x));
-        }
-
-        public static bool DrawHeader(string title, bool activeField)
-        {
-            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
-
-            var labelRect = backgroundRect;
-            labelRect.xMin += 16f;
-            labelRect.xMax -= 20f;
-
-            var toggleRect = backgroundRect;
-            toggleRect.y += 2f;
-            toggleRect.width = 13f;
-            toggleRect.height = 13f;
-
-            var menuIcon = EditorGUIUtility.isProSkin
-                ? (Texture2D)EditorGUIUtility.Load("Builtin Skins/DarkSkin/Images/pane options.png")
-                : (Texture2D)EditorGUIUtility.Load("Builtin Skins/LightSkin/Images/pane options.png");
-
-            var menuRect = new Rect(labelRect.xMax + 4f, labelRect.y + 4f, menuIcon.width, menuIcon.height);
-
-            // Background rect should be full-width
-            backgroundRect.xMin = 0f;
-            backgroundRect.width += 4f;
-
-            // Background
-            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
-            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
-
-            // Title
-            using (new EditorGUI.DisabledScope(!activeField))
-                EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
-
-            // Active checkbox
-            activeField = GUI.Toggle(toggleRect, activeField, GUIContent.none, new GUIStyle("ShurikenCheckMark"));
-
-            var e = Event.current;
-            if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
-            {
-                activeField = !activeField;
-                e.Use();
-            }
-
-            EditorGUILayout.Space();
-
-            return activeField;
-        }
-
-        public static void DrawHeader(string title)
-        {
-            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
-
-            var labelRect = backgroundRect;
-            labelRect.xMin += 16f;
-            labelRect.xMax -= 20f;
-
-            var foldoutRect = backgroundRect;
-            foldoutRect.y += 1f;
-            foldoutRect.width = 13f;
-            foldoutRect.height = 13f;
-
-            // Background rect should be full-width
-            backgroundRect.xMin = 0f;
-            backgroundRect.width += 4f;
-
-            // Background
-            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
-            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
-
-            // Title
-            EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
-            EditorGUILayout.Space();
-        }
-
-        public static void DrawSplitter()
-        {
-            var rect = GUILayoutUtility.GetRect(1f, 1f);
-
-            // Splitter rect should be full-width
-            rect.xMin = 0f;
-            rect.width += 4f;
-
-            if (Event.current.type != EventType.Repaint)
-                return;
-
-            EditorGUI.DrawRect(rect, !EditorGUIUtility.isProSkin
-                ? new Color(0.6f, 0.6f, 0.6f, 1.333f)
-                : new Color(0.12f, 0.12f, 0.12f, 1.333f));
-        }
-
-        public static bool DrawHeaderFoldout(string title, bool state)
-        {
-            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
-
-            var labelRect = backgroundRect;
-            labelRect.xMin += 16f;
-            labelRect.xMax -= 20f;
-
-            var foldoutRect = backgroundRect;
-            foldoutRect.y += 1f;
-            foldoutRect.width = 13f;
-            foldoutRect.height = 13f;
-
-            // Background rect should be full-width
-            backgroundRect.xMin = 0f;
-            backgroundRect.width += 4f;
-
-            // Background
-            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
-            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
-
-            // Title
-            EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
-
-            // Active checkbox
-            state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
-
-            var e = Event.current;
-            if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
-            {
-                state = !state;
-                e.Use();
-            }
-
-            return state;
         }
     }
 #endif

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/HomogeneousFog.cs

-using System;
-
-#if UNITY_EDITOR
-    using UnityEditor;
-#endif
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     [ExecuteInEditMode]

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Volumetrics/VolumetricLighting.cs

 using System;
 using UnityEngine.Rendering;
 
-#if UNITY_EDITOR
-    using UnityEditor;
-#endif
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Builtin/BuiltinData.cs

-using UnityEngine;
-
 //-----------------------------------------------------------------------------
 // structure definition
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Material/LayeredLit/Editor/LayeredLitUI.cs

 using System;
 using UnityEngine;
-using UnityEngine.Rendering;
 
 using System.Linq;
 
 
         private class StylesLayer
         {
-            public readonly Color[] layerColors = 
+            public readonly Color[] layerColors =
             {
                 Color.white,
                 Color.red,

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/BaseLitUI.cs

 using System;
 using UnityEngine;
-using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
             public static GUIContent ppdMinSamplesText = new GUIContent("Minimum steps", "Minimum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdMaxSamplesText = new GUIContent("Maximum steps", "Maximum steps (texture sample) to use with per pixel displacement mapping");
             public static GUIContent ppdLodThresholdText = new GUIContent("Fading mip level start", "Starting heightmap mipmap lod number where the parallax occlusion mapping effect start to disappear");
-            public static GUIContent perPixelDisplacementObjectScaleText = new GUIContent("Lock with object scale", "Per Pixel displacement will take into account the tiling scale - Only work with uniform positive scale");            
+            public static GUIContent perPixelDisplacementObjectScaleText = new GUIContent("Lock with object scale", "Per Pixel displacement will take into account the tiling scale - Only work with uniform positive scale");
 
             // Vertex displacement
             public static string vertexDisplacementText = "Vertex displacement";
             ppdMinSamples = FindProperty(kPpdMinSamples, props);
             ppdMaxSamples = FindProperty(kPpdMaxSamples, props);
             ppdLodThreshold = FindProperty(kPpdLodThreshold, props);
-            perPixelDisplacementObjectScale = FindProperty(kPerPixelDisplacementObjectScale, props);            
+            perPixelDisplacementObjectScale = FindProperty(kPerPixelDisplacementObjectScale, props);
 
             // vertex displacement
             enableVertexDisplacement = FindProperty(kEnableVertexDisplacement, props);
                 ppdMinSamples.floatValue = Mathf.Min(ppdMinSamples.floatValue, ppdMaxSamples.floatValue);
                 m_MaterialEditor.ShaderProperty(ppdLodThreshold, StylesBaseLit.ppdLodThresholdText);
                 //m_MaterialEditor.ShaderProperty(perPixelDisplacementObjectScale, StylesBaseLit.perPixelDisplacementObjectScaleText);
-                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);                
+                m_MaterialEditor.ShaderProperty(depthOffsetEnable, StylesBaseLit.depthOffsetEnableText);
                 EditorGUI.indentLevel--;
             }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/LitUI.cs

 using System;
 using UnityEngine;
-using UnityEngine.Rendering;
 using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LtcData.DisneyDiffuse.cs

 using UnityEngine;
-using UnityEngine.Rendering;
 using System;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LtcData.GGX.cs

 using UnityEngine;
-using UnityEngine.Rendering;
 using System;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

 using System;
-#if UNITY_EDITOR
-    using UnityEditor;
-#endif
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
             BuildKernel();
         }
 
+        public void Validate()
+        {
+            thicknessRemap.y = Mathf.Max(thicknessRemap.y, 0f);
+            thicknessRemap.x = Mathf.Clamp(thicknessRemap.x, 0f, thicknessRemap.y);
+            worldScale       = Mathf.Max(worldScale, 0.001f);
+
+            // Old SSS Model >>>
+            var c = new Color();
+            c.r = Mathf.Max(0.05f, scatterDistance1.r);
+            c.g = Mathf.Max(0.05f, scatterDistance1.g);
+            c.b = Mathf.Max(0.05f, scatterDistance1.b);
+            c.a = 0.0f;
+
+            scatterDistance1 = c;
+
+            c.r = Mathf.Max(0.05f, scatterDistance2.r);
+            c.g = Mathf.Max(0.05f, scatterDistance2.g);
+            c.b = Mathf.Max(0.05f, scatterDistance2.b);
+            c.a = 0.0f;
+
+            scatterDistance2 = c;
+            // <<< Old SSS Model
+
+            BuildKernel();
+        }
+
         // Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar.
         public void BuildKernel()
         {
             }
 
             // Clamp to avoid artifacts.
-            m_ShapeParam   = new Vector3();
             m_ShapeParam.x = 1.0f / Mathf.Max(0.001f, scatteringDistance.r);
             m_ShapeParam.y = 1.0f / Mathf.Max(0.001f, scatteringDistance.g);
             m_ShapeParam.z = 1.0f / Mathf.Max(0.001f, scatteringDistance.b);
                 }
             }
 
-            for (int i = 0; i < numProfiles; i++)
+            foreach (var profile in profiles)
-                // Skip unassigned profiles.
-                if (profiles[i] == null) continue;
-
-                profiles[i].thicknessRemap.y = Mathf.Max(profiles[i].thicknessRemap.y, 0);
-                profiles[i].thicknessRemap.x = Mathf.Clamp(profiles[i].thicknessRemap.x, 0, profiles[i].thicknessRemap.y);
-                profiles[i].worldScale       = Mathf.Max(profiles[i].worldScale, 0.001f);
-
-                // Old SSS Model >>>
-                Color c = new Color();
-
-                c.r = Mathf.Max(0.05f, profiles[i].scatterDistance1.r);
-                c.g = Mathf.Max(0.05f, profiles[i].scatterDistance1.g);
-                c.b = Mathf.Max(0.05f, profiles[i].scatterDistance1.b);
-                c.a = 0.0f;
-
-                profiles[i].scatterDistance1 = c;
-
-                c.r = Mathf.Max(0.05f, profiles[i].scatterDistance2.r);
-                c.g = Mathf.Max(0.05f, profiles[i].scatterDistance2.g);
-                c.b = Mathf.Max(0.05f, profiles[i].scatterDistance2.b);
-                c.a = 0.0f;
-
-                profiles[i].scatterDistance2 = c;
-                // <<< Old SSS Model
-
-                profiles[i].BuildKernel();
+                if (profile != null)
+                    profile.Validate();
             }
 
             UpdateCache();
             // UpdateCache();
         }
     }
-
-#if UNITY_EDITOR
-
-    [CustomEditor(typeof(SubsurfaceScatteringProfile))]
-    public class SubsurfaceScatteringProfileEditor : Editor
-    {
-        private class Styles
-        {
-            public readonly GUIContent   sssProfilePreview0           = new GUIContent("Profile Preview");
-            public readonly GUIContent   sssProfilePreview1           = new GUIContent("Shows the fraction of light scattered from the source (center).");
-            public readonly GUIContent   sssProfilePreview2           = new GUIContent("The distance to the boundary of the image corresponds to the Max Radius.");
-            public readonly GUIContent   sssProfilePreview3           = new GUIContent("Note that the intensity of pixels around the center may be clipped.");
-            public readonly GUIContent   sssTransmittancePreview0     = new GUIContent("Transmittance Preview");
-            public readonly GUIContent   sssTransmittancePreview1     = new GUIContent("Shows the fraction of light passing through the object for thickness values from the remap.");
-            public readonly GUIContent   sssTransmittancePreview2     = new GUIContent("Can be viewed as a cross section of a slab of material illuminated by white light from the left.");
-            public readonly GUIContent   sssProfileScatteringDistance = new GUIContent("Scattering Distance", "Determines the shape of the profile, and the blur radius of the filter per color channel. Alpha is ignored.");
-            public readonly GUIContent   sssProfileTransmissionTint   = new GUIContent("Transmission tint", "Color which tints transmitted light. Alpha is ignored.");
-            public readonly GUIContent   sssProfileMaxRadius          = new GUIContent("Max Radius", "Effective radius of the filter (in millimeters). The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Reducing the distance increases the sharpness of the result.");
-            public readonly GUIContent   sssTexturingMode             = new GUIContent("Texturing Mode", "Specifies when the diffuse texture should be applied.");
-            public readonly GUIContent[] sssTexturingModeOptions      = new GUIContent[2]
-            {
-                new GUIContent("Pre- and post-scatter", "Texturing is performed during both the lighting and the SSS passes. Slightly blurs the diffuse texture. Choose this mode if your diffuse texture contains little to no SSS lighting."),
-                new GUIContent("Post-scatter",          "Texturing is performed only during the SSS pass. Effectively preserves the sharpness of the diffuse texture. Choose this mode if your diffuse texture already contains SSS lighting (e.g. a photo of skin).")
-            };
-            public readonly GUIContent   sssProfileTransmissionMode = new GUIContent("Transmission Mode", "Configures the simulation of light passing through thin objects. Depends on the thickness value (which is applied in the normal direction).");
-            public readonly GUIContent[] sssTransmissionModeOptions = new GUIContent[3]
-            {
-                new GUIContent("None",         "Disables transmission. Choose this mode for completely opaque, or very thick translucent objects."),
-                new GUIContent("Thin Object",  "Choose this mode for thin objects, such as paper or leaves. Transmitted light reuses the shadowing state of the surface."),
-                new GUIContent("Regular",      "Choose this mode for moderately thick objects. For performance reasons, transmitted light ignores occlusion (shadows).")
-            };
-            public readonly GUIContent   sssProfileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below (in millimeters).");
-            public readonly GUIContent   sssProfileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range (in millimeters).");
-            public readonly GUIContent   sssProfileWorldScale      = new GUIContent("World Scale", "Size of the world unit in meters.");
-            // Old SSS Model >>>
-            public readonly GUIContent   sssProfileScatterDistance1 = new GUIContent("Scattering Distance #1", "The radius (in centimeters) of the 1st Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
-            public readonly GUIContent   sssProfileScatterDistance2 = new GUIContent("Scattering Distance #2", "The radius (in centimeters) of the 2nd Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
-            public readonly GUIContent   sssProfileLerpWeight       = new GUIContent("Filter Interpolation", "Controls linear interpolation between the two Gaussian filters.");
-            // <<< Old SSS Model
-            public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
-
-            public Styles()
-            {
-                centeredMiniBoldLabel.alignment = TextAnchor.MiddleCenter;
-                centeredMiniBoldLabel.fontSize  = 10;
-                centeredMiniBoldLabel.fontStyle = FontStyle.Bold;
-            }
-        }
-
-        private static Styles styles
-        {
-            get
-            {
-                if (s_Styles == null)
-                {
-                    s_Styles = new Styles();
-                }
-                return s_Styles;
-            }
-        }
-
-        private static Styles      s_Styles = null;
-
-        private RenderTexture      m_ProfileImage, m_TransmittanceImage;
-        private Material           m_ProfileMaterial, m_TransmittanceMaterial;
-        private SerializedProperty m_ScatteringDistance, m_MaxRadius, m_ShapeParam, m_TransmissionTint,
-                                   m_TexturingMode, m_TransmissionMode, m_ThicknessRemap, m_WorldScale;
-        // Old SSS Model >>>
-        private SerializedProperty m_ScatterDistance1, m_ScatterDistance2, m_LerpWeight;
-        // <<< Old SSS Model
-
-        void OnEnable()
-        {
-            m_ScatteringDistance    = serializedObject.FindProperty("scatteringDistance");
-            m_MaxRadius             = serializedObject.FindProperty("m_MaxRadius");
-            m_ShapeParam            = serializedObject.FindProperty("m_ShapeParam");
-            m_TransmissionTint      = serializedObject.FindProperty("transmissionTint");
-            m_TexturingMode         = serializedObject.FindProperty("texturingMode");
-            m_TransmissionMode      = serializedObject.FindProperty("transmissionMode");
-            m_ThicknessRemap        = serializedObject.FindProperty("thicknessRemap");
-            m_WorldScale            = serializedObject.FindProperty("worldScale");
-            // Old SSS Model >>>
-            m_ScatterDistance1      = serializedObject.FindProperty("scatterDistance1");
-            m_ScatterDistance2      = serializedObject.FindProperty("scatterDistance2");
-            m_LerpWeight            = serializedObject.FindProperty("lerpWeight");
-            // <<< Old SSS Model
-
-            // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime
-            m_ProfileMaterial       = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawSssProfile");
-            m_TransmittanceMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
-
-            m_ProfileImage          = new RenderTexture(256, 256, 0, RenderTextureFormat.DefaultHDR);
-            m_TransmittanceImage    = new RenderTexture( 16, 256, 0, RenderTextureFormat.DefaultHDR);
-        }
-
-        public override void OnInspectorGUI()
-        {
-            serializedObject.Update();
-
-            // Old SSS Model >>>
-            bool useDisneySSS;
-            {
-                HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
-                useDisneySSS = hdPipeline.sssSettings.useDisneySSS;
-            }
-            // <<< Old SSS Model
-
-            EditorGUI.BeginChangeCheck();
-            {
-                if (useDisneySSS)
-                {
-                    EditorGUILayout.PropertyField(m_ScatteringDistance, styles.sssProfileScatteringDistance);
-
-                    GUI.enabled = false;
-                    EditorGUILayout.PropertyField(m_MaxRadius, styles.sssProfileMaxRadius);
-                    GUI.enabled = true;
-                }
-                else
-                {
-                    EditorGUILayout.PropertyField(m_ScatterDistance1, styles.sssProfileScatterDistance1);
-                    EditorGUILayout.PropertyField(m_ScatterDistance2, styles.sssProfileScatterDistance2);
-                    EditorGUILayout.PropertyField(m_LerpWeight,       styles.sssProfileLerpWeight);
-                }
-
-                m_TexturingMode.intValue    = EditorGUILayout.Popup(styles.sssTexturingMode,           m_TexturingMode.intValue,    styles.sssTexturingModeOptions);
-                m_TransmissionMode.intValue = EditorGUILayout.Popup(styles.sssProfileTransmissionMode, m_TransmissionMode.intValue, styles.sssTransmissionModeOptions);
-
-                EditorGUILayout.PropertyField(m_TransmissionTint,   styles.sssProfileTransmissionTint);
-                EditorGUILayout.PropertyField(m_ThicknessRemap, styles.sssProfileMinMaxThickness);
-                Vector2 thicknessRemap = m_ThicknessRemap.vector2Value;
-                EditorGUILayout.MinMaxSlider(styles.sssProfileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0.0f, 50.0f);
-                m_ThicknessRemap.vector2Value = thicknessRemap;
-                EditorGUILayout.PropertyField(m_WorldScale, styles.sssProfileWorldScale);
-
-                EditorGUILayout.Space();
-                EditorGUILayout.LabelField(styles.sssProfilePreview0, styles.centeredMiniBoldLabel);
-                EditorGUILayout.LabelField(styles.sssProfilePreview1, EditorStyles.centeredGreyMiniLabel);
-                EditorGUILayout.LabelField(styles.sssProfilePreview2, EditorStyles.centeredGreyMiniLabel);
-                EditorGUILayout.LabelField(styles.sssProfilePreview3, EditorStyles.centeredGreyMiniLabel);
-                EditorGUILayout.Space();
-            }
-
-            float   r = m_MaxRadius.floatValue;
-            Vector3 S = m_ShapeParam.vector3Value;
-            Vector4 T = m_TransmissionTint.colorValue;
-            Vector2 R = m_ThicknessRemap.vector2Value;
-            bool transmissionEnabled = m_TransmissionMode.intValue != (int)SubsurfaceScatteringProfile.TransmissionMode.None;
-
-            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius,  r);
-            m_ProfileMaterial.SetVector(HDShaderIDs._ShapeParam, S);
-            // Old SSS Model >>>
-            CoreUtils.SelectKeyword(m_ProfileMaterial, "SSS_MODEL_DISNEY", "SSS_MODEL_BASIC", useDisneySSS);
-            // Apply the three-sigma rule, and rescale.
-            float   s       = (1.0f / 3.0f) * SssConstants.SSS_BASIC_DISTANCE_SCALE;
-            float   rMax    = Mathf.Max(m_ScatterDistance1.colorValue.r, m_ScatterDistance1.colorValue.g, m_ScatterDistance1.colorValue.b,
-                                        m_ScatterDistance2.colorValue.r, m_ScatterDistance2.colorValue.g, m_ScatterDistance2.colorValue.b);
-            Vector4 stdDev1 = s * m_ScatterDistance1.colorValue;
-            Vector4 stdDev2 = s * m_ScatterDistance2.colorValue;
-            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev1,   stdDev1);
-            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev2,   stdDev2);
-            m_ProfileMaterial.SetFloat(HDShaderIDs._LerpWeight, m_LerpWeight.floatValue);
-            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius,  rMax);
-            // <<< Old SSS Model
-
-            // Draw the profile.
-            EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImage, m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
-
-            EditorGUILayout.Space();
-            EditorGUILayout.LabelField(styles.sssTransmittancePreview0, styles.centeredMiniBoldLabel);
-            EditorGUILayout.LabelField(styles.sssTransmittancePreview1, EditorStyles.centeredGreyMiniLabel);
-            EditorGUILayout.LabelField(styles.sssTransmittancePreview2, EditorStyles.centeredGreyMiniLabel);
-            EditorGUILayout.Space();
-
-            // Old SSS Model >>>
-            // Multiply by 0.1 to convert from millimeters to centimeters. Apply the distance scale.
-            float a = 0.1f * SssConstants.SSS_BASIC_DISTANCE_SCALE;
-            Vector4 halfRcpVarianceAndWeight1 = new Vector4(a * a * 0.5f / (stdDev1.x * stdDev1.x), a * a * 0.5f / (stdDev1.y * stdDev1.y), a * a * 0.5f / (stdDev1.z * stdDev1.z), 4 * (1.0f - m_LerpWeight.floatValue));
-            Vector4 halfRcpVarianceAndWeight2 = new Vector4(a * a * 0.5f / (stdDev2.x * stdDev2.x), a * a * 0.5f / (stdDev2.y * stdDev2.y), a * a * 0.5f / (stdDev2.z * stdDev2.z), 4 * m_LerpWeight.floatValue);
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._HalfRcpVarianceAndWeight1, halfRcpVarianceAndWeight1);
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._HalfRcpVarianceAndWeight2, halfRcpVarianceAndWeight2);
-            // <<< Old SSS Model
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._ShapeParam,       S);
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._TransmissionTint, transmissionEnabled ? T : Vector4.zero);
-            m_TransmittanceMaterial.SetVector(HDShaderIDs._ThicknessRemap,   R);
-
-            // Draw the transmittance graph.
-            EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImage, m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
-
-            serializedObject.ApplyModifiedProperties();
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                HDRenderPipeline hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
-                // Validate each individual asset and update caches.
-                hdPipeline.sssSettings.OnValidate();
-            }
-        }
-    }
-#endif
 }

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs

 using System;
 using UnityEngine;
-using UnityEngine.Rendering;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/UnlitUI.cs

 using System;
 using UnityEngine;
-using UnityEngine.Rendering;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {

ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering.HDPipeline;
 using System;
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/RenderPipelineResources/RenderPipelineResources.cs

 {
     public class RenderPipelineResources : ScriptableObject
     {
-#if UNITY_EDITOR
-        public static string GetRenderPipelineResourcesPath()
-        {
-            return HDUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/HDRenderPipelineResources.asset";
-        }
-
-        // TODO skybox/cubemap
-
-        [UnityEditor.MenuItem("RenderPipeline/HDRenderPipeline/Create Resources Asset", false, 15)]
-        static void CreateRenderPipelineResources()
-        {
-            var instance = CreateInstance<RenderPipelineResources>();
-
-            string HDRenderPipelinePath = HDUtils.GetHDRenderPipelinePath();
-            string PostProcessingPath = HDUtils.GetPostProcessingPath();
-            string CorePath = HDUtils.GetCorePath();
-
-            instance.debugDisplayLatlongShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
-            instance.debugViewMaterialGBufferShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");
-            instance.debugViewTilesShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Debug/DebugViewTiles.Shader");
-            instance.debugFullScreenShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Debug/DebugFullScreen.Shader");
-
-            instance.deferredShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
-            instance.screenSpaceAmbientOcclusionShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.Shader");
-            instance.subsurfaceScatteringCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Material/Lit/Resources/SubsurfaceScattering.compute");
-            instance.volumetricLightingCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/Volumetrics/Resources/VolumetricLighting.compute");
-            instance.gaussianPyramidCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");
-            instance.depthPyramidCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthDownsample.compute");
-            instance.copyChannelCS = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(CorePath + "Resources/GPUCopy.compute");
-
-            instance.clearDispatchIndirectShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/cleardispatchindirect.compute");
-            instance.buildDispatchIndirectShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/builddispatchindirect.compute");
-            instance.buildScreenAABBShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/scrbound.compute");
-            instance.buildPerTileLightListShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild.compute");
-            instance.buildPerBigTileLightListShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-bigtile.compute");
-            instance.buildPerVoxelLightListShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-clustered.compute");
-            instance.buildMaterialFlagsShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/materialflags.compute");
-            instance.deferredComputeShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/Deferred.compute");
-
-            instance.deferredDirectionalShadowComputeShader = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/DeferredDirectionalShadow.compute");
-
-            // SceneSettings
-            // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)
-            // instance.drawSssProfile = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawSssProfile.shader");
-            // instance.drawTransmittanceGraphShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawTransmittanceGraph.shader");
-
-            instance.cameraMotionVectors = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "RenderPipelineResources/CameraMotionVectors.shader");
-
-            // Sky
-            instance.blitCubemap = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Sky/BlitCubemap.shader");
-            instance.buildProbabilityTables = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Sky/BuildProbabilityTables.compute");
-            instance.computeGgxIblSampleData = UnityEditor.AssetDatabase.LoadAssetAtPath<ComputeShader>(HDRenderPipelinePath + "Sky/ComputeGgxIblSampleData.compute");
-            instance.GGXConvolve = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "Sky/GGXConvolve.shader");
-
-            // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
-            instance.skyboxCubemap = Shader.Find("Skybox/Cubemap");
-
-            UnityEditor.AssetDatabase.CreateAsset(instance, GetRenderPipelineResourcesPath());
-            UnityEditor.AssetDatabase.SaveAssets();
-            UnityEditor.AssetDatabase.Refresh();
-        }
-#endif
         // Debug
         public Shader debugDisplayLatlongShader;
         public Shader debugViewMaterialGBufferShader;

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/Editor/CommonSettingsEditor.cs

-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SceneSettings.cs

-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/SceneSettings/SceneSettingsManager.cs

-using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
 

ScriptableRenderPipeline/HDRenderPipeline/ShaderConfig.cs

 using UnityEngine;
-using UnityEngine.Rendering;
 using System;
 //-----------------------------------------------------------------------------
 // Configuration

ScriptableRenderPipeline/HDRenderPipeline/ShaderPass/ShaderPass.cs

 using UnityEngine;
-using UnityEngine.Experimental.Rendering.HDPipeline;
 using System;
 
 //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/Editor/HDRISkyEditor.cs

-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
 

ScriptableRenderPipeline/HDRenderPipeline/Sky/HDRISky/HDRISkyRenderer.cs

-using UnityEngine.Rendering;
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class HDRISkyRenderer : SkyRenderer

ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/Editor/ProceduralSkyEditor.cs

-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 using UnityEditor;
 

ScriptableRenderPipeline/HDRenderPipeline/Sky/ProceduralSky/ProceduralSkyRenderer.cs

-using UnityEngine.Rendering;
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     public class ProceduralSkyRenderer : SkyRenderer

ScriptableRenderPipeline/HDRenderPipeline/Sky/RuntimeFilterIBL.cs

 using UnityEngine.Rendering;
-using UnityEngine.Experimental.Rendering.HDPipeline;
 using System;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/Wind/ShaderWindSettings.cs

-using System.Collections;
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/LightweightPipeline/Editor/ShaderGUI/LightweightUnlitGUI.cs

 using System;
 using UnityEditor;
 using UnityEngine;
-using UnityEngine.Rendering;
 using UnityEditor.Experimental.Rendering.LightweightPipeline;
 
 public class LightweightUnlitGUI : ShaderGUI

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 using System;
-using System.Collections.Generic;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
 using UnityEngine.XR;

ScriptableRenderPipeline/Core/Editor/CoreEditorUtils.cs

+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering
+{
+    public static class CoreEditorUtils
+    {
+        // UI Helpers
+        public static void DrawSplitter()
+        {
+            var rect = GUILayoutUtility.GetRect(1f, 1f);
+
+            // Splitter rect should be full-width
+            rect.xMin = 0f;
+            rect.width += 4f;
+
+            if (Event.current.type != EventType.Repaint)
+                return;
+
+            EditorGUI.DrawRect(rect, !EditorGUIUtility.isProSkin
+                ? new Color(0.6f, 0.6f, 0.6f, 1.333f)
+                : new Color(0.12f, 0.12f, 0.12f, 1.333f));
+        }
+
+        public static void DrawHeader(string title)
+        {
+            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
+
+            var labelRect = backgroundRect;
+            labelRect.xMin += 16f;
+            labelRect.xMax -= 20f;
+
+            var foldoutRect = backgroundRect;
+            foldoutRect.y += 1f;
+            foldoutRect.width = 13f;
+            foldoutRect.height = 13f;
+
+            // Background rect should be full-width
+            backgroundRect.xMin = 0f;
+            backgroundRect.width += 4f;
+
+            // Background
+            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
+            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
+
+            // Title
+            EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
+            EditorGUILayout.Space();
+        }
+
+        public static bool DrawHeaderFoldout(string title, bool state)
+        {
+            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
+
+            var labelRect = backgroundRect;
+            labelRect.xMin += 16f;
+            labelRect.xMax -= 20f;
+
+            var foldoutRect = backgroundRect;
+            foldoutRect.y += 1f;
+            foldoutRect.width = 13f;
+            foldoutRect.height = 13f;
+
+            // Background rect should be full-width
+            backgroundRect.xMin = 0f;
+            backgroundRect.width += 4f;
+
+            // Background
+            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
+            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
+
+            // Title
+            EditorGUI.LabelField(labelRect, title, EditorStyles.boldLabel);
+
+            // Active checkbox
+            state = GUI.Toggle(foldoutRect, state, GUIContent.none, EditorStyles.foldout);
+
+            var e = Event.current;
+            if (e.type == EventType.MouseDown && backgroundRect.Contains(e.mousePosition) && e.button == 0)
+            {
+                state = !state;
+                e.Use();
+            }
+
+            return state;
+        }
+    }
+}

ScriptableRenderPipeline/Core/Editor/CoreEditorUtils.cs.meta

+fileFormatVersion: 2
+guid: 744ceabda269e6c469964dda8c490d0d
+timeCreated: 1507109827
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/Core/Resources/Editor.meta

+fileFormatVersion: 2
+guid: f00a25194233f5c4392fa05f23ecc076
+folderAsset: yes
+timeCreated: 1507130547
+licenseType: Pro
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDAssetFactory.cs

+using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    using UnityObject = UnityEngine.Object;
+
+    static class HDAssetFactory
+    {
+        static string s_RenderPipelineResourcesPath
+        {
+            get { return HDEditorUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/HDRenderPipelineResources.asset"; }
+        }
+
+        [MenuItem("RenderPipeline/HDRenderPipeline/Create Pipeline Asset", false, 16)]
+        static void CreateHDRenderPipeline()
+        {
+            var instance = ScriptableObject.CreateInstance<HDRenderPipelineAsset>();
+            AssetDatabase.CreateAsset(instance, HDEditorUtils.GetHDRenderPipelinePath() + "HDRenderPipelineAsset.asset");
+
+            // If it exist, load renderPipelineResources
+            instance.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(s_RenderPipelineResourcesPath);
+        }
+
+        // TODO skybox/cubemap
+
+        [MenuItem("RenderPipeline/HDRenderPipeline/Create Resources Asset", false, 15)]
+        static void CreateRenderPipelineResources()
+        {
+            string HDRenderPipelinePath = HDEditorUtils.GetHDRenderPipelinePath();
+            string PostProcessingPath = HDEditorUtils.GetPostProcessingPath();
+            string CorePath = HDEditorUtils.GetCorePath();
+
+            var instance = ScriptableObject.CreateInstance<RenderPipelineResources>();
+
+            instance.debugDisplayLatlongShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
+            instance.debugViewMaterialGBufferShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");
+            instance.debugViewTilesShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewTiles.Shader");
+            instance.debugFullScreenShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugFullScreen.Shader");
+
+            instance.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
+            instance.screenSpaceAmbientOcclusionShader = Load<Shader>(HDRenderPipelinePath + "Lighting/AmbientOcclusion/ScreenSpaceAmbientOcclusion.Shader");
+            instance.subsurfaceScatteringCS = Load<ComputeShader>(HDRenderPipelinePath + "Material/Lit/Resources/SubsurfaceScattering.compute");
+            instance.volumetricLightingCS = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/Volumetrics/Resources/VolumetricLighting.compute");
+            instance.gaussianPyramidCS = Load<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");
+            instance.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthDownsample.compute");
+            instance.copyChannelCS = Load<ComputeShader>(CorePath + "Resources/GPUCopy.compute");
+
+            instance.clearDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/cleardispatchindirect.compute");
+            instance.buildDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/builddispatchindirect.compute");
+            instance.buildScreenAABBShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/scrbound.compute");
+            instance.buildPerTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild.compute");
+            instance.buildPerBigTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-bigtile.compute");
+            instance.buildPerVoxelLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-clustered.compute");
+            instance.buildMaterialFlagsShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/materialflags.compute");
+            instance.deferredComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/Deferred.compute");
+
+            instance.deferredDirectionalShadowComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/DeferredDirectionalShadow.compute");
+
+            // SceneSettings
+            // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)
+            // instance.drawSssProfile = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawSssProfile.shader");
+            // instance.drawTransmittanceGraphShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawTransmittanceGraph.shader");
+
+            instance.cameraMotionVectors = Load<Shader>(HDRenderPipelinePath + "RenderPipelineResources/CameraMotionVectors.shader");
+
+            // Sky
+            instance.blitCubemap = Load<Shader>(HDRenderPipelinePath + "Sky/BlitCubemap.shader");
+            instance.buildProbabilityTables = Load<ComputeShader>(HDRenderPipelinePath + "Sky/BuildProbabilityTables.compute");
+            instance.computeGgxIblSampleData = Load<ComputeShader>(HDRenderPipelinePath + "Sky/ComputeGgxIblSampleData.compute");
+            instance.GGXConvolve = Load<Shader>(HDRenderPipelinePath + "Sky/GGXConvolve.shader");
+
+            // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
+            instance.skyboxCubemap = Shader.Find("Skybox/Cubemap");
+
+            AssetDatabase.CreateAsset(instance, s_RenderPipelineResourcesPath);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+        }
+
+        // Note: move this to a static using once we can target C#6+
+        static T Load<T>(string path)
+            where T : UnityObject
+        {
+            return AssetDatabase.LoadAssetAtPath<T>(path);
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDAssetFactory.cs.meta

+fileFormatVersion: 2
+guid: c895a728829a6b94da9922c78197e403
+timeCreated: 1507108008
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDEditorUtils.cs

+using System.IO;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    public class HDEditorUtils
+    {
+        public static string GetHDRenderPipelinePath()
+        {
+            // User can create their own directory for SRP, so we need to find the current path that they use.
+            // We know that DefaultHDMaterial exist and we know where it is, let's use that to find the current directory.
+            var guid = AssetDatabase.FindAssets("DefaultHDMaterial t:material");
+            string path = AssetDatabase.GUIDToAssetPath(guid[0]);
+            path = Path.GetDirectoryName(path); // Asset is in HDRenderPipeline/RenderPipelineResources/DefaultHDMaterial.mat
+            path = path.Replace("RenderPipelineResources", ""); // Keep only path with HDRenderPipeline
+
+            return path;
+        }
+
+        // TODO: The two following functions depend on HDRP, they should be made generic
+        public static string GetPostProcessingPath()
+        {
+            var hdrpPath = GetHDRenderPipelinePath();
+            var fullPath = Path.GetFullPath(hdrpPath + "../../PostProcessing/PostProcessing");
+            var relativePath = fullPath.Substring(fullPath.IndexOf("Assets"));
+            return relativePath.Replace("\\", "/") + "/";
+        }
+
+        public static string GetCorePath()
+        {
+            var hdrpPath = GetHDRenderPipelinePath();
+            var fullPath = Path.GetFullPath(hdrpPath + "../Core");
+            var relativePath = fullPath.Substring(fullPath.IndexOf("Assets"));
+            return relativePath.Replace("\\", "/") + "/";
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDEditorUtils.cs.meta

+fileFormatVersion: 2
+guid: 7e04ef797263c2a47ad576cce5233df9
+timeCreated: 1507109247
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringProfileEditor.Styles.cs

+using UnityEngine;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    partial class SubsurfaceScatteringProfileEditor
+    {
+        sealed class Styles
+        {
+            public readonly GUIContent   profilePreview0           = new GUIContent("Profile Preview");
+            public readonly GUIContent   profilePreview1           = new GUIContent("Shows the fraction of light scattered from the source (center).");
+            public readonly GUIContent   profilePreview2           = new GUIContent("The distance to the boundary of the image corresponds to the Max Radius.");
+            public readonly GUIContent   profilePreview3           = new GUIContent("Note that the intensity of pixels around the center may be clipped.");
+            public readonly GUIContent   transmittancePreview0     = new GUIContent("Transmittance Preview");
+            public readonly GUIContent   transmittancePreview1     = new GUIContent("Shows the fraction of light passing through the object for thickness values from the remap.");
+            public readonly GUIContent   transmittancePreview2     = new GUIContent("Can be viewed as a cross section of a slab of material illuminated by white light from the left.");
+            public readonly GUIContent   profileScatteringDistance = new GUIContent("Scattering Distance", "Determines the shape of the profile, and the blur radius of the filter per color channel. Alpha is ignored.");
+            public readonly GUIContent   profileTransmissionTint   = new GUIContent("Transmission tint", "Color which tints transmitted light. Alpha is ignored.");
+            public readonly GUIContent   profileMaxRadius          = new GUIContent("Max Radius", "Effective radius of the filter (in millimeters). The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Reducing the distance increases the sharpness of the result.");
+            public readonly GUIContent   texturingMode             = new GUIContent("Texturing Mode", "Specifies when the diffuse texture should be applied.");
+            public readonly GUIContent[] texturingModeOptions      = new GUIContent[2]
+            {
+                new GUIContent("Pre- and post-scatter", "Texturing is performed during both the lighting and the SSS passes. Slightly blurs the diffuse texture. Choose this mode if your diffuse texture contains little to no SSS lighting."),
+                new GUIContent("Post-scatter",          "Texturing is performed only during the SSS pass. Effectively preserves the sharpness of the diffuse texture. Choose this mode if your diffuse texture already contains SSS lighting (e.g. a photo of skin).")
+            };
+            public readonly GUIContent   profileTransmissionMode = new GUIContent("Transmission Mode", "Configures the simulation of light passing through thin objects. Depends on the thickness value (which is applied in the normal direction).");
+            public readonly GUIContent[] transmissionModeOptions = new GUIContent[3]
+            {
+                new GUIContent("None",         "Disables transmission. Choose this mode for completely opaque, or very thick translucent objects."),
+                new GUIContent("Thin Object",  "Choose this mode for thin objects, such as paper or leaves. Transmitted light reuses the shadowing state of the surface."),
+                new GUIContent("Regular",      "Choose this mode for moderately thick objects. For performance reasons, transmitted light ignores occlusion (shadows).")
+            };
+            public readonly GUIContent   profileMinMaxThickness = new GUIContent("Min-Max Thickness", "Shows the values of the thickness remap below (in millimeters).");
+            public readonly GUIContent   profileThicknessRemap  = new GUIContent("Thickness Remap", "Remaps the thickness parameter from [0, 1] to the desired range (in millimeters).");
+            public readonly GUIContent   profileWorldScale      = new GUIContent("World Scale", "Size of the world unit in meters.");
+            // Old SSS Model >>>
+            public readonly GUIContent   profileScatterDistance1 = new GUIContent("Scattering Distance #1", "The radius (in centimeters) of the 1st Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
+            public readonly GUIContent   profileScatterDistance2 = new GUIContent("Scattering Distance #2", "The radius (in centimeters) of the 2nd Gaussian filter, one per color channel. Alpha is ignored. The blur is energy-preserving, so a wide filter results in a large area with small contributions of individual samples. Smaller values increase the sharpness.");
+            public readonly GUIContent   profileLerpWeight       = new GUIContent("Filter Interpolation", "Controls linear interpolation between the two Gaussian filters.");
+            // <<< Old SSS Model
+            public readonly GUIStyle     centeredMiniBoldLabel     = new GUIStyle(GUI.skin.label);
+
+            public Styles()
+            {
+                centeredMiniBoldLabel.alignment = TextAnchor.MiddleCenter;
+                centeredMiniBoldLabel.fontSize  = 10;
+                centeredMiniBoldLabel.fontStyle = FontStyle.Bold;
+            }
+        }
+
+        static Styles s_Styles;
+
+        // Can't use a static initializer in case we need to create GUIStyle in the Styles class as
+        // these can only be created with an active GUI rendering context
+        void CheckStyles()
+        {
+            if (s_Styles == null)
+                s_Styles = new Styles();
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringProfileEditor.Styles.cs.meta

+fileFormatVersion: 2
+guid: fcb1bb4049093ff41855e3951f22e9cf
+timeCreated: 1507119569
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringProfileEditor.cs

+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    [CustomEditor(typeof(SubsurfaceScatteringProfile))]
+    public partial class SubsurfaceScatteringProfileEditor : Editor
+    {
+        RenderTexture      m_ProfileImage;
+        RenderTexture      m_TransmittanceImage;
+        Material           m_ProfileMaterial;
+        Material           m_TransmittanceMaterial;
+        SerializedProperty m_ScatteringDistance;
+        SerializedProperty m_MaxRadius;
+        SerializedProperty m_ShapeParam;
+        SerializedProperty m_TransmissionTint;
+        SerializedProperty m_TexturingMode;
+        SerializedProperty m_TransmissionMode;
+        SerializedProperty m_ThicknessRemap;
+        SerializedProperty m_WorldScale;
+
+        // Old SSS Model >>>
+        SerializedProperty m_ScatterDistance1;
+        SerializedProperty m_ScatterDistance2;
+        SerializedProperty m_LerpWeight;
+        // <<< Old SSS Model
+
+        void OnEnable()
+        {
+            using (var o = new PropertyFetcher<SubsurfaceScatteringProfile>(serializedObject))
+            {
+                m_ScatteringDistance    = o.FindProperty(x => x.scatteringDistance);
+                m_MaxRadius             = o.FindProperty("m_MaxRadius");
+                m_ShapeParam            = o.FindProperty("m_ShapeParam");
+                m_TransmissionTint      = o.FindProperty(x => x.transmissionTint);
+                m_TexturingMode         = o.FindProperty(x => x.texturingMode);
+                m_TransmissionMode      = o.FindProperty(x => x.transmissionMode);
+                m_ThicknessRemap        = o.FindProperty(x => x.thicknessRemap);
+                m_WorldScale            = o.FindProperty(x => x.worldScale);
+                // Old SSS Model >>>
+                m_ScatterDistance1      = o.FindProperty(x => x.scatterDistance1);
+                m_ScatterDistance2      = o.FindProperty(x => x.scatterDistance2);
+                m_LerpWeight            = o.FindProperty(x => x.lerpWeight);
+                // <<< Old SSS Model
+            }
+
+            // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime
+            m_ProfileMaterial       = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawSssProfile");
+            m_TransmittanceMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/DrawTransmittanceGraph");
+
+            m_ProfileImage          = new RenderTexture(256, 256, 0, RenderTextureFormat.DefaultHDR);
+            m_TransmittanceImage    = new RenderTexture( 16, 256, 0, RenderTextureFormat.DefaultHDR);
+        }
+
+        void OnDisable()
+        {
+            CoreUtils.Destroy(m_ProfileMaterial);
+            CoreUtils.Destroy(m_TransmittanceMaterial);
+            CoreUtils.Destroy(m_ProfileImage);
+            CoreUtils.Destroy(m_TransmittanceImage);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            var hdPipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+
+            if (hdPipeline == null)
+                return;
+
+            serializedObject.Update();
+            CheckStyles();
+
+            // Old SSS Model >>>
+            bool useDisneySSS = hdPipeline.sssSettings.useDisneySSS;
+            // <<< Old SSS Model
+
+            using (var scope = new EditorGUI.ChangeCheckScope())
+            {
+                if (useDisneySSS)
+                {
+                    EditorGUILayout.PropertyField(m_ScatteringDistance, s_Styles.profileScatteringDistance);
+
+                    using (new EditorGUI.DisabledScope(true))
+                        EditorGUILayout.PropertyField(m_MaxRadius, s_Styles.profileMaxRadius);
+                }
+                else
+                {
+                    EditorGUILayout.PropertyField(m_ScatterDistance1, s_Styles.profileScatterDistance1);
+                    EditorGUILayout.PropertyField(m_ScatterDistance2, s_Styles.profileScatterDistance2);
+                    EditorGUILayout.PropertyField(m_LerpWeight, s_Styles.profileLerpWeight);
+                }
+
+                m_TexturingMode.intValue = EditorGUILayout.Popup(s_Styles.texturingMode, m_TexturingMode.intValue, s_Styles.texturingModeOptions);
+                m_TransmissionMode.intValue = EditorGUILayout.Popup(s_Styles.profileTransmissionMode, m_TransmissionMode.intValue, s_Styles.transmissionModeOptions);
+
+                EditorGUILayout.PropertyField(m_TransmissionTint, s_Styles.profileTransmissionTint);
+                EditorGUILayout.PropertyField(m_ThicknessRemap, s_Styles.profileMinMaxThickness);
+                Vector2 thicknessRemap = m_ThicknessRemap.vector2Value;
+                EditorGUILayout.MinMaxSlider(s_Styles.profileThicknessRemap, ref thicknessRemap.x, ref thicknessRemap.y, 0.0f, 50.0f);
+                m_ThicknessRemap.vector2Value = thicknessRemap;
+                EditorGUILayout.PropertyField(m_WorldScale, s_Styles.profileWorldScale);
+
+                EditorGUILayout.Space();
+                EditorGUILayout.LabelField(s_Styles.profilePreview0, s_Styles.centeredMiniBoldLabel);
+                EditorGUILayout.LabelField(s_Styles.profilePreview1, EditorStyles.centeredGreyMiniLabel);
+                EditorGUILayout.LabelField(s_Styles.profilePreview2, EditorStyles.centeredGreyMiniLabel);
+                EditorGUILayout.LabelField(s_Styles.profilePreview3, EditorStyles.centeredGreyMiniLabel);
+                EditorGUILayout.Space();
+
+                serializedObject.ApplyModifiedProperties();
+
+                if (scope.changed)
+                {
+                    // Validate each individual asset and update caches.
+                    ((SubsurfaceScatteringProfile)target).Validate();
+                }
+            }
+
+            float r = m_MaxRadius.floatValue;
+            Vector3 S = m_ShapeParam.vector3Value;
+            Vector4 T = m_TransmissionTint.colorValue;
+            Vector2 R = m_ThicknessRemap.vector2Value;
+            bool transmissionEnabled = m_TransmissionMode.intValue != (int)SubsurfaceScatteringProfile.TransmissionMode.None;
+
+            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius, r);
+            m_ProfileMaterial.SetVector(HDShaderIDs._ShapeParam, S);
+
+            // Old SSS Model >>>
+            CoreUtils.SelectKeyword(m_ProfileMaterial, "SSS_MODEL_DISNEY", "SSS_MODEL_BASIC", useDisneySSS);
+
+            // Apply the three-sigma rule, and rescale.
+            float s = (1.0f / 3.0f) * SssConstants.SSS_BASIC_DISTANCE_SCALE;
+            float rMax = Mathf.Max(m_ScatterDistance1.colorValue.r, m_ScatterDistance1.colorValue.g, m_ScatterDistance1.colorValue.b,
+                m_ScatterDistance2.colorValue.r, m_ScatterDistance2.colorValue.g, m_ScatterDistance2.colorValue.b);
+            Vector4 stdDev1 = s * m_ScatterDistance1.colorValue;
+            Vector4 stdDev2 = s * m_ScatterDistance2.colorValue;
+            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev1, stdDev1);
+            m_ProfileMaterial.SetVector(HDShaderIDs._StdDev2, stdDev2);
+            m_ProfileMaterial.SetFloat(HDShaderIDs._LerpWeight, m_LerpWeight.floatValue);
+            m_ProfileMaterial.SetFloat(HDShaderIDs._MaxRadius, rMax);
+            // <<< Old SSS Model
+
+            // Draw the profile.
+            EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImage, m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField(s_Styles.transmittancePreview0, s_Styles.centeredMiniBoldLabel);
+            EditorGUILayout.LabelField(s_Styles.transmittancePreview1, EditorStyles.centeredGreyMiniLabel);
+            EditorGUILayout.LabelField(s_Styles.transmittancePreview2, EditorStyles.centeredGreyMiniLabel);
+            EditorGUILayout.Space();
+
+            // Old SSS Model >>>
+            // Multiply by 0.1 to convert from millimeters to centimeters. Apply the distance scale.
+            float a = 0.1f * SssConstants.SSS_BASIC_DISTANCE_SCALE;
+            Vector4 halfRcpVarianceAndWeight1 = new Vector4(a * a * 0.5f / (stdDev1.x * stdDev1.x), a * a * 0.5f / (stdDev1.y * stdDev1.y), a * a * 0.5f / (stdDev1.z * stdDev1.z), 4 * (1.0f - m_LerpWeight.floatValue));
+            Vector4 halfRcpVarianceAndWeight2 = new Vector4(a * a * 0.5f / (stdDev2.x * stdDev2.x), a * a * 0.5f / (stdDev2.y * stdDev2.y), a * a * 0.5f / (stdDev2.z * stdDev2.z), 4 * m_LerpWeight.floatValue);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._HalfRcpVarianceAndWeight1, halfRcpVarianceAndWeight1);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._HalfRcpVarianceAndWeight2, halfRcpVarianceAndWeight2);
+            // <<< Old SSS Model
+
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._ShapeParam, S);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._TransmissionTint, transmissionEnabled ? T : Vector4.zero);
+            m_TransmittanceMaterial.SetVector(HDShaderIDs._ThicknessRemap, R);
+
+            // Draw the transmittance graph.
+            EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(16, 16), m_TransmittanceImage, m_TransmittanceMaterial, ScaleMode.ScaleToFit, 16.0f);
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Editor/SubsurfaceScatteringProfileEditor.cs.meta

+fileFormatVersion: 2
+guid: 4e87e719e85a91846ad1d5aa15793685
+timeCreated: 1507118957
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: