Merge remote-tracking branch 'origin/Unity-2017.3' into Reorganize-HDRP-GraphicTests

SampleScenes/HDTest/DistortionTest.unity

   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 12b78618760f1ed418b720ef565ac193, type: 2}
+  - {fileID: 2100000, guid: f7ab0c70df8099e48a29dac7439299a8, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_Materials:
-  - {fileID: 2100000, guid: 12b78618760f1ed418b720ef565ac193, type: 2}
+  - {fileID: 2100000, guid: f7ab0c70df8099e48a29dac7439299a8, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_ShowToolkit: 0
   m_ShowCustomSorter: 0
   breakBeforeColorGrading: 0
-  m_BeforeTransparentBundles: []
+  m_BeforeTransparentBundles:
+  - assemblyQualifiedName: InvertOpaque, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
+      PublicKeyToken=null
   m_BeforeStackBundles:
   - assemblyQualifiedName: HalfToneOpaque, Assembly-CSharp, Version=0.0.0.0, Culture=neutral,
       PublicKeyToken=null

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Lit_Reject.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Mat_Distorsion_Lit_Reject
-  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT
+  m_Shader: {fileID: 4800000, guid: c4edd00ff2db5b24391a4fcb1762e459, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _BLENDMODE_ALPHA _DISTORTIONDEPTHTEST_OFF
+    _DOUBLESIDEDENABLE_OFF _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE _PREREFRACTIONPASS_OFF
+    _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
   disabledShaderPasses:
   - ForwardOnlyOpaqueDepthOnly
   - ForwardOnlyOpaque
+  - Forward
+  - DepthOnly
+  - DepthForwardOnly
+  - ForwardOnly
+  - GBuffer
+  - GBufferWithPrepass
+  - MOTIONVECTORS
+  - TransparentDepthPrepass
+  - META
+  - SHADOWCASTER
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ColorMap:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _ZWrite: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_plane_Clear_ior101.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_plane_Clear_ior15.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_plane_Dragon.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_plane_EarthMap.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_Clear_ior101.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_Clear_ior15.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_Dragon.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_EarthMap.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_EarthMap_RefractionMask.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_sphere_EarthMap_pretransparent.mat

     - _ZTestMode: 8
     - _ZWrite: 0
     m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 0.078431375}
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 0}
     - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Unlit_Voronoi.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: Mat_Distorsion_Lit_Only_2DNoise
-  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT
+  m_Name: Mat_Distorsion_Unlit_Voronoi
+  m_Shader: {fileID: 4800000, guid: c4edd00ff2db5b24391a4fcb1762e459, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _BLENDMODE_ALPHA _DISTORTIONDEPTHTEST_OFF
+    _DOUBLESIDEDENABLE_OFF _ENABLE_FOG_ON_TRANSPARENT _NORMALMAP_TANGENT_SPACE _PREREFRACTIONPASS_OFF
+    _SURFACE_TYPE_TRANSPARENT
   m_LightmapFlags: 4
   m_EnableInstancingVariants: 0
   m_DoubleSidedGI: 0
   disabledShaderPasses:
   - ForwardOnlyOpaque
   - ForwardOnlyOpaqueDepthOnly
+  - Forward
+  - DepthOnly
+  - DepthForwardOnly
+  - ForwardOnly
+  - GBuffer
+  - GBufferWithPrepass
+  - MOTIONVECTORS
+  - TransparentDepthPrepass
+  - META
+  - SHADOWCASTER
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _ColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
-        m_Texture: {fileID: 8600000, guid: 99d420ed53cf5bc449b014653d05770d, type: 2}
+        m_Texture: {fileID: 8600000, guid: 857ebf2cca737d54194a3a1077fec4cc, type: 2}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     - _EmissiveColorMap:
     - _DistortionBlurBlendMode: 0
     - _DistortionBlurDstBlend: 1
     - _DistortionBlurRemapMax: 1
-    - _DistortionBlurRemapMin: 0
-    - _DistortionBlurScale: 1
+    - _DistortionBlurRemapMin: 0.097841725
+    - _DistortionBlurScale: 1.5
     - _DistortionBlurSrcBlend: 1
     - _DistortionDepthTest: 0
     - _DistortionDstBlend: 1
-    - _DistortionScale: 1
+    - _DistortionScale: 200000
     - _DistortionSrcBlend: 1
     - _DistortionStencilRef: 4
     - _DoubleSidedEnable: 0
     - _ZWrite: 0
     m_Colors:
     - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
     - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
     - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}

ScriptableRenderPipeline/Core/Debugging/DebugMenuManager.cs

             if(m_DebugMenuState != null && m_DebugMenuStateDirty)
             {
                 m_DebugMenuStateDirty = false;
-                m_DebugMenuState.UpdateAllDebugItems();
+                m_DebugMenuState.ReInitializeDebugItemStates();
             }
 
             m_DebugMenuUI.Update();

ScriptableRenderPipeline/Core/Debugging/DebugMenuState.cs

 #if UNITY_EDITOR
             UnityEditor.Undo.undoRedoPerformed += OnUndoRedoPerformed;
 #endif
+            DebugMenuManager.instance.SetDebugMenuState(this);
+        }
+
+        public void OnDisable()
+        {
+            DebugMenuManager.instance.SetDebugMenuState(null);
+
+#if UNITY_EDITOR
+            UnityEditor.Undo.undoRedoPerformed -= OnUndoRedoPerformed;
+#endif
+        }
+
+        public void ReInitializeDebugItemStates()
+        {
+            CleanUp();
             // Populate item states
             DebugMenuManager dmm = DebugMenuManager.instance;
             for (int panelIdx = 0; panelIdx < dmm.panelCount; ++panelIdx)
                     if (debugItemState == null)
                     {
                         debugItemState = item.handler.CreateDebugItemState();
-                        if(debugItemState != null)
+                        if (debugItemState != null)
                         {
                             debugItemState.hideFlags = HideFlags.DontSave;
                             debugItemState.Initialize(item);
                 }
             }
 
-            DebugMenuManager.instance.SetDebugMenuState(this);
+            UpdateAllDebugItems();
-        public void OnDisable()
+        private void CleanUp()
-#if UNITY_EDITOR
-            UnityEditor.Undo.undoRedoPerformed -= OnUndoRedoPerformed;
-#endif
+            foreach (var item in m_ItemStateList)
+            {
+                Object.DestroyImmediate(item);
+            }
+
+            m_ItemStateList.Clear();
-            foreach(var item in m_ItemStateList)
-            {
-                Object.DestroyImmediate(item);
-            }
+            CleanUp();
         }
 
         void OnUndoRedoPerformed()
 #endif
         }
 
-        public void AddDebugItemState(DebugItemState state)
+        private void AddDebugItemState(DebugItemState state)
         {
             m_ItemStateList.Add(state);
         }
             return m_ItemStateList.Find(x => x.itemName == item.name && x.panelName == item.panelName);
         }
 
-        public void UpdateAllDebugItems()
+        private void UpdateAllDebugItems()
         {
             foreach (var itemState in m_ItemStateList)
             {

ScriptableRenderPipeline/Core/Debugging/Editor/DebugMenuEditor.cs

         {
             DebugItemState debugItemState = m_DebugMenuState.FindDebugItemState(item);
 
-            UnityEditor.Undo.RecordObject(debugItemState, "DebugMenu State Update");
-            debugItemState.SetValue(item.GetValue());
-            EditorUtility.SetDirty(m_DebugMenuState);
+            if(debugItemState != null)
+            {
+                UnityEditor.Undo.RecordObject(debugItemState, "DebugMenu State Update");
+                debugItemState.SetValue(item.GetValue());
+                EditorUtility.SetDirty(m_DebugMenuState);
+            }
         }
 
         void OnGUI()

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

             public static string InputsText = "Inputs";
 
             public static GUIContent baseColorText = new GUIContent("Base Color + Opacity", "Albedo (RGB) and Opacity (A)");
-            public static GUIContent baseColorRefractionMaskText = new GUIContent("Base Color + RefractionMask", "Albedo (RGB) and Refraction mask (A)");
 
             public static GUIContent smoothnessMapChannelText = new GUIContent("Smoothness Source", "Smoothness texture and channel");
             public static GUIContent metallicText = new GUIContent("Metallic", "Metallic scale factor");
 
             EditorGUI.indentLevel++;
 
-            bool refractionEnable = (material.HasProperty(kRefractionMode) && refractionMode.floatValue > 0.0f) && (material.HasProperty(kPreRefractionPass) && preRefractionPass.floatValue == 0.0f);
-
-            m_MaterialEditor.TexturePropertySingleLine(refractionEnable ? Styles.baseColorRefractionMaskText : Styles.baseColorText, baseColorMap[layerIndex], baseColor[layerIndex]);
+            m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, baseColorMap[layerIndex], baseColor[layerIndex]);
 
             if ((Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitStandard || (Lit.MaterialId)materialID.floatValue == Lit.MaterialId.LitAniso)
             {

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

             public Vector3 transmittanceColor;
             [SurfaceDataAttributes("Transmittance Absorption Distance")]
             public float atDistance;
-            [SurfaceDataAttributes("Refraction mask")]
-            public float refractionMask;
+            [SurfaceDataAttributes("Transmittance mask")]
+            public float transmittanceMask;
         };
 
         //-----------------------------------------------------------------------------
             public float ior;
             // Reuse thickness from SSS
             public Vector3 absorptionCoefficient;
-            public float refractionMask;
+            public float transmittanceMask;
         };
 
         //-----------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs.hlsl

 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+RefractionMode:  static fields
 //
 #define REFRACTIONMODE_NONE (0)
-#define REFRACTIONMODE_THICK_PLANE (1)
-#define REFRACTIONMODE_THICK_SPHERE (2)
-#define REFRACTIONMODE_THIN_PLANE (3)
+#define REFRACTIONMODE_PLANE (1)
+#define REFRACTIONMODE_SPHERE (2)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+SurfaceData:  static fields
 #define DEBUGVIEW_LIT_SURFACEDATA_IOR (1016)
 #define DEBUGVIEW_LIT_SURFACEDATA_TRANSMITTANCE_COLOR (1017)
 #define DEBUGVIEW_LIT_SURFACEDATA_AT_DISTANCE (1018)
-#define DEBUGVIEW_LIT_SURFACEDATA_REFRACTION_MASK (1019)
+#define DEBUGVIEW_LIT_SURFACEDATA_TRANSMITTANCE_MASK (1019)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+BSDFData:  static fields
 #define DEBUGVIEW_LIT_BSDFDATA_COAT_IOR (1050)
 #define DEBUGVIEW_LIT_BSDFDATA_IOR (1051)
 #define DEBUGVIEW_LIT_BSDFDATA_ABSORPTION_COEFFICIENT (1052)
-#define DEBUGVIEW_LIT_BSDFDATA_REFRACTION_MASK (1053)
+#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE_MASK (1053)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+GBufferMaterial:  static fields
     float ior;
     float3 transmittanceColor;
     float atDistance;
-    float refractionMask;
+    float transmittanceMask;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Lit+BSDFData
     float coatIOR;
     float ior;
     float3 absorptionCoefficient;
-    float refractionMask;
+    float transmittanceMask;
 };
 
 //
         case DEBUGVIEW_LIT_SURFACEDATA_AT_DISTANCE:
             result = surfacedata.atDistance.xxx;
             break;
-        case DEBUGVIEW_LIT_SURFACEDATA_REFRACTION_MASK:
-            result = surfacedata.refractionMask.xxx;
+        case DEBUGVIEW_LIT_SURFACEDATA_TRANSMITTANCE_MASK:
+            result = surfacedata.transmittanceMask.xxx;
             break;
     }
 }
         case DEBUGVIEW_LIT_BSDFDATA_ABSORPTION_COEFFICIENT:
             result = bsdfdata.absorptionCoefficient;
             break;
-        case DEBUGVIEW_LIT_BSDFDATA_REFRACTION_MASK:
-            result = bsdfdata.refractionMask.xxx;
+        case DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE_MASK:
+            result = bsdfdata.transmittanceMask.xxx;
             break;
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

     bsdfData.coatCoverage = coatCoverage;
 }
 
-void FillMaterialIdTransparencyData(float ior, float3 transmittanceColor, float atDistance, float thickness, float refractionMask, inout BSDFData bsdfData)
+void FillMaterialIdTransparencyData(float ior, float3 transmittanceColor, float atDistance, float thickness, float transmittanceMask, inout BSDFData bsdfData)
-    bsdfData.refractionMask = refractionMask;
+    bsdfData.transmittanceMask = transmittanceMask;
     bsdfData.thickness = max(thickness, 0.0001);
 }
 
 #if HAS_REFRACTION
     // Note: Will override thickness of SSS's property set
     FillMaterialIdTransparencyData(
-        surfaceData.ior, surfaceData.transmittanceColor, surfaceData.atDistance, surfaceData.thickness, surfaceData.refractionMask,
+        surfaceData.ior, surfaceData.transmittanceColor, surfaceData.atDistance, surfaceData.thickness, surfaceData.transmittanceMask,
         bsdfData);
 #endif
 
     //    a. Get the corresponding color depending on the roughness from the gaussian pyramid of the color buffer
     //    b. Multiply by the transmittance for absorption (depends on the optical depth)
 
-    weight.x = bsdfData.refractionMask;
+    weight.x = bsdfData.transmittanceMask;
 
     float3 refractedBackPointWS = float3(0.0, 0.0, 0.0);
     float opticalDepth = 0.0;

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

     surfaceData.ior = 1.0;
     surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
     surfaceData.atDistance = 1000000.0;
-    surfaceData.refractionMask = 0.0;
+    surfaceData.transmittanceMask = 0.0;
 
     GetNormalWS(input, V, normalTS, surfaceData.normalWS);
     // Use bent normal to sample GI if available

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitDataInternal.hlsl

     surfaceData.atDistance = _ATDistance;
     // Thickness already defined with SSS (from both thickness and thicknessMap)
     surfaceData.thickness *= _ThicknessMultiplier;
-    // Rough refraction don't use opacity. Instead we use opacity as a refraction mask. 
-    surfaceData.refractionMask = alpha;
+    // Rough refraction don't use opacity. Instead we use opacity as a transmittance mask. 
+    surfaceData.transmittanceMask = 1.0 - alpha;
-    surfaceData.refractionMask = 1.0;
+    surfaceData.transmittanceMask = 0.0;
 #endif
 
     surfaceData.coatNormalWS    = input.worldToTangent[2].xyz; // Assign vertex normal
     surfaceData.ior = 1.0;
     surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0);
     surfaceData.atDistance = 1000000.0;
-    surfaceData.refractionMask = 0.0;
+    surfaceData.transmittanceMask = 0.0;
 
 #endif // #if !defined(LAYERED_LIT_SHADER)
 

ScriptableRenderPipeline/HDRenderPipeline/Sky/BlacksmithlSky/BlacksmithSkyRenderer.cs

 
         public override void Build()
         {
-            m_ProceduralSkyMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/Sky/SkyProcedural");
+            m_ProceduralSkyMaterial = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/Sky/SkyBlacksmith");
         }
 
         public override void Cleanup()

ScriptableRenderPipeline/LightweightPipeline/Editor/LegacyShadersToLightweightPipelineUpgrader.cs

 {
     public class LegacyShadersToLightweightPipelineUpgrader
     {
-        [MenuItem("RenderPipeline/LightweightPipeline/Material Upgraders/Upgrade Legacy Materials to LightweightPipeline - Project", false, 3)]
-        public static void UpgradeMaterialsToLDProject()
-        {
-            List<MaterialUpgrader> materialUpgraders = new List<MaterialUpgrader>();
-            GetUpgraders(ref materialUpgraders);
+        //[MenuItem("RenderPipeline/Lightweight Pipeline/Material Upgraders/Upgrade Legacy Materials to LightweightPipeline - Project", false, 3)]
+        //public static void UpgradeMaterialsToLDProject()
+        //{
+        //    List<MaterialUpgrader> materialUpgraders = new List<MaterialUpgrader>();
+        //    GetUpgraders(ref materialUpgraders);
-            MaterialUpgrader.UpgradeProjectFolder(materialUpgraders, "Upgrade to LD Materials");
-        }
+        //    MaterialUpgrader.UpgradeProjectFolder(materialUpgraders, "Upgrade to LD Materials");
+        //}
-        [MenuItem("RenderPipeline/LightweightPipeline/Material Upgraders/Upgrade Legacy Materials to LightweightPipeline - Selection", false, 4)]
-        public static void UpgradeMaterialsToLDSelection()
-        {
-            List<MaterialUpgrader> materialUpgraders = new List<MaterialUpgrader>();
-            GetUpgraders(ref materialUpgraders);
+        //[MenuItem("RenderPipeline/Lightweight Pipeline/Material Upgraders/Upgrade Legacy Materials to LightweightPipeline - Selection", false, 4)]
+        //public static void UpgradeMaterialsToLDSelection()
+        //{
+        //    List<MaterialUpgrader> materialUpgraders = new List<MaterialUpgrader>();
+        //    GetUpgraders(ref materialUpgraders);
-            MaterialUpgrader.UpgradeSelection(materialUpgraders, "Upgrade to Lightweight Materials");
-        }
+        //    MaterialUpgrader.UpgradeSelection(materialUpgraders, "Upgrade to Lightweight Materials");
+        //}
 
         private static void GetUpgraders(ref List<MaterialUpgrader> materialUpgraders)
         {

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightAssetInspector.cs

             public static GUIContent renderingLabel = new GUIContent("Rendering");
             public static GUIContent shadowLabel = new GUIContent("Shadows");
             public static GUIContent defaults = new GUIContent("Defaults");
-            public static GUIContent linearRenderingLabel = new GUIContent("Force Linear Colorspace", "When enabled Lightweight shader will perform gamma to linear conversion in the shader when linear rendering is not supported or disabled");
-            public static GUIContent maxPixelLights = new GUIContent("Per-Object Pixel Lights",
-                    "Max amount of pixel lights.");
+            public static GUIContent maxAdditionalPixelLightsLabel = new GUIContent("Max Additional Pixel Lights",
+                    "Controls the additional per-pixel lights that run in fragment light loop.");
-                    "Lightweight pipeline support at most 4 vertex lights.");
+                    "If enabled, shades additional lights exceeding maxAdditionalPixelLights per-vertex up to the maximum of 8 lights.");
 
             public static GUIContent enableSoftParticles = new GUIContent("Enable Soft Particles", "By enabled this the pipeline will generate depth texture necessary for SoftParticles");
 
                 "Material to use when creating 3D objects");
 
             public static GUIContent defaultParticleMaterial = new GUIContent("Default Particle Material",
-                "Material to use when creating Paticle Systems");
+                "Material to use when creating Particle Systems");
 
             public static GUIContent defaultLineMaterial = new GUIContent("Default Line Material",
                 "Material to use when creating Line Renderers");
             public static GUIContent attenuationTextureLabel = new GUIContent("Attenuation Texture", "Light attenuation falloff texture");
         }
 
-        private int kMaxSupportedPixelLights = 9;
-        private SerializedProperty m_LinearRenderingProperty;
+        private int kMaxSupportedAdditionalPixelLights = 8;
-        private SerializedProperty m_MaxPixelLights;
+        private SerializedProperty m_MaxAdditionalPixelLights;
         private SerializedProperty m_SupportsVertexLightProp;
         private SerializedProperty m_SupportSoftParticlesProp;
         private SerializedProperty m_ShadowTypeProp;
 
         void OnEnable()
         {
-            m_LinearRenderingProperty = serializedObject.FindProperty("m_LinearRendering");
-            m_MaxPixelLights = serializedObject.FindProperty("m_MaxPixelLights");
+            m_MaxAdditionalPixelLights = serializedObject.FindProperty("m_MaxAdditionalPixelLights");
             m_SupportsVertexLightProp = serializedObject.FindProperty("m_SupportsVertexLight");
             m_SupportSoftParticlesProp = serializedObject.FindProperty("m_SupportSoftParticles");
             m_ShadowTypeProp = serializedObject.FindProperty("m_ShadowType");
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(Styles.renderingLabel, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
-            EditorGUILayout.PropertyField(m_LinearRenderingProperty, Styles.linearRenderingLabel);
-            EditorGUILayout.LabelField(Styles.maxPixelLights);
-            m_MaxPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxPixelLights.intValue, 0, kMaxSupportedPixelLights);
+            EditorGUILayout.LabelField(Styles.maxAdditionalPixelLightsLabel);
+            m_MaxAdditionalPixelLights.intValue = EditorGUILayout.IntSlider(m_MaxAdditionalPixelLights.intValue, 0, kMaxSupportedAdditionalPixelLights);
             EditorGUILayout.EndHorizontal();
             EditorGUILayout.PropertyField(m_SupportsVertexLightProp, Styles.enableVertexLightLabel);
             EditorGUILayout.PropertyField(m_SupportSoftParticlesProp, Styles.enableSoftParticles);

ScriptableRenderPipeline/LightweightPipeline/Editor/LightweightPipelineUpgraders.cs

     {
         public StandardUpgrader(string oldShaderName)
         {
-            RenameShader(oldShaderName, LightweightPipelineAsset.m_PBSShaderPath);
+            RenameShader(oldShaderName, LightweightPipelineAsset.m_StandardShaderPath);
         }
     }
 
         {
-            RenameShader(oldShaderName, LightweightPipelineAsset.m_PBSShaderPath);
+            RenameShader(oldShaderName, LightweightPipelineAsset.m_StandardShaderPath);
             SetFloat("_Shininess", 1.0f);
         }
     }

ScriptableRenderPipeline/LightweightPipeline/Editor/StandardToLightweightMaterialUpgrader.cs

 {
     public class StandardToLightweightMaterialUpgrader
     {
-        [MenuItem("RenderPipeline/LightweightPipeline/Material Upgraders/Upgrade Standard Materials to Lightweight Mobile - Project Folder", false, 1)]
+        [MenuItem("RenderPipeline/Lightweight Pipeline/Material Upgraders/Upgrade Project Materials", false, 1)]
-            MaterialUpgrader.UpgradeProjectFolder(upgraders, "Upgrade to LD Materials");
+            MaterialUpgrader.UpgradeProjectFolder(upgraders, "Upgrade to Lightweight Pipeline Materials");
-        [MenuItem("RenderPipeline/LightweightPipeline/Material Upgraders/Upgrade Standard Materials to Lightweight Mobile - Selection", false, 2)]
+        [MenuItem("RenderPipeline/Lightweight Pipeline/Material Upgraders/Upgrade Selected Materials", false, 2)]
-            MaterialUpgrader.UpgradeSelection(upgraders, "Upgrade to LD Materials");
+            MaterialUpgrader.UpgradeSelection(upgraders, "Upgrade to Lightweight Pipeline Materials");
         }
 
         private static void GetUpgraders(ref List<MaterialUpgrader> upgraders)

ScriptableRenderPipeline/LightweightPipeline/LightweightPipeline.cs

 
     public struct LightData
     {
-        public int additionalPixelLightsCount;
-        public int vertexLightsCount;
+        public int pixelAdditionalLightsCount;
+        public int totalAdditionalLightsCount;
-        public bool hasAdditionalLights;
         public bool shadowsRendered;
     }
 
 
-        // Max amount of visible lights. This controls the lights constant buffers in shader but not the max shaded lights.
-        // Lights are set per-object and the max shaded lights for each object are controlled by the max pixel lights in pipeline asset and kMaxVertexLights.
+        // Maximum amount of visible lights the shader can process. This controls the constant global light buffer size.
+        // It must match the MAX_VISIBLE_LIGHTS in LightweightCore.cginc
-        private static readonly int kMaxPerObjectLights = 8;
+
+        // Lights are culled per-object. This holds the maximum amount of additional lights that can shade each object.
+        // The engine fills in the lights indices per-object in unity4_LightIndices0 and unity_4LightIndices1
+        private static readonly int kMaxPerObjectAdditionalLights = 8;
 
         private Vector4[] m_LightPositions = new Vector4[kMaxVisibleAdditionalLights];
         private Vector4[] m_LightColors = new Vector4[kMaxVisibleAdditionalLights];
         private Camera m_CurrCamera = null;
-
-        private ComputeBuffer m_LightIndexListBuffer;
 
         private static readonly int kMaxCascades = 4;
         private int m_ShadowCasterCascadesCount = kMaxCascades;
         public override void Dispose()
         {
             base.Dispose();
-
-            if (m_LightIndexListBuffer != null)
-            {
-                m_LightIndexListBuffer.Dispose();
-                m_LightIndexListBuffer = null;
-            }
         }
 
         CullResults m_CullResults;
             if (m_Asset.AreShadowsEnabled() && lightData.mainLightIndex != -1)
             {
                 VisibleLight mainLight = visibleLights[lightData.mainLightIndex];
+
+                    if (!LightweightUtils.IsSupportedShadowType(mainLight.lightType))
+                    {
+                        Debug.LogWarning("Only directional and spot shadows are supported by LightweightPipeline.");
+                        return;
+                    }
+
-                    int shadowOriginalIndex = (lightData.hasAdditionalLights) ? GetLightUnsortedIndex(lightData.mainLightIndex) : lightData.mainLightIndex;
+                    int shadowOriginalIndex = (lightData.totalAdditionalLightsCount > 0) ? GetLightUnsortedIndex(lightData.mainLightIndex) : lightData.mainLightIndex;
                     lightData.shadowsRendered = RenderShadows(ref m_CullResults, ref mainLight,
                         shadowOriginalIndex, ref context);
                 }
             int visibleLightsCount = visibleLights.Length;
             m_SortedLightIndexMap.Clear();
 
-            // kMaxPerObjectLights + 1 main light
-            int maxSupportedPixelLights = Math.Min(m_Asset.MaxSupportedPixelLights, kMaxPerObjectLights + 1);
-            int maxPixelLights = Math.Min(maxSupportedPixelLights, visibleLightsCount);
-
-            if (maxPixelLights <= 1)
+            lightData.shadowsRendered = false;
+            if (visibleLightsCount <= 1)
-                lightData.mainLightIndex = maxPixelLights - 1;
-                lightData.additionalPixelLightsCount = 0;
+                // If there's exactly one visible light that will be picked as main light.
+                // Otherwise we disable main light by setting its index to -1.
+                lightData.mainLightIndex = visibleLightsCount - 1;
+                lightData.pixelAdditionalLightsCount = 0;
+                lightData.totalAdditionalLightsCount = 0;
+                return;
-            else
-            {
-                lightData.mainLightIndex = SortLights(visibleLights);
-                lightData.additionalPixelLightsCount = maxPixelLights - 1;
-            }
+
+            // We always support at least one per-pixel light, which is main light. Shade objects up to a limit of per-object
+            // pixel lights defined in the pipeline settings.
+            int maxSupportedPixelLights = Math.Min(m_Asset.MaxAdditionalPixelLights, kMaxPerObjectAdditionalLights) + 1;
+            int maxPixelLights = Math.Min(maxSupportedPixelLights, visibleLightsCount);
-            lightData.vertexLightsCount = (m_Asset.SupportsVertexLight) ? Math.Min(4, Math.Min(visibleLightsCount - maxPixelLights, kMaxPerObjectLights)) : 0;
-            lightData.hasAdditionalLights = (lightData.additionalPixelLightsCount + lightData.vertexLightsCount) > 0;
-            lightData.shadowsRendered = false;
+            // If vertex lighting is enabled in the pipeline settings, then we shade the remaining visible lights per-vertex
+            // up to the maximum amount of per-object lights.
+            int vertexLights = (m_Asset.SupportsVertexLight) ? kMaxPerObjectAdditionalLights - maxPixelLights - 1: 0;
+
+            lightData.mainLightIndex = SortLights(visibleLights);
+            lightData.pixelAdditionalLightsCount = maxPixelLights - 1;
+            lightData.totalAdditionalLightsCount = lightData.pixelAdditionalLightsCount + vertexLights;
         }
 
         private int SortLights(VisibleLight[] visibleLights)
             Dictionary<int, int> visibleLightsIDMap = new Dictionary<int, int>();
             for (int i = 0; i < totalVisibleLights; ++i)
-                visibleLightsIDMap.Add(visibleLights[i].light.GetInstanceID(), i);
+                visibleLightsIDMap.Add(visibleLights[i].GetHashCode(), i);
 
             // Sorts light so we have all directionals first, then local lights.
             // Directionals are sorted further by shadow, cookie and intensity
 
             for (int i = 0; i < totalVisibleLights; ++i)
-                m_SortedLightIndexMap.Add(visibleLightsIDMap[visibleLights[i].light.GetInstanceID()]);
+                m_SortedLightIndexMap.Add(visibleLightsIDMap[visibleLights[i].GetHashCode()]);
 
             return GetMainLight(visibleLights);
         }
         private void InitializeLightConstants(VisibleLight[] lights, int lightIndex, out Vector4 lightPos, out Vector4 lightColor, out Vector4 lightSpotDir,
             out Vector4 lightAttenuationParams)
         {
-            lightPos = Vector4.zero;
+            lightPos = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
-            // When no lights are available in the pipeline or maxPixelLights is set to 0
-            // In this case we want to initialize the lightData to default values and return
+            // When no lights are visible, main light will be set to -1.
+            // In this case we initialize it to default values and return
             if (lightIndex < 0)
                 return;
 
                 Vector4 dir = light.localToWorld.GetColumn(2);
                 lightSpotDir = new Vector4(-dir.x, -dir.y, -dir.z, 0.0f);
 
+                // Spot Attenuation with a linear falloff can be defined as
+                // (SdotL - cosOuterAngle) / (cosInnerAngle - cosOuterAngle)
+                // This can be rewritten as
+                // invAngleRange = 1.0 / (cosInnerAngle - cosOuterAngle)
+                // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange)
+                // If we precompute the terms in a MAD instruction
-                float angleRange = cosInneAngle - cosOuterAngle;
-                lightAttenuationParams = new Vector4(cosOuterAngle,
-                    Mathf.Approximately(angleRange, 0.0f) ? 1.0f : angleRange, quadAtten, rangeSq);
+                float smoothAngleRange = cosInneAngle - cosOuterAngle;
+                if (Mathf.Approximately(smoothAngleRange, 0.0f))
+                    smoothAngleRange = 1.0f;
+
+                float invAngleRange = 1.0f / smoothAngleRange;
+                float add = -cosOuterAngle * invAngleRange;
+                lightAttenuationParams = new Vector4(invAngleRange, add, quadAtten, rangeSq);
-                lightAttenuationParams = new Vector4(-1.0f, 1.0f, quadAtten, rangeSq);
+                lightAttenuationParams = new Vector4(0.0f, 1.0f, quadAtten, rangeSq);
             }
         }
 
         {
             // Main light has an optimized shader path for main light. This will benefit games that only care about a single light.
             // Lightweight pipeline also supports only a single shadow light, if available it will be the main light.
-            if (lightData.mainLightIndex != -1)
-            {
-                SetupMainLightConstants (cmd, lights, lightData.mainLightIndex, ref context);
-                if (lightData.shadowsRendered)
-                    SetupShadowShaderConstants (cmd, ref context, ref lights[lightData.mainLightIndex], m_ShadowCasterCascadesCount);
-            }
+            SetupMainLightConstants(cmd, lights, lightData.mainLightIndex, ref context);
+            if (lightData.shadowsRendered)
+                SetupShadowShaderConstants(cmd, ref context, ref lights[lightData.mainLightIndex], m_ShadowCasterCascadesCount);
-            if (lightData.hasAdditionalLights)
+            if (lightData.totalAdditionalLightsCount > 0)
                 SetupAdditionalListConstants(cmd, lights, ref lightData, ref context);
         }
 
             }
             m_CullResults.SetLightIndexMap(perObjectLightIndexMap);
 
-            cmd.SetGlobalVector(PerCameraBuffer._AdditionalLightCount, new Vector4 (lightData.additionalPixelLightsCount, lightData.vertexLightsCount, 0.0f, 0.0f));
+            cmd.SetGlobalVector(PerCameraBuffer._AdditionalLightCount, new Vector4 (lightData.pixelAdditionalLightsCount,
+                 lightData.totalAdditionalLightsCount, 0.0f, 0.0f));
             cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightPosition, m_LightPositions);
             cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightColor, m_LightColors);
             cmd.SetGlobalVectorArray (PerCameraBuffer._AdditionalLightAttenuationParams, m_LightAttenuations);
         {
             Vector3 shadowLightDir = Vector3.Normalize(shadowLight.localToWorld.GetColumn(2));
 
-            float bias = shadowLight.light.shadowBias * 0.1f;
-            float normalBias = shadowLight.light.shadowNormalBias;
+            Light light = shadowLight.light;
+            float bias = light.shadowBias * 0.1f;
+            float normalBias = light.shadowNormalBias;
             float shadowResolution = m_ShadowSlices[0].shadowResolution;
 
             const int maxShadowCascades = 4;
 
         private void SetShaderKeywords(CommandBuffer cmd, ref LightData lightData, VisibleLight[] visibleLights)
         {
-            LightweightUtils.SetKeyword(cmd, "_LIGHTWEIGHT_FORCE_LINEAR", m_Asset.ForceLinearRendering);
-            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", lightData.vertexLightsCount > 0);
-            LightweightUtils.SetKeyword(cmd, "_ATTENUATION_TEXTURE", m_Asset.AttenuationTexture != null);
+            int vertexLightsCount = lightData.totalAdditionalLightsCount - lightData.pixelAdditionalLightsCount;
+            LightweightUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
-            LightweightUtils.SetKeyword (cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex != -1 && visibleLights[mainLightIndex].lightType == LightType.Directional);
+            LightweightUtils.SetKeyword (cmd, "_MAIN_DIRECTIONAL_LIGHT", mainLightIndex == -1 || visibleLights[mainLightIndex].lightType == LightType.Directional);
-            LightweightUtils.SetKeyword(cmd, "_ADDITIONAL_PIXEL_LIGHTS", lightData.additionalPixelLightsCount > 0);
+            LightweightUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);
 
             string[] shadowKeywords = new string[] { "_HARD_SHADOWS", "_SOFT_SHADOWS", "_HARD_SHADOWS_CASCADES", "_SOFT_SHADOWS_CASCADES" };
             for (int i = 0; i < shadowKeywords.Length; ++i)
         RendererConfiguration GetRendererSettings(ref LightData lightData)
         {
             RendererConfiguration settings = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-            if (lightData.hasAdditionalLights)
+            if (lightData.totalAdditionalLightsCount > 0)
                 settings |= RendererConfiguration.PerObjectLightIndices8;
             return settings;
         }

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_Script: {fileID: 11500000, guid: bf2edee5c58d82540a51f03df9d42094, type: 3}
   m_Name: LightweightPipelineAsset
   m_EditorClassIdentifier: 
-  m_MaxPixelLights: 5
-  m_SupportsVertexLight: 1
+  m_MaxAdditionalPixelLights: 4
+  m_SupportsVertexLight: 0
   m_SupportSoftParticles: 1
   m_MSAA: 4
   m_RenderScale: 1
   m_ShadowCascades: 1
   m_Cascade2Split: 0.25
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}
-  m_LinearRendering: 1
   m_AttenuationTexture: {fileID: 2800000, guid: ee420ad43ff580149a07f10ad66c49ff,
     type: 3}
   m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d,

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineAsset.cs

 
     public class LightweightPipelineAsset : RenderPipelineAsset
     {
-        public static readonly string m_SimpleLightShaderPath = "ScriptableRenderPipeline/LightweightPipeline/Standard (Simple Lighting)";
-        public static readonly string m_PBSShaderPath = "ScriptableRenderPipeline/LightweightPipeline/Standard (Simple Lighting)";
-        public static readonly string m_BlitShaderPath = "Hidden/ScriptableRenderPipeline/LightweightPipeline/Blit";
-        public static readonly string m_CopyDephPath = "Hidden/ScriptableRenderPipeline/LightweightPipeline/CopyDepth";
-        private static readonly string m_PipelineFolder = "Assets/ScriptableRenderPipeline/LightweightPipeline";
+        public static readonly string m_SimpleLightShaderPath = "LightweightPipeline/Standard (Simple Lighting)";
+        public static readonly string m_StandardShaderPath = "LightweightPipeline/Standard (Physically Based)";
+        public static readonly string m_BlitShaderPath = "Hidden/LightweightPipeline/Blit";
+        public static readonly string m_CopyDephPath = "Hidden/LightweightPipeline/CopyDepth";
+        private static readonly string m_PipelineFolder = "Assets/LightweightPipeline";
-        [SerializeField] private int m_MaxPixelLights = 1;
+        [SerializeField] private int m_MaxAdditionalPixelLights = 1;
         [SerializeField] private bool m_SupportsVertexLight = true;
         [SerializeField] private bool m_SupportSoftParticles = false;
         [SerializeField] private MSAAQuality m_MSAA = MSAAQuality.Disabled;
         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.NO_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
-        [SerializeField] private bool m_LinearRendering = true;
         [SerializeField] private Texture2D m_AttenuationTexture;
 
         [SerializeField] private Material m_DefaultDiffuseMaterial;
         [SerializeField] private Shader m_DefaultShader;
 
 #if UNITY_EDITOR
-        [UnityEditor.MenuItem("RenderPipeline/LightweightPipeline/Create Pipeline Asset", false, 15)]
+        [UnityEditor.MenuItem("RenderPipeline/Lightweight Pipeline/Create Pipeline Asset", false, 15)]
         static void CreateLightweightPipeline()
         {
             var instance = ScriptableObject.CreateInstance<LightweightPipelineAsset>();
             return ShadowSetting != ShadowType.NO_SHADOW;
         }
 
-        public int MaxSupportedPixelLights
+        public int MaxAdditionalPixelLights
-            get { return m_MaxPixelLights; }
+            get { return m_MaxAdditionalPixelLights; }
         }
 
         public bool SupportsVertexLight
         {
             get { return m_Cascade4Split; }
             private set { m_Cascade4Split = value; }
-        }
-
-        public bool ForceLinearRendering
-        {
-            get { return m_LinearRendering; }
-            set { m_LinearRendering = value; }
         }
 
         public Texture2D AttenuationTexture

ScriptableRenderPipeline/LightweightPipeline/LightweightPipelineUtils.cs

                 if (rhs.lightType == LightType.Directional) return 1;
             }
 
+            // Particle Lights have the Light reference set to null
+            // They are at the end of the priority
+            if (lhsLight == null) return 1;
+            if (rhsLight == null) return -1;
+
             // In the following priority: Soft, Hard, None
             if (lhsLight.shadows != rhsLight.shadows)
                 return (int)rhsLight.shadows - (int)lhsLight.shadows;

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightBlit.shader

-Shader "Hidden/ScriptableRenderPipeline/LightweightPipeline/Blit"
+Shader "Hidden/LightweightPipeline/Blit"
 {
     SubShader
     {

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightCopyDepth.shader

-Shader "Hidden/ScriptableRenderPipeline/LightweightPipeline/CopyDepth"
+Shader "Hidden/LightweightPipeline/CopyDepth"
 {
     SubShader
     {

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightCore.cginc

 #ifndef LIGHTWEIGHT_PIPELINE_CORE_INCLUDED
 #define LIGHTWEIGHT_PIPELINE_CORE_INCLUDED
 
-#include "LightweightInput.cginc"
-#include "LightweightLighting.cginc"
-#include "LightweightShadows.cginc"
+#include "UnityCG.cginc"
+
+#define MAX_VISIBLE_LIGHTS 16
-#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
-#define LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
+#if defined(UNITY_COLORSPACE_GAMMA)
+    #define LIGHTWEIGHT_GAMMA_TO_LINEAR(gammaColor) gammaColor * gammaColor
+    #define LIGHTWEIGHT_LINEAR_TO_GAMMA(linColor) sqrt(color)
+#else
+    #define LIGHTWEIGHT_GAMMA_TO_LINEAR(color) color
+    #define LIGHTWEIGHT_LINEAR_TO_GAMMA(color) color
-#define kDieletricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)
+#ifdef _SPECULAR_SETUP
+    #define SAMPLE_METALLICSPECULAR(uv) tex2D(_SpecGlossMap, uv)
+#else
+    #define SAMPLE_METALLICSPECULAR(uv) tex2D(_MetallicGlossMap, uv)
+#endif
+
+CBUFFER_START(_PerObject)
+half4 unity_LightIndicesOffsetAndCount;
+half4 unity_4LightIndices0;
+half4 unity_4LightIndices1;
+half _Shininess;
+CBUFFER_END
+
+CBUFFER_START(_PerCamera)
+float4 _MainLightPosition;
+half4 _MainLightColor;
+float4 _MainLightAttenuationParams;
+half4 _MainLightSpotDir;
+
+half4 _AdditionalLightCount;
+float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightColor[MAX_VISIBLE_LIGHTS];
+float4 _AdditionalLightAttenuationParams[MAX_VISIBLE_LIGHTS];
+half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
+CBUFFER_END
-half SpecularReflectivity(half3 specular)
+CBUFFER_START(_PerFrame)
+half4 _GlossyEnvironmentColor;
+sampler2D _AttenuationTexture;
+CBUFFER_END
+
+half3 TangentToWorldNormal(half3 normalTangent, half3 tangent, half3 binormal, half3 normal)
-#if (SHADER_TARGET < 30)
-    // SM2.0: instruction count limitation
-    // SM2.0: simplified SpecularStrength
-    return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
+    half3x3 tangentToWorld = half3x3(tangent, binormal, normal);
+    return normalize(mul(normalTangent, tangentToWorld));
+}
+
+float ComputeFogFactor(float z)
+{
+    float clipZ_01 = UNITY_Z_0_FAR_FROM_CLIPSPACE(z);
+
+#if defined(FOG_LINEAR)
+    // factor = (end-z)/(end-start) = z * (-1/(end-start)) + (end/(end-start))
+    float fogFactor = saturate(clipZ_01 * unity_FogParams.z + unity_FogParams.w);
+    return half(fogFactor);
+#elif defined(FOG_EXP)
+    // factor = exp(-density*z)
+    float unityFogFactor = unity_FogParams.y * clipZ_01;
+    return half(saturate(exp2(-unityFogFactor)));
+#elif defined(FOG_EXP2)
+    // factor = exp(-(density*z)^2)
+    float unityFogFactor = unity_FogParams.x * clipZ_01;
+    return half(saturate(exp2(-unityFogFactor*unityFogFactor)));
-    return max(max(specular.r, specular.g), specular.b);
+    return 0.0h;
+#endif
+}
+
+void ApplyFog(inout half3 color, half fogFactor)
+{
+#if defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2)
+    color = lerp(unity_FogColor, color, fogFactor);
+#endif
+}
+
+half4 OutputColor(half3 color, half alpha)
+{
+#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
+    return half4(LIGHTWEIGHT_LINEAR_TO_GAMMA(color), alpha);
+#else
+    return half4(LIGHTWEIGHT_LINEAR_TO_GAMMA(color), 1);
-inline void InitializeSurfaceData(LightweightVertexOutput i, out SurfaceData outSurfaceData)
+inline half Alpha(half albedoAlpha)
-    float2 uv = i.uv01.xy;
-    half4 albedoAlpha = tex2D(_MainTex, uv);
+#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+    half alpha = _Color.a;
+#else
+    half alpha = albedoAlpha * _Color.a;
+#endif
+
+#if defined(_ALPHATEST_ON)
+    clip(alpha - _Cutoff);
+#endif
+
+    return alpha;
+}
-    outSurfaceData.albedo = LIGHTWEIGHT_GAMMA_TO_LINEAR(albedoAlpha.rgb) * _Color.rgb;
-    outSurfaceData.alpha = Alpha(albedoAlpha.a);
-    outSurfaceData.metallicSpecGloss = MetallicSpecGloss(uv, albedoAlpha);
-    outSurfaceData.normalWorld = Normal(i);
-    outSurfaceData.ao = OcclusionLW(uv);
-    outSurfaceData.emission = EmissionLW(uv);
+half3 Normal(float2 uv)
+{
+#if _NORMALMAP
+    return UnpackNormal(tex2D(_BumpMap, uv));
+#else
+    return half3(0.0h, 0.0h, 1.0h);
+#endif
-inline void InitializeBRDFData(SurfaceData surfaceData, out BRDFData outBRDFData)
+inline void SpecularGloss(half2 uv, half alpha, out half4 specularGloss)
-    // BRDF SETUP
-#ifdef _METALLIC_SETUP
-    half2 metallicGloss = surfaceData.metallicSpecGloss.ra;
-    half metallic = metallicGloss.r;
-    half smoothness = metallicGloss.g;
+    specularGloss = half4(0, 0, 0, 1);
+#ifdef _SPECGLOSSMAP
+    specularGloss = tex2D(_SpecGlossMap, uv);
+    specularGloss.rgb = LIGHTWEIGHT_GAMMA_TO_LINEAR(specularGloss.rgb);
+#elif defined(_SPECULAR_COLOR)
+    specularGloss = _SpecColor;
+#endif
+
+#ifdef _GLOSSINESS_FROM_BASE_ALPHA
+    specularGloss.a = alpha;
+#endif
+}
-    // We'll need oneMinusReflectivity, so
-    //   1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
-    // store (1-dielectricSpec) in kDieletricSpec.a, then
-    //   1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) =
-    //                  = alpha - metallic * alpha
-    half oneMinusDielectricSpec = kDieletricSpec.a;
-    half oneMinusReflectivity = oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
-    half reflectivity = 1.0 - oneMinusReflectivity;
+half4 MetallicSpecGloss(float2 uv, half albedoAlpha)
+{
+    half4 specGloss;
-    outBRDFData.diffuse = surfaceData.albedo * oneMinusReflectivity;
-    outBRDFData.specular = lerp(kDieletricSpec.rgb, surfaceData.albedo, metallic);
+#ifdef _METALLICSPECGLOSSMAP
+    specGloss = specGloss = SAMPLE_METALLICSPECULAR(uv);
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    specGloss.a = albedoAlpha * _GlossMapScale;
+#else
+    specGloss.a *= _GlossMapScale;
+#endif
+#else // _METALLICSPECGLOSSMAP
+#if _METALLIC_SETUP
+    specGloss.rgb = _Metallic.rrr;
-    half3 specular = surfaceData.metallicSpecGloss.rgb;
-    half smoothness = surfaceData.metallicSpecGloss.a;
-    half reflectivity = SpecularReflectivity(specular);
+    specGloss.rgb = _SpecColor.rgb;
+#endif
-    outBRDFData.diffuse = surfaceData.albedo * (half3(1.0h, 1.0h, 1.0h) - specular);
-    outBRDFData.specular = specular;
+#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+    specGloss.a = albedoAlpha * _GlossMapScale;
+#else
+    specGloss.a = _Glossiness;
+#endif
-    outBRDFData.grazingTerm = saturate(smoothness + reflectivity);
-    outBRDFData.perceptualRoughness = 1.0h - smoothness;
-    outBRDFData.roughness = outBRDFData.perceptualRoughness * outBRDFData.perceptualRoughness;
+    return specGloss;
+}
-#ifdef _ALPHAPREMULTIPLY_ON
-    half alpha = surfaceData.alpha;
-    outBRDFData.diffuse *= alpha;
-    surfaceData.alpha = reflectivity + alpha * (1.0 - reflectivity);
+half OcclusionLW(float2 uv)
+{
+#ifdef _OCCLUSIONMAP
+    #if (SHADER_TARGET < 30)
+    // SM20: instruction count limitation
+    // SM20: simpler occlusion
+    return tex2D(_OcclusionMap, uv).g;
+#else
+    half occ = tex2D(_OcclusionMap, uv).g;
+    return LerpOneTo(occ, _OcclusionStrength);
+#endif
+#else
+    return 1.0;
-half4 OutputColor(half3 color, half alpha)
+half3 EmissionLW(float2 uv)
-#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
-    return LIGHTWEIGHT_LINEAR_TO_GAMMA(half4(color, alpha));
+#ifndef _EMISSION
+    return 0;
-    return half4(LIGHTWEIGHT_LINEAR_TO_GAMMA(color), 1);
+    return LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, uv).rgb) * _EmissionColor.rgb;
+
 
 
 #endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightLighting.cginc

 #ifndef LIGHTWEIGHT_LIGHTING_INCLUDED
 #define LIGHTWEIGHT_LIGHTING_INCLUDED
 
+#include "LightweightCore.cginc"
+#include "LightweightShadows.cginc"
+
+#define kDieletricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)
+
+// Main light initialized without indexing
+#define INITIALIZE_MAIN_LIGHT(light) \
+    light.pos = _MainLightPosition; \
+    light.color = _MainLightColor; \
+    light.atten = _MainLightAttenuationParams; \
+    light.spotDir = _MainLightSpotDir;
+
+// Indexing might have a performance hit for old mobile hardware
+#define INITIALIZE_LIGHT(light, i) \
+    half4 indices = (i < 4) ? unity_4LightIndices0 : unity_4LightIndices1; \
+    int index = (i < 4) ? i : i - 4; \
+    int lightIndex = indices[index]; \
+    light.pos = _AdditionalLightPosition[lightIndex]; \
+    light.color = _AdditionalLightColor[lightIndex]; \
+    light.atten = _AdditionalLightAttenuationParams[lightIndex]; \
+    light.spotDir = _AdditionalLightSpotDir[lightIndex]
+
+struct LightInput
+{
+    float4 pos;
+    half4 color;
+    float4 atten;
+    half4 spotDir;
+};
+
+struct SurfaceData
+{
+    half3 albedo;
+    half3 specular;
+    half  metallic;
+    half  smoothness;
+    half3 normal;
+    half3 emission;
+    half  occlusion;
+    half  alpha;
+};
+
+struct SurfaceInput
+{
+    float4  lightmapUV;
+    half3   normalWS;
+    half3   tangentWS;
+    half3   bitangentWS;
+    float3  positionWS;
+    half3   viewDirectionWS;
+    half    fogFactor;
+};
+
+struct BRDFData
+{
+    half3 diffuse;
+    half3 specular;
+    half perceptualRoughness;
+    half roughness;
+    half grazingTerm;
+};
+
+inline void InitializeSurfaceData(out SurfaceData outSurfaceData)
+{
+    outSurfaceData.albedo = half3(1.0h, 1.0h, 1.0h);
+    outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
+    outSurfaceData.metallic = 1.0h;
+    outSurfaceData.smoothness = 0.5h;
+    outSurfaceData.normal = half3(0.0h, 0.0h, 1.0h);
+    outSurfaceData.occlusion = 1.0h;
+    outSurfaceData.emission = half3(0.0h, 0.0h, 0.0h);
+    outSurfaceData.alpha = 1.0h;
+}
+
+half SpecularReflectivity(half3 specular)
+{
+#if (SHADER_TARGET < 30)
+    // SM2.0: instruction count limitation
+    // SM2.0: simplified SpecularStrength
+    return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
+#else
+    return max(max(specular.r, specular.g), specular.b);
+#endif
+}
+
+inline void InitializeBRDFData(half3 albedo, half metallic, half3 specular, half smoothness, half alpha, out BRDFData outBRDFData)
+{
+    // BRDF SETUP
+#ifdef _METALLIC_SETUP
+    // We'll need oneMinusReflectivity, so
+    //   1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
+    // store (1-dielectricSpec) in kDieletricSpec.a, then
+    //   1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) =
+    //                  = alpha - metallic * alpha
+    half oneMinusDielectricSpec = kDieletricSpec.a;
+    half oneMinusReflectivity = oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
+    half reflectivity = 1.0 - oneMinusReflectivity;
+
+    outBRDFData.diffuse = albedo * oneMinusReflectivity;
+    outBRDFData.specular = lerp(kDieletricSpec.rgb, albedo, metallic);
+#else
+    half reflectivity = SpecularReflectivity(specular);
+
+    outBRDFData.diffuse = albedo * (half3(1.0h, 1.0h, 1.0h) - specular);
+    outBRDFData.specular = specular;
+#endif
+
+    outBRDFData.grazingTerm = saturate(smoothness + reflectivity);
+    outBRDFData.perceptualRoughness = 1.0h - smoothness;
+    outBRDFData.roughness = outBRDFData.perceptualRoughness * outBRDFData.perceptualRoughness;
+
+#ifdef _ALPHAPREMULTIPLY_ON
+    outBRDFData.diffuse *= alpha;
+    alpha = reflectivity + alpha * (1.0 - reflectivity);
+#endif
+}
 
 // Based on Minimalist CookTorrance BRDF
 // Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
     return c;
 }
 
-UnityIndirect LightweightGI(float2 lightmapUV, half3 ambientColor, half3 normalWorld, half3 reflectVec, half occlusion, half perceptualRoughness)
+UnityIndirect LightweightGI(float4 lightmapUV, half3 normalWorld, half3 reflectVec, half occlusion, half perceptualRoughness)
+
-    ambientColor = (DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, lightmapUV)));
+    o.diffuse += (DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, lightmapUV.xy))) * occlusion;
-    ambientColor += SHEvalLinearL0L1(half4(normalWorld, 1.0));
-    ambientColor = max(half3(0.0, 0.0, 0.0), ambientColor);
+    o.diffuse = ShadeSH9(half4(normalWorld, 1.0)) * occlusion;
-
-    o.diffuse = ambientColor * occlusion;
 
 #ifndef _GLOSSYREFLECTIONS_OFF
     Unity_GlossyEnvironmentData g;
     return o;
 }
 
-inline half ComputeLightAttenuationVertex(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
+half SpotAttenuation(half3 spotDirection, half3 lightDirection, float4 attenuationParams)
+{
+    // Spot Attenuation with a linear falloff can be defined as
+    // (SdotL - cosOuterAngle) / (cosInnerAngle - cosOuterAngle)
+    // This can be rewritten as
+    // invAngleRange = 1.0 / (cosInnerAngle - cosOuterAngle)
+    // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange)
+    // If we precompute the terms in a MAD instruction
+    half SdotL = dot(spotDirection, lightDirection);
+
+    // attenuationParams.x = invAngleRange
+    // attenuationParams.y = (-cosOuterAngle  invAngleRange)
+    return saturate(SdotL * attenuationParams.x + attenuationParams.y);
+}
+
+// In per-vertex falloff there's no smooth falloff to light range. A hard cut will be noticed
+inline half ComputeVertexLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
-    float3 posToLightVec = lightInput.pos - worldPos;
+    float3 posToLightVec = lightInput.pos - worldPos * lightInput.pos.w;
-    //// attenuationParams.z = kQuadFallOff = (25.0) / (lightRange * lightRange)
-    //// attenuationParams.w = lightRange * lightRange
-    //// TODO: we can precompute 1.0 / (attenuationParams.w * 0.64 - attenuationParams.w)
-    //// falloff is computed from 80% light range squared
-    float lightAtten = half(1.0 / (1.0 + distanceSqr * attenuationParams.z));
-
-    half SdotL = saturate(dot(lightInput.spotDir.xyz, lightDirection));
-    lightAtten *= saturate((SdotL - attenuationParams.x) / attenuationParams.y);
-
-    return half(lightAtten);
+    // attenuationParams.z = kQuadFallOff = (25.0) / (lightRange * lightRange)
+    // attenuationParams.w = lightRange * lightRange
+    half lightAtten = half(1.0 / (1.0 + distanceSqr * attenuationParams.z));
+    lightAtten *= SpotAttenuation(lightInput.spotDir.xyz, lightDirection, attenuationParams);
+    return lightAtten;
-inline half ComputeLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
+// In per-pixel falloff attenuation smoothly decreases to light range.
+inline half ComputePixelLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
-
-#ifdef _ATTENUATION_TEXTURE
-    float u = (distanceSqr * attenuationParams.z) / attenuationParams.w;
-    float lightAtten = tex2D(_AttenuationTexture, float2(u, 0.0)).a;
-#else
-    //// attenuationParams.z = kQuadFallOff = (25.0) / (lightRange * lightRange)
-    //// attenuationParams.w = lightRange * lightRange
-    //// TODO: we can precompute 1.0 / (attenuationParams.w * 0.64 - attenuationParams.w)
-    //// falloff is computed from 80% light range squared
-    float lightAtten = half(1.0 / (1.0 + distanceSqr * attenuationParams.z));
-    float falloff = saturate((distanceSqr - attenuationParams.w) / (attenuationParams.w * 0.64 - attenuationParams.w));
-    lightAtten *= half(falloff);
-#endif
-
-    half SdotL = saturate(dot(lightInput.spotDir.xyz, lightDirection));
-    lightAtten *= saturate((SdotL - attenuationParams.x) / attenuationParams.y);
-    return half(lightAtten);
+    float u = (distanceSqr * attenuationParams.z) / attenuationParams.w;
+    half lightAtten = tex2D(_AttenuationTexture, float2(u, 0.0)).a;
+    lightAtten *= SpotAttenuation(lightInput.spotDir.xyz, lightDirection, attenuationParams);
+    return lightAtten;
 }
 
 inline half ComputeMainLightAttenuation(LightInput lightInput, half3 normal, float3 worldPos, out half3 lightDirection)
     lightDirection = lightInput.pos;
     return 1.0;
 #else
-    return ComputeLightAttenuation(lightInput, normal, worldPos, lightDirection);
+    return ComputePixelLightAttenuation(lightInput, normal, worldPos, lightDirection);
 #endif
 }
 
     return (diffuse + specular) * atten;
 }
 
+half4 LightweightFragmentPBR(half4 lightmapUV, float3 positionWS, half3 normalWS, half3 tangentWS, half3 bitangentWS,
+    half3 viewDirectionWS, half fogFactor, half3 albedo, half metallic, half3 specular, half smoothness,
+    half3 normalTS, half ambientOcclusion, half3 emission, half alpha)
+{
+    BRDFData brdfData;
+    InitializeBRDFData(albedo, metallic, specular, smoothness, alpha, brdfData);
+
+    half3 vertexNormal = normalWS;
+#if _NORMALMAP
+    normalWS = TangentToWorldNormal(normalTS, tangentWS, bitangentWS, normalWS);
+#else
+    normalWS = normalize(normalWS);
+#endif
+
+    half3 reflectVec = reflect(-viewDirectionWS, normalWS);
+    half roughness2 = brdfData.roughness * brdfData.roughness;
+    UnityIndirect indirectLight = LightweightGI(lightmapUV, normalWS, reflectVec, ambientOcclusion, brdfData.perceptualRoughness);
+
+    // PBS
+    half fresnelTerm = Pow4(1.0 - saturate(dot(normalWS, viewDirectionWS)));
+    half3 color = LightweightBRDFIndirect(brdfData, indirectLight, roughness2, fresnelTerm);
+    half3 lightDirectionWS;
+
+    LightInput light;
+    INITIALIZE_MAIN_LIGHT(light);
+    half lightAtten = ComputeMainLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
+    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(positionWS, normalize(vertexNormal), _ShadowLightDirection.xyz);
+
+    half NdotL = saturate(dot(normalWS, lightDirectionWS));
+    half3 radiance = light.color * (lightAtten * NdotL);
+    color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
+
+#ifdef _ADDITIONAL_LIGHTS
+    int pixelLightCount = min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);
+    for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
+    {
+        LightInput light;
+        INITIALIZE_LIGHT(light, lightIter);
+        half lightAtten = ComputePixelLightAttenuation(light, normalWS, positionWS, lightDirectionWS);
+
+        half NdotL = saturate(dot(normalWS, lightDirectionWS));
+        half3 radiance = light.color * (lightAtten * NdotL);
+        color += LightweightBDRF(brdfData, roughness2, normalWS, lightDirectionWS, viewDirectionWS) * radiance;
+    }
+#endif
+
+    color += emission;
+
+    // Computes fog factor per-vertex
+    ApplyFog(color, fogFactor);
+    return OutputColor(color, alpha);
+}
 #endif

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightPassLit.cginc

 #ifndef LIGHTWEIGHT_PASS_LIT_INCLUDED
 #define LIGHTWEIGHT_PASS_LIT_INCLUDED
 
-#include "LightweightCore.cginc"
+#include "LightweightLighting.cginc"
+
+struct LightweightVertexInput
+{
+    float4 vertex : POSITION;
+    float3 normal : NORMAL;
+    float4 tangent : TANGENT;
+    float2 texcoord : TEXCOORD0;
+    float2 lightmapUV : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct LightweightVertexOutput
+{
+    float2 uv                       : TEXCOORD0;
+    float4 ambientOrLightmapUV      : TEXCOORD1; // xy: lightmapUV, zw: dynamicLightmapUV OR color from SH
+    float4 posWS                    : TEXCOORD2;
+#if _NORMALMAP
+    half3 tangent                   : TEXCOORD3;
+    half3 binormal                  : TEXCOORD4;
+    half3 normal                    : TEXCOORD5;
+#else
+    half3 normal                    : TEXCOORD3;
+#endif
+    half4 viewDir                   : TEXCOORD6; // xyz: viewDir
+    half4 fogFactorAndVertexLight   : TEXCOORD7; // x: fogFactor, yzw: vertex light
+    float4 clipPos                  : SV_POSITION;
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+inline void InitializeStandardLitSurfaceData(LightweightVertexOutput IN, out SurfaceData outSurfaceData)
+{
+    float2 uv = IN.uv;
+    half4 albedoAlpha = tex2D(_MainTex, uv);
+
+    half4 specGloss = MetallicSpecGloss(uv, albedoAlpha);
+    outSurfaceData.albedo = LIGHTWEIGHT_GAMMA_TO_LINEAR(albedoAlpha.rgb) * _Color.rgb;
+
+#if _METALLIC_SETUP
+    outSurfaceData.metallic = specGloss.r;
+    outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
+#else
+    outSurfaceData.metallic = 1.0h;
+    outSurfaceData.specular = specGloss.rgb;
+#endif
+
+    outSurfaceData.smoothness = specGloss.a;
+    outSurfaceData.normal = Normal(uv);
+    outSurfaceData.occlusion = OcclusionLW(uv);
+    outSurfaceData.emission = EmissionLW(uv);
+    outSurfaceData.emission += IN.fogFactorAndVertexLight.yzw;
+    outSurfaceData.alpha = Alpha(albedoAlpha.a);
+}
+
+void InitializeSurfaceInput(LightweightVertexOutput IN, out SurfaceInput outSurfaceInput)
+{
+#if LIGHTMAP_ON
+    outSurfaceInput.lightmapUV = float4(IN.ambientOrLightmapUV.xy, 0.0, 0.0);
+#else
+    outSurfaceInput.lightmapUV = float4(0.0, 0.0, 0.0, 0.0);
+#endif
+
+#if _NORMALMAP
+    outSurfaceInput.tangentWS = IN.tangent;
+    outSurfaceInput.bitangentWS = IN.binormal;
+#else
+    outSurfaceInput.tangentWS = half3(1.0h, 0.0h, 0.0h);
+    outSurfaceInput.bitangentWS = half3(0.0h, 1.0h, 0.0h);
+#endif
+
+    outSurfaceInput.normalWS = IN.normal;
+    outSurfaceInput.positionWS = IN.posWS;
+    outSurfaceInput.viewDirectionWS = IN.viewDir;
+    outSurfaceInput.fogFactor = IN.fogFactorAndVertexLight.x;
+}
 
 LightweightVertexOutput LitPassVertex(LightweightVertexInput v)
 {
     UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
 
-    o.uv01.xy = TRANSFORM_TEX(v.texcoord, _MainTex);
-#ifdef LIGHTMAP_ON
-    o.uv01.zw = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
-#endif
-    o.hpos = UnityObjectToClipPos(v.vertex);
+    o.uv = TRANSFORM_TEX(v.texcoord, _MainTex);
 
     float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
     o.posWS.xyz = worldPos;
 
 #if _NORMALMAP
     half sign = v.tangent.w * unity_WorldTransformParams.w;
-    half3 tangent = UnityObjectToWorldDir(v.tangent);
-    half3 binormal = cross(normal, tangent) * sign;
-
-    // Initialize tangetToWorld in column-major to benefit from better glsl matrix multiplication code
-    o.tangentToWorld0 = half3(tangent.x, binormal.x, normal.x);
-    o.tangentToWorld1 = half3(tangent.y, binormal.y, normal.y);
-    o.tangentToWorld2 = half3(tangent.z, binormal.z, normal.z);
+    o.tangent = normalize(mul((half3x3)unity_ObjectToWorld, v.tangent.xyz));
+    o.binormal = cross(normal, o.tangent) * sign;
+    o.normal = normal;
-    // TODO: change to only support point lights per vertex. This will greatly simplify shader ALU
-//#if defined(_VERTEX_LIGHTS) && defined(_MULTIPLE_LIGHTS)
-//    half3 diffuse = half3(1.0, 1.0, 1.0);
-//    // pixel lights shaded = min(pixelLights, perObjectLights)
-//    // vertex lights shaded = min(vertexLights, perObjectLights) - pixel lights shaded
-//    // Therefore vertexStartIndex = pixelLightCount;  vertexEndIndex = min(vertexLights, perObjectLights)
-//    int vertexLightStart = min(globalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-//    int vertexLightEnd = min(globalLightCount.y, unity_LightIndicesOffsetAndCount.y);
-//    for (int lightIter = vertexLightStart; lightIter < vertexLightEnd; ++lightIter)
-//    {
-//        int lightIndex = unity_4LightIndices0[lightIter];
-//        LightInput lightInput;
-//        INITIALIZE_LIGHT(lightInput, lightIndex);
-//
-//        half3 lightDirection;
-//        half atten = ComputeLightAttenuationVertex(lightInput, normal, worldPos, lightDirection);
-//        o.fogCoord.yzw += LightingLambert(diffuse, lightDirection, normal, atten);
-//    }
-//#endif
+#ifdef LIGHTMAP_ON
+    o.ambientOrLightmapUV.xy = v.lightmapUV * unity_LightmapST.xy + unity_LightmapST.zw;
+    // TODO: Dynamic Lightmap
+    o.ambientOrLightmapUV.zw = float2(0.0, 0.0);
-#if !defined(LIGHTMAP_ON)
-    o.fogCoord.yzw = SHEvalLinearL2(half4(normal, 1.0));
+    // TODO: Currently there's no way to pass in ambient contribution to fragmentPBR.
+    // We should allow to create custom ambient computation for things like SH evaluation, lightmap, ambient color etc.
+//#else
+//    o.ambientOrLightmapUV = half4(SHEvalLinearL2(half4(normal, 1.0)), 0.0h);
-    UNITY_TRANSFER_FOG(o, o.hpos);
+    o.fogFactorAndVertexLight.yzw = half3(0.0h, 0.0h, 0.0h);
+#if defined(_VERTEX_LIGHTS)
+    half3 diffuse = half3(1.0, 1.0, 1.0);
+    int vertexLightStart = _AdditionalLightCount.x;
+    int vertexLightEnd = min(_AdditionalLightCount.y, unity_LightIndicesOffsetAndCount.y);
+    for (int lightIter = vertexLightStart; lightIter < vertexLightEnd; ++lightIter)
+    {
+        LightInput lightData;
+        INITIALIZE_LIGHT(lightData, lightIter);
+
+        half3 lightDirection;
+        half atten = ComputeVertexLightAttenuation(lightData, normal, worldPos, lightDirection);
+        o.fogFactorAndVertexLight.yzw += LightingLambert(diffuse, lightDirection, normal, atten) * lightData.color;
+    }
+#endif
+
+    float4 clipPos = UnityObjectToClipPos(v.vertex);
+    o.fogFactorAndVertexLight.x = ComputeFogFactor(clipPos.z);
+    o.clipPos = clipPos;
-half4 LitPassFragment(LightweightVertexOutput i) : SV_Target
+half4 LitPassFragment(LightweightVertexOutput IN) : SV_Target
-    InitializeSurfaceData(i, surfaceData);
+    InitializeStandardLitSurfaceData(IN, surfaceData);
-    BRDFData brdfData;
-    InitializeBRDFData(surfaceData, brdfData);
-
-    float2 lightmapUV = i.uv01.zw;
-    half3 normal = surfaceData.normalWorld;
-    half3 reflectVec = reflect(-i.viewDir.xyz, normal);
-    half roughness2 = brdfData.roughness * brdfData.roughness;
-    UnityIndirect indirectLight = LightweightGI(lightmapUV, i.fogCoord.yzw, normal, reflectVec, surfaceData.ao, brdfData.perceptualRoughness);
-
-    // PBS
-    half fresnelTerm = Pow4(1.0 - saturate(dot(normal, i.viewDir.xyz)));
-    half3 color = LightweightBRDFIndirect(brdfData, indirectLight, roughness2, fresnelTerm);
-    half3 lightDirection;
-
-#ifdef _MAIN_LIGHT
-    LightInput light;
-    INITIALIZE_MAIN_LIGHT(light);
-    half lightAtten = ComputeMainLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
-    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(i, _ShadowLightDirection.xyz);
-
-    half NdotL = saturate(dot(normal, lightDirection));
-    half3 radiance = light.color * (lightAtten * NdotL);
-    color += LightweightBDRF(brdfData, roughness2, normal, lightDirection, i.viewDir.xyz) * radiance;
-#endif
-
-#ifdef _ADDITIONAL_PIXEL_LIGHTS
-    int pixelLightCount = min(_AdditionalLightCount.x, unity_LightIndicesOffsetAndCount.y);
-    for (int lightIter = 0; lightIter < pixelLightCount; ++lightIter)
-    {
-        LightInput light;
-        INITIALIZE_LIGHT(light, lightIter);
-        half lightAtten = ComputeLightAttenuation(light, normal, i.posWS.xyz, lightDirection);
-
-        half NdotL = saturate(dot(normal, lightDirection));
-        half3 radiance = light.color * (lightAtten * NdotL);
-        color += LightweightBDRF(brdfData, roughness2, normal, lightDirection, i.viewDir.xyz) * radiance;
-    }
-#endif
+    SurfaceInput surfaceInput;
+    InitializeSurfaceInput(IN, surfaceInput);
-    color += surfaceData.emission;
-    UNITY_APPLY_FOG(i.fogCoord, color);
-    return OutputColor(color, surfaceData.alpha);
+    return LightweightFragmentPBR(surfaceInput.lightmapUV, surfaceInput.positionWS, surfaceInput.normalWS, surfaceInput.tangentWS, surfaceInput.bitangentWS, surfaceInput.viewDirectionWS, surfaceInput.fogFactor, surfaceData.albedo, surfaceData.metallic, surfaceData.specular, surfaceData.smoothness, surfaceData.normal, surfaceData.occlusion, surfaceData.emission, surfaceData.alpha);
-half4 LitPassFragmentSimple(LightweightVertexOutput i) : SV_Target
+half4 LitPassFragmentSimple(LightweightVertexOutput IN) : SV_Target
-    half4 diffuseAlpha = tex2D(_MainTex, i.uv01.xy);
+    float2 uv = IN.uv;
+
+    half4 diffuseAlpha = tex2D(_MainTex, uv);
     half3 diffuse = LIGHTWEIGHT_GAMMA_TO_LINEAR(diffuseAlpha.rgb) * _Color.rgb;
 
 #ifdef _GLOSSINESS_FROM_BASE_ALPHA
     clip(alpha - _Cutoff);
 #endif
 
-    half3 normal = Normal(i);
+#if _NORMALMAP
+    half3 normalTangent = Normal(uv);
+    half3 normalWorld = TangentToWorldNormal(normalTangent, IN.tangent, IN.binormal, IN.normal);
+#else
+    half3 normalWorld = normalize(IN.normal);
+#endif
-    SpecularGloss(i.uv01.xy, alpha, specularGloss);
+    SpecularGloss(uv, alpha, specularGloss);
-    half3 viewDir = i.viewDir.xyz;
-    float3 worldPos = i.posWS.xyz;
+    half3 viewDir = IN.viewDir.xyz;
+    float3 worldPos = IN.posWS.xyz;
-    half3 color = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, i.uv01.zw)) * diffuse;
+    half3 color = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, IN.ambientOrLightmapUV.xy)) * diffuse;
-    half3 color = (SHEvalLinearL0L1(half4(normal, 1.0)) + i.fogCoord.yzw) * diffuse;
+    half3 color = (ShadeSH9(half4(normalWorld, 1.0)) + IN.ambientOrLightmapUV.xyz) * diffuse;
-#ifdef _MAIN_LIGHT
-    half lightAtten = ComputeMainLightAttenuation(lightInput, normal, worldPos, lightDirection);
-    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(i, _ShadowLightDirection.xyz);
+    half lightAtten = ComputeMainLightAttenuation(lightInput, normalWorld, worldPos, lightDirection);
+    lightAtten *= LIGHTWEIGHT_SHADOW_ATTENUATION(worldPos, normalize(IN.normal), _ShadowLightDirection.xyz);
-#ifdef LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
-    color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightInput.color;
+#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
+    color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normalWorld, viewDir, lightAtten) * lightInput.color;
-    color += LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightInput.color;
+    color += LightingLambert(diffuse, lightDirection, normalWorld, lightAtten) * lightInput.color;
-#endif
-
-#ifdef _ADDITIONAL_PIXEL_LIGHTS
+#ifdef _ADDITIONAL_LIGHTS
-        half lightAtten = ComputeLightAttenuation(lightData, normal, worldPos, lightDirection);
+        half lightAtten = ComputePixelLightAttenuation(lightData, normalWorld, worldPos, lightDirection);
-#ifdef LIGHTWEIGHT_SPECULAR_HIGHLIGHTS
-        color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normal, viewDir, lightAtten) * lightData.color;
+#if defined(_SPECGLOSSMAP) || defined(_SPECULAR_COLOR)
+        color += LightingBlinnPhong(diffuse, specularGloss, lightDirection, normalWorld, viewDir, lightAtten) * lightData.color;
-        color += LightingLambert(diffuse, lightDirection, normal, lightAtten) * lightData.color;
+        color += LightingLambert(diffuse, lightDirection, normalWorld, lightAtten) * lightData.color;
-#endif // _ADDITIONAL_PIXEL_LIGHTS
+#endif // _ADDITIONAL_LIGHTS
+
+    color += EmissionLW(uv);
+    color += IN.fogFactorAndVertexLight.yzw;
-    color += EmissionLW(i.uv01.xy);
-    UNITY_APPLY_FOG(i.fogCoord, color);
+    // Computes Fog Factor per vextex
+    ApplyFog(color, IN.fogFactorAndVertexLight.x);
     return OutputColor(color, alpha);
 };
 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightShadows.cginc

 #endif
 
 #ifdef _SHADOWS
-#define LIGHTWEIGHT_SHADOW_ATTENUATION(vertexOutput, shadowDir) ComputeShadowAttenuation(vertexOutput, shadowDir)
+#define LIGHTWEIGHT_SHADOW_ATTENUATION(posWorld, vertexNormal, shadowDir) ComputeShadowAttenuation(posWorld, vertexNormal, shadowDir)
-#define LIGHTWEIGHT_SHADOW_ATTENUATION(vertexOutput, shadowDir) 1.0h
+#define LIGHTWEIGHT_SHADOW_ATTENUATION(posWorld, vertexNormal, shadowDir) 1.0h
 #endif
 
 sampler2D_float _ShadowMap;
     return attenuation * 0.25;
 }
 
-inline half ComputeShadowAttenuation(LightweightVertexOutput i, half3 shadowDir)
+inline half ComputeShadowAttenuation(float3 posWorld, half3 vertexNormal, half3 shadowDir)
-#if _NORMALMAP
-    half3 vertexNormal = half3(i.tangentToWorld0.z, i.tangentToWorld1.z, i.tangentToWorld2.z);
-#else
-    half3 vertexNormal = i.normal;
-#endif
-
-    float3 posWorldOffsetNormal = i.posWS + vertexNormal * bias;
+    float3 posWorldOffsetNormal = posWorld + vertexNormal * bias;
 
     int cascadeIndex = 0;
 #ifdef _SHADOW_CASCADES

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandard.shader

-Shader "ScriptableRenderPipeline/LightweightPipeline/Standard (PBS)"
+Shader "LightweightPipeline/Standard (Physically Based)"
 {
     Properties
     {
             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
             #pragma shader_feature _EMISSION
-            #pragma shader_feature _ _METALLICSPECGLOSSMAP
-            #pragma shader_feature ___ _DETAIL_MULX2
-            #pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-            #pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
-            #pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
-            #pragma shader_feature _ _OCCLUSIONMAP
-            #pragma shader_feature _PARALLAXMAP
+            #pragma shader_feature _METALLICSPECGLOSSMAP
+            #pragma shader_feature _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+            #pragma shader_feature _SPECULARHIGHLIGHTS_OFF
+            #pragma shader_feature _GLOSSYREFLECTIONS_OFF
+            #pragma shader_feature _OCCLUSIONMAP
-            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
-            #pragma multi_compile _ _ADDITIONAL_PIXEL_LIGHTS
-            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _ _ADDITIONAL_LIGHTS
-            #pragma multi_compile _ _ATTENUATION_TEXTURE
 
             #pragma multi_compile_fog
             #pragma multi_compile_instancing
-            #include "UnityCG.cginc"
             #include "UnityStandardInput.cginc"
             #include "LightweightPassLit.cginc"
             ENDCG

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightStandardSimpleLighting.shader

 // Shader targeted for low end devices. Single Pass Forward Rendering. Shader Model 2
-Shader "ScriptableRenderPipeline/LightweightPipeline/Standard (Simple Lighting)"
+Shader "LightweightPipeline/Standard (Simple Lighting)"
 {
     // Keep properties of StandardSpecular shader for upgrade reasons.
     Properties
             #pragma shader_feature _NORMALMAP
             #pragma shader_feature _EMISSION
 
-            #pragma multi_compile _ _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
-            #pragma multi_compile _ _ADDITIONAL_PIXEL_LIGHTS
-            #pragma multi_compile _ _LIGHTWEIGHT_FORCE_LINEAR
+            #pragma multi_compile _MAIN_DIRECTIONAL_LIGHT _MAIN_SPOT_LIGHT _MAIN_POINT_LIGHT
+            #pragma multi_compile _ _ADDITIONAL_LIGHTS
-            #pragma multi_compile _ _ATTENUATION_TEXTURE
-            #include "UnityCG.cginc"
             #include "UnityStandardInput.cginc"
             #include "LightweightPassLit.cginc"
             ENDCG

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightUnlit.shader

-Shader "ScriptableRenderPipeline/LightweightPipeline/Unlit"
+Shader "LightweightPipeline/Unlit"
 {
     Properties
     {

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/Scenes/021_Lighting_BasicPoint.unity

   m_SpotAngle: 30
   m_CookieSize: 10
   m_Shadows:
-    m_Type: 1
+    m_Type: 0
     m_Resolution: -1
     m_CustomResolution: -1
     m_Strength: 1
   maxSmoothness: 1
   applyRangeAttenuation: 1
   useOldInspector: 0
+  featuresFoldout: 1
   showAdditionalSettings: 1
 --- !u!1 &1266012094
 GameObject:

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Lit_Only_2DNoise.mat.meta

-fileFormatVersion: 2
-guid: 83ec3bd906ef2d442ad5caa8ecce9d15
-timeCreated: 1507195204
-licenseType: Pro
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Lit_Only_Ripple.mat

-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!21 &2100000
-Material:
-  serializedVersion: 6
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_Name: Mat_Distorsion_Lit_Only_Ripple
-  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: 3000
-  stringTagMap:
-    RenderType: Transparent
-  disabledShaderPasses:
-  - ForwardOnlyOpaque
-  - ForwardOnlyOpaqueDepthOnly
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs:
-    - _AnisotropyMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BaseColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BentNormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BentNormalMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DistortionVectorMap:
-        m_Texture: {fileID: 8600000, guid: b47c3f363d01c934e91b198a745925eb, type: 2}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _EmissiveColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _HeightMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MaskMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _NormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _NormalMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SpecularColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SubsurfaceRadiusMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _TangentMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _TangentMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _ThicknessMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Floats:
-    - _ATDistance: 1
-    - _AlbedoAffectEmissive: 0
-    - _AlphaCutoff: 0.5
-    - _AlphaCutoffEnable: 0
-    - _Anisotropy: 0
-    - _BlendMode: 0
-    - _CoatCoverage: 1
-    - _CoatIOR: 0.5
-    - _CullMode: 2
-    - _DepthOffsetEnable: 0
-    - _DetailAlbedoScale: 1
-    - _DetailNormalScale: 1
-    - _DetailSmoothnessScale: 1
-    - _DisplacementLockObjectScale: 1
-    - _DisplacementLockTilingScale: 1
-    - _DisplacementMode: 0
-    - _DistortionBlendMode: 0
-    - _DistortionBlendOp: 21
-    - _DistortionBlurBlendMode: 0
-    - _DistortionBlurDstBlend: 1
-    - _DistortionBlurRemapMax: 0.92805755
-    - _DistortionBlurRemapMin: 0
-    - _DistortionBlurScale: 1
-    - _DistortionBlurSrcBlend: 1
-    - _DistortionDepthTest: 1
-    - _DistortionDstBlend: 1
-    - _DistortionEnable: 1
-    - _DistortionNullify: 0
-    - _DistortionOnly: 1
-    - _DistortionScale: 1
-    - _DistortionSrcBlend: 1
-    - _DistortionStencilRef: 4
-    - _DoubleSidedEnable: 0
-    - _DoubleSidedNormalMode: 1
-    - _Drag: 1
-    - _DstBlend: 10
-    - _EmissiveColorMode: 1
-    - _EmissiveIntensity: 0
-    - _EnableBlendModePreserveSpecularLighting: 1
-    - _EnableFogOnTransparent: 1
-    - _EnablePerPixelDisplacement: 0
-    - _EnableSpecularOcclusion: 0
-    - _EnableVertexDisplacement: 0
-    - _EnableWind: 0
-    - _HeightAmplitude: 0.01
-    - _HeightCenter: 0.5
-    - _HeightMax: 1
-    - _HeightMin: -1
-    - _IOR: 1
-    - _InitialBend: 1
-    - _InvTilingScale: 1
-    - _LinkDetailsWithBase: 1
-    - _MaterialID: 1
-    - _Metallic: 0
-    - _NormalMapSpace: 0
-    - _NormalScale: 1
-    - _PPDLodThreshold: 5
-    - _PPDMaxSamples: 15
-    - _PPDMinSamples: 5
-    - _PPDPrimitiveLength: 1
-    - _PPDPrimitiveWidth: 1
-    - _PerPixelDisplacementObjectScale: 1
-    - _PreRefractionPass: 0
-    - _RefractionMode: 0
-    - _ShiverDirectionality: 0.5
-    - _ShiverDrag: 0.2
-    - _Smoothness: 1
-    - _SmoothnessRemapMax: 1
-    - _SmoothnessRemapMin: 0
-    - _SrcBlend: 1
-    - _StencilRef: 2
-    - _Stiffness: 1
-    - _SubsurfaceProfile: 0
-    - _SubsurfaceRadius: 1
-    - _SurfaceType: 1
-    - _TexWorldScale: 1
-    - _Thickness: 1
-    - _ThicknessMultiplier: 1
-    - _UVBase: 0
-    - _UVDetail: 0
-    - _VertexDisplacementObjectScale: 1
-    - _VertexDisplacementTilingScale: 1
-    - _ZTestMode: 4
-    - _ZWrite: 0
-    m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
-    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
-    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
-    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
-    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
-    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
-    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
-    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
-    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Lit_Only_Ripple.mat.meta

-fileFormatVersion: 2
-guid: 12b78618760f1ed418b720ef565ac193
-timeCreated: 1507195204
-licenseType: Pro
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 2100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

SampleScenes/HDTest/GraphicTest/Common/Material/Mat_Distorsion_Lit_Voronoi.mat

-%YAML 1.1
-%TAG !u! tag:unity3d.com,2011:
---- !u!21 &2100000
-Material:
-  serializedVersion: 6
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_Name: Mat_Distorsion_Lit_Voronoi
-  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
-  m_ShaderKeywords: _BLENDMODE_ALPHA _BLENDMODE_PRESERVE_SPECULAR_LIGHTING _ENABLE_FOG_ON_TRANSPARENT
-    _NORMALMAP_TANGENT_SPACE _SURFACE_TYPE_TRANSPARENT
-  m_LightmapFlags: 4
-  m_EnableInstancingVariants: 0
-  m_DoubleSidedGI: 0
-  m_CustomRenderQueue: 3000
-  stringTagMap:
-    RenderType: Transparent
-  disabledShaderPasses:
-  - ForwardOnlyOpaque
-  - ForwardOnlyOpaqueDepthOnly
-  m_SavedProperties:
-    serializedVersion: 3
-    m_TexEnvs:
-    - _AnisotropyMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BaseColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BentNormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BentNormalMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DistortionVectorMap:
-        m_Texture: {fileID: 8600000, guid: 857ebf2cca737d54194a3a1077fec4cc, type: 2}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _EmissiveColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _HeightMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MaskMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _NormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _NormalMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SpecularColorMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _SubsurfaceRadiusMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _TangentMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _TangentMapOS:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _ThicknessMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    m_Floats:
-    - _ATDistance: 1
-    - _AlbedoAffectEmissive: 0
-    - _AlphaCutoff: 0.5
-    - _AlphaCutoffEnable: 0
-    - _Anisotropy: 0
-    - _BlendMode: 0
-    - _CoatCoverage: 1
-    - _CoatIOR: 0.5
-    - _CullMode: 2
-    - _DepthOffsetEnable: 0
-    - _DetailAlbedoScale: 1
-    - _DetailNormalScale: 1
-    - _DetailSmoothnessScale: 1
-    - _DisplacementLockObjectScale: 1
-    - _DisplacementLockTilingScale: 1
-    - _DisplacementMode: 0
-    - _DistortionBlendMode: 0
-    - _DistortionBlendOp: 0
-    - _DistortionBlurBlendMode: 0
-    - _DistortionBlurDstBlend: 1
-    - _DistortionBlurRemapMax: 1
-    - _DistortionBlurRemapMin: 0.097841725
-    - _DistortionBlurScale: 1.5
-    - _DistortionBlurSrcBlend: 1
-    - _DistortionDepthTest: 0
-    - _DistortionDstBlend: 1
-    - _DistortionEnable: 1
-    - _DistortionNullify: 0
-    - _DistortionOnly: 1
-    - _DistortionScale: 200000
-    - _DistortionSrcBlend: 1
-    - _DistortionStencilRef: 4
-    - _DoubleSidedEnable: 0
-    - _DoubleSidedNormalMode: 1
-    - _Drag: 1
-    - _DstBlend: 10
-    - _EmissiveColorMode: 1
-    - _EmissiveIntensity: 0
-    - _EnableBlendModePreserveSpecularLighting: 1
-    - _EnableFogOnTransparent: 1
-    - _EnablePerPixelDisplacement: 0
-    - _EnableSpecularOcclusion: 0
-    - _EnableVertexDisplacement: 0
-    - _EnableWind: 0
-    - _HeightAmplitude: 0.01
-    - _HeightCenter: 0.5
-    - _HeightMax: 1
-    - _HeightMin: -1
-    - _IOR: 1
-    - _InitialBend: 1
-    - _InvTilingScale: 1
-    - _LinkDetailsWithBase: 1
-    - _MaterialID: 1
-    - _Metallic: 0
-    - _NormalMapSpace: 0
-    - _NormalScale: 1
-    - _PPDLodThreshold: 5
-    - _PPDMaxSamples: 15
-    - _PPDMinSamples: 5
-    - _PPDPrimitiveLength: 1
-    - _PPDPrimitiveWidth: 1
-    - _PerPixelDisplacementObjectScale: 1
-    - _PreRefractionPass: 0
-    - _RefractionMode: 0
-    - _ShiverDirectionality: 0.5
-    - _ShiverDrag: 0.2
-    - _Smoothness: 1
-    - _SmoothnessRemapMax: 1
-    - _SmoothnessRemapMin: 0
-    - _SrcBlend: 1
-    - _StencilRef: 2
-    - _Stiffness: 1
-    - _SubsurfaceProfile: 0
-    - _SubsurfaceRadius: 1
-    - _SurfaceType: 1
-    - _TexWorldScale: 1
-    - _Thickness: 1
-    - _ThicknessMultiplier: 1
-    - _UVBase: 0
-    - _UVDetail: 0
-    - _VertexDisplacementObjectScale: 1
-    - _VertexDisplacementTilingScale: 1
-    - _ZTestMode: 8
-    - _ZWrite: 0
-    m_Colors:
-    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
-    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
-    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
-    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
-    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
-    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
-    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
-    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
-    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

SampleScenes/HDTest/GraphicTest/Common/Prefabs/Refraction ThinPlane Clear Dragon.prefab.meta

-fileFormatVersion: 2
-guid: 9281ce26c9326594ebf339a7749d1382
-timeCreated: 1507017860
-licenseType: Pro
-NativeFormatImporter:
-  externalObjects: {}
-  mainObjectFileID: 100100000
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/Editor/GenerateTextures.cs

-using System.IO;
-using UnityEngine;
-using UnityEditor;
-
-public class GenerateTextures : MonoBehaviour
-{
-    private static readonly int kTextureSize = 1024;
-    private static readonly float kQuadraticFac = 25.0f;
-    private static readonly float kToZeroFadeStart = 0.8f * 0.8f;
-    private static readonly string kSavePath = "Assets/ScriptableRenderPipeline/LightweightPipeline/Textures/LightweightLightAttenuation.png";
-
-    [MenuItem("RenderPipeline/LightweightPipeline/GenerateLightFalloffTexture")]
-    public static void GenerateLightFalloffTexture()
-    {
-        Texture2D tex = new Texture2D(kTextureSize, 4, TextureFormat.Alpha8, false, true);
-        tex.wrapMode = TextureWrapMode.Clamp;
-
-        byte[] bytes = new byte[kTextureSize * 4];
-        for (int x = 0; x < kTextureSize; ++x)
-        {
-            float sqrRange = (float) x/(float) kTextureSize;
-            byte atten = LightAttenuationNormalized(sqrRange);
-            bytes[x] = atten;
-            bytes[x + kTextureSize] = atten;
-            bytes[x + kTextureSize * 2] = atten;
-            bytes[x + kTextureSize * 3] = atten;
-        }
-
-        tex.LoadRawTextureData(bytes);
-        tex.Apply(false);
-        SaveTexture(tex);
-    }
-
-    public static void SaveTexture(Texture2D tex)
-    {
-        byte[] bytes = tex.EncodeToPNG();
-        File.WriteAllBytes(kSavePath, bytes);
-    }
-
-    public static byte LightAttenuationNormalized(float distSqr)
-    {
-        // 1 / 1.0 + quadAtten * distSqr attenuation function
-        float atten = 1.0f / (1.0f + CalculateLightQuadFac(1.0f) * distSqr);
-
-        // however the above does not falloff to zero at light range.
-        // Start fading from ktoZeroFadeStart to light range
-        float fadeMultiplier = Mathf.Clamp01((distSqr - 1.0f) / (kToZeroFadeStart - 1.0f));
-        atten *= fadeMultiplier;
-
-        //return atten;
-        return (byte)Mathf.RoundToInt(atten * (float)byte.MaxValue);
-    }
-
-    public static float CalculateLightQuadFac(float range)
-    {
-        return kQuadraticFac / (range * range);
-    }
-}

ScriptableRenderPipeline/LightweightPipeline/Editor/GenerateTextures.cs.meta

-fileFormatVersion: 2
-guid: dd9e613bcee552646a17f8b54e3519de
-timeCreated: 1503914974
-licenseType: Pro
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc.meta

-fileFormatVersion: 2
-guid: 926949d7f34e3e143a1acbf6270e42e0
-timeCreated: 1488965025
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/Shaders/LightweightInput.cginc

-#ifndef LIGHTWEIGHT_INPUT_INCLUDED
-#define LIGHTWEIGHT_INPUT_INCLUDED
-
-#define MAX_VISIBLE_LIGHTS 16
-
-// Main light initialized without indexing
-#define INITIALIZE_MAIN_LIGHT(light) \
-    light.pos = _MainLightPosition; \
-    light.color = _MainLightColor; \
-    light.atten = _MainLightAttenuationParams; \
-    light.spotDir = _MainLightSpotDir;
-
-// Indexing might have a performance hit for old mobile hardware
-#define INITIALIZE_LIGHT(light, i) \
-    half4 indices = (i < 4) ? unity_4LightIndices0 : unity_4LightIndices1; \
-    int index = (i < 4) ? i : i - 4; \
-    int lightIndex = indices[index]; \
-    light.pos = _AdditionalLightPosition[lightIndex]; \
-    light.color = _AdditionalLightColor[lightIndex]; \
-    light.atten = _AdditionalLightAttenuationParams[lightIndex]; \
-    light.spotDir = _AdditionalLightSpotDir[lightIndex]
-
-#if (defined(_MAIN_DIRECTIONAL_LIGHT) || defined(_MAIN_SPOT_LIGHT) || defined(_MAIN_POINT_LIGHT))
-#define _MAIN_LIGHT
-#endif
-
-#ifdef _SPECULAR_SETUP
-#define SAMPLE_METALLICSPECULAR(uv) tex2D(_SpecGlossMap, uv)
-#else
-#define SAMPLE_METALLICSPECULAR(uv) tex2D(_MetallicGlossMap, uv)
-#endif
-
-#if defined(UNITY_COLORSPACE_GAMMA) && defined(_LIGHTWEIGHT_FORCE_LINEAR)
-#define LIGHTWEIGHT_GAMMA_TO_LINEAR(gammaColor) gammaColor * gammaColor
-#define LIGHTWEIGHT_LINEAR_TO_GAMMA(linColor) sqrt(color)
-#else
-#define LIGHTWEIGHT_GAMMA_TO_LINEAR(color) color
-#define LIGHTWEIGHT_LINEAR_TO_GAMMA(color) color
-#endif
-
-struct LightInput
-{
-    float4 pos;
-    half4 color;
-    float4 atten;
-    half4 spotDir;
-};
-
-CBUFFER_START(_PerObject)
-half4 unity_LightIndicesOffsetAndCount;
-half4 unity_4LightIndices0;
-half4 unity_4LightIndices1;
-half _Shininess;
-CBUFFER_END
-
-CBUFFER_START(_PerCamera)
-float4 _MainLightPosition;
-half4 _MainLightColor;
-float4 _MainLightAttenuationParams;
-half4 _MainLightSpotDir;
-
-half4 _AdditionalLightCount;
-float4 _AdditionalLightPosition[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightColor[MAX_VISIBLE_LIGHTS];
-float4 _AdditionalLightAttenuationParams[MAX_VISIBLE_LIGHTS];
-half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
-CBUFFER_END
-
-CBUFFER_START(_PerFrame)
-half4 _GlossyEnvironmentColor;
-sampler2D _AttenuationTexture;
-CBUFFER_END
-
-struct LightweightVertexInput
-{
-    float4 vertex : POSITION;
-    float3 normal : NORMAL;
-    float4 tangent : TANGENT;
-    float2 texcoord : TEXCOORD0;
-    float2 lightmapUV : TEXCOORD1;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-struct LightweightVertexOutput
-{
-    float4 uv01 : TEXCOORD0; // uv01.xy: uv0, uv01.zw: uv1
-    float4 posWS : TEXCOORD1;
-#if _NORMALMAP
-    half3 tangentToWorld0 : TEXCOORD2; // tangentToWorld matrix
-    half3 tangentToWorld1 : TEXCOORD3; // tangentToWorld matrix
-    half3 tangentToWorld2 : TEXCOORD4; // tangentToWorld matrix
-#else
-    half3 normal : TEXCOORD2;
-#endif
-    half4 viewDir : TEXCOORD5; // xyz: viewDir
-    half4 fogCoord : TEXCOORD6; // x: fogCoord, yzw: vertexColor
-    float4 hpos : SV_POSITION;
-    UNITY_VERTEX_OUTPUT_STEREO
-};
-
-struct SurfaceData
-{
-    half3 albedo;
-    half  alpha;
-    half4 metallicSpecGloss;
-    half3 normalWorld;
-    half  ao;
-    half3 emission;
-};
-
-struct BRDFData
-{
-    half3 diffuse;
-    half3 specular;
-    half perceptualRoughness;
-    half roughness;
-    half grazingTerm;
-};
-
-inline half Alpha(half albedoAlpha)
-{
-#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
-    half alpha = _Color.a;
-#else
-    half alpha = albedoAlpha * _Color.a;
-#endif
-
-#if defined(_ALPHATEST_ON)
-    clip(alpha - _Cutoff);
-#endif
-
-    return alpha;
-}
-
-inline half3 Normal(LightweightVertexOutput i)
-{
-    #if _NORMALMAP
-    half3 normalTangent = UnpackNormal(tex2D(_BumpMap, i.uv01.xy));
-
-    // glsl compiler will generate underperforming code by using a row-major pre multiplication matrix: mul(normalmap, i.tangentToWorld)
-    // i.tangetToWorld was initialized as column-major in vs and here dot'ing individual for better performance.
-    // The code below is similar to post multiply: mul(i.tangentToWorld, normalmap)
-    half3 normalWorld = normalize(half3(dot(normalTangent, i.tangentToWorld0), dot(normalTangent, i.tangentToWorld1), dot(normalTangent, i.tangentToWorld2)));
-#else
-    half3 normalWorld = normalize(i.normal);
-#endif
-
-    return normalWorld;
-}
-
-inline void SpecularGloss(half2 uv, half alpha, out half4 specularGloss)
-{
-    specularGloss = half4(0, 0, 0, 1);
-#ifdef _SPECGLOSSMAP
-    specularGloss = tex2D(_SpecGlossMap, uv);
-    specularGloss.rgb = LIGHTWEIGHT_GAMMA_TO_LINEAR(specularGloss.rgb);
-#elif defined(_SPECULAR_COLOR)
-    specularGloss = _SpecColor;
-#endif
-
-#ifdef _GLOSSINESS_FROM_BASE_ALPHA
-    specularGloss.a = alpha;
-#endif
-}
-
-half4 MetallicSpecGloss(float2 uv, half albedoAlpha)
-{
-    half4 specGloss;
-
-#ifdef _METALLICSPECGLOSSMAP
-    specGloss = specGloss = SAMPLE_METALLICSPECULAR(uv);
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    specGloss.a = albedoAlpha * _GlossMapScale;
-#else
-    specGloss.a *= _GlossMapScale;
-#endif
-
-#else // _METALLICSPECGLOSSMAP
-#if _METALLIC_SETUP
-    specGloss.rgb = _Metallic.rrr;
-#else
-    specGloss.rgb = _SpecColor.rgb;
-#endif
-
-#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
-    specGloss.a = albedoAlpha * _GlossMapScale;
-#else
-    specGloss.a = _Glossiness;
-#endif
-#endif
-
-    return specGloss;
-}
-
-half OcclusionLW(float2 uv)
-{
-#ifdef _OCCLUSIONMAP
-    #if (SHADER_TARGET < 30)
-    // SM20: instruction count limitation
-    // SM20: simpler occlusion
-    return tex2D(_OcclusionMap, uv).g;
-#else
-    half occ = tex2D(_OcclusionMap, uv).g;
-    return LerpOneTo(occ, _OcclusionStrength);
-#endif
-#else
-    return 1.0;
-#endif
-}
-
-half3 EmissionLW(float2 uv)
-{
-#ifndef _EMISSION
-    return 0;
-#else
-    return LIGHTWEIGHT_GAMMA_TO_LINEAR(tex2D(_EmissionMap, uv).rgb) * _EmissionColor.rgb;
-#endif
-}
-
-#endif