Merge pull request #955 from Unity-Technologies/LW-KeywordKilling

Lw keyword killing

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/LightweightLightEditor.cs

 
             ShadowsGUI();
 
+            /* Tim: Disable cookie for v1 to save on shader combinations
             using (var group = new EditorGUILayout.FadeGroupScope(animShowRuntimeOptions.faded))
                 if (group.visible)
                     DrawCookie();
                 if (group.visible)
                     DrawCookieSize();
+           */
 
             settings.DrawRenderMode();
             settings.DrawCullingMask();

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

                 bool shadows = ShadowPass(visibleLights, ref context, ref lightData);
 
                 FrameRenderingConfiguration frameRenderingConfiguration;
-                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, shadows, stereoEnabled);
+                SetupFrameRenderingConfiguration(out frameRenderingConfiguration, shadows, stereoEnabled, sceneViewCamera);
                 SetupIntermediateResources(frameRenderingConfiguration, ref context);
 
                 // SetupCameraProperties does the following:
                         ShadowCollectPass(visibleLights, ref context, ref lightData);
                 }
 
+                if (!shadows)
+                {
+                    var setRT = CommandBufferPool.Get("Generate Small Shadow Buffer");
+                    setRT.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, 4, 4, 0, FilterMode.Bilinear, RenderTextureFormat.R8);
+                    setRT.Blit(Texture2D.whiteTexture, m_ScreenSpaceShadowMapRT);
+                    context.ExecuteCommandBuffer(setRT);
+                }
+
+
+#if UNITY_EDITOR
+                if (sceneViewCamera)
+                    CopyTexture(cmd, CameraRenderTargetID.depth, BuiltinRenderTextureType.CameraTarget, m_CopyDepthMaterial, true);
+#endif
                 cmd.ReleaseTemporaryRT(m_ShadowMapRTID);
                 cmd.ReleaseTemporaryRT(m_ScreenSpaceShadowMapRTID);
                 cmd.ReleaseTemporaryRT(CameraRenderTargetID.depthCopy);
                     // There's no way to map shadow light indices. We need to pass in the original unsorted index.
                     // If no additional lights then no light sorting is performed and the indices match.
                     int shadowOriginalIndex = (lightData.totalAdditionalLightsCount > 0) ? GetLightUnsortedIndex(lightData.mainLightIndex) : lightData.mainLightIndex;
-                    bool shadowsRendered = RenderShadows(ref m_CullResults, ref mainLight,
-                            shadowOriginalIndex, ref context);
+                    bool shadowsRendered = RenderShadows(ref m_CullResults, ref mainLight, shadowOriginalIndex, ref context);
                     if (shadowsRendered)
                     {
                         lightData.shadowMapSampleType = (m_Asset.ShadowSetting != ShadowType.SOFT_SHADOWS)
             }
         }
 
-        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool shadows, bool stereoEnabled)
+        private void SetupFrameRenderingConfiguration(out FrameRenderingConfiguration configuration, bool shadows, bool stereoEnabled, bool sceneViewCamera)
         {
             configuration = (stereoEnabled) ? FrameRenderingConfiguration.Stereo : FrameRenderingConfiguration.None;
             if (stereoEnabled && XRSettings.eyeTextureDesc.dimension == TextureDimension.Tex2DArray)
                         m_RequireCopyColor = true;
                 }
             }
+
+            if (sceneViewCamera)
+                m_RequireDepthTexture = true;
 
             if (shadows)
             {
             int vertexLightsCount = lightData.totalAdditionalLightsCount - lightData.pixelAdditionalLightsCount;
 
             int mainLightIndex = lightData.mainLightIndex;
+            //TIM: Not used in shader for V1 to reduce keywords
+            //TIM: Not used in shader for V1 to reduce keywords
+
+            //TIM: Not used in shader for V1 to reduce keywords
+
+            //TIM: Not used in shader for V1 to reduce keywords
+
             CoreUtils.SetKeyword(cmd, "_ADDITIONAL_LIGHTS", lightData.totalAdditionalLightsCount > 0);
             CoreUtils.SetKeyword(cmd, "_MIXED_LIGHTING_SUBTRACTIVE", m_MixedLightingSetup == MixedLightingSetup.Subtractive);
             CoreUtils.SetKeyword(cmd, "_VERTEX_LIGHTS", vertexLightsCount > 0);
             }
         }
 
-        private void CopyTexture(CommandBuffer cmd, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material copyMaterial)
+        private void CopyTexture(CommandBuffer cmd, RenderTargetIdentifier sourceRT, RenderTargetIdentifier destRT, Material copyMaterial, bool forceBlit = false)
-            if (m_CopyTextureSupport != CopyTextureSupport.None)
+            if (m_CopyTextureSupport != CopyTextureSupport.None && !forceBlit)
                 cmd.CopyTexture(sourceRT, destRT);
             else
                 cmd.Blit(sourceRT, destRT, copyMaterial);

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineUtils.cs

         DepthPrePass = (1 << 4),
         DepthCopy = (1 << 5),
         DefaultViewport = (1 << 6),
-        IntermediateTexture = (1 << 7),
+        IntermediateTexture = (1 << 7)
     }
 
     public static class LightweightUtils

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Lighting.hlsl

 
 half4 GetMainLightDirectionAndAttenuation(LightInput lightInput, float3 positionWS)
 {
-    half4 directionAndAttenuation;
-
-#if defined(_MAIN_LIGHT_DIRECTIONAL)
-    directionAndAttenuation = half4(lightInput.position.xyz, 1.0);
-#else
-    directionAndAttenuation = GetLightDirectionAndAttenuation(lightInput, positionWS);
-#endif
+    half4 directionAndAttenuation = lerp(half4(lightInput.position.xyz, 1.0), GetLightDirectionAndAttenuation(lightInput, positionWS), lightInput.position.w);
 
     // Cookies are only computed for main light
     directionAndAttenuation.w *= CookieAttenuation(positionWS);
 
 void MixRealtimeAndBakedGI(inout Light light, half3 normalWS, inout half3 bakedGI, half4 shadowMask)
 {
-#if defined(_MAIN_LIGHT_DIRECTIONAL) && defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_ON) && defined(_SHADOWS_ENABLED)
-    bakedGI = SubtractDirectMainLightFromLightmap(light, normalWS, bakedGI);
+#if defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_ON) && defined(_SHADOWS_ENABLED)
+    bakedGI = lerp(SubtractDirectMainLightFromLightmap(light, normalWS, bakedGI), bakedGI, _MainLightPosition.w);
 #endif
 
 #if defined(LIGHTMAP_ON)
 
     Light mainLight = GetMainLight(inputData.positionWS);
 
-#ifdef _SHADOWS_ENABLED
-#endif
 
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
     half3 color = GlobalIllumination(brdfData, inputData.bakedGI, occlusion, inputData.normalWS, inputData.viewDirectionWS);
 half4 LightweightFragmentBlinnPhong(InputData inputData, half3 diffuse, half4 specularGloss, half shininess, half3 emission, half alpha)
 {
     Light mainLight = GetMainLight(inputData.positionWS);
-#ifdef _SHADOWS_ENABLED
-#endif
     MixRealtimeAndBakedGI(mainLight, inputData.normalWS, inputData.bakedGI, half4(0, 0, 0, 0));
 
     half3 attenuatedLightColor = mainLight.color * mainLight.attenuation;

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/LightweightPassLit.hlsl

     half3 viewDir                   : TEXCOORD6;
     half4 fogFactorAndVertexLight   : TEXCOORD7; // x: fogFactor, yzw: vertex light
 
-#ifdef _SHADOWS_ENABLED
-#endif
 
     float4 clipPos                  : SV_POSITION;
     UNITY_VERTEX_INPUT_INSTANCE_ID
     inputData.viewDirectionWS = normalize(IN.viewDir);
 #endif
 
-#ifdef _SHADOWS_ENABLED
-#else
-    inputData.shadowCoord = float4(0, 0, 0, 0);
-#endif
 
     inputData.fogCoord = IN.fogFactorAndVertexLight.x;
     inputData.vertexLighting = IN.fogFactorAndVertexLight.yzw;
     half3 vertexLight = VertexLighting(o.posWS, o.normal);
     half fogFactor = ComputeFogFactor(o.clipPos.z);
     o.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
-
-#ifdef _SHADOWS_ENABLED
-    o.shadowCoord = ComputeScreenPos(o.clipPos);
-#endif
+    o.shadowCoord = ComputeShadowCoord(o.clipPos);
 
     return o;
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Shadows.hlsl

 
 inline half SampleScreenSpaceShadowMap(float4 shadowCoord)
 {
-    shadowCoord.xy = shadowCoord.xy / shadowCoord.w;
+    shadowCoord.xy /= shadowCoord.w;
     half attenuation = SAMPLE_TEXTURE2D(_ScreenSpaceShadowMap, sampler_ScreenSpaceShadowMap, shadowCoord.xy).x;
 
     // Apply shadow strength
 inline real SampleShadowmap(float4 shadowCoord)
 {
-    shadowCoord.xyz = shadowCoord.xyz /= shadowCoord.w;
+    shadowCoord.xyz /= shadowCoord.w;
 
     real attenuation;
 
     return 4 - dot(weights, half4(4, 3, 2, 1));
 }
 
-float4 ComputeShadowCoord(float3 positionWS)
+float4 ComputeScreenSpaceShadowCoords(float3 positionWS)
-#ifdef _SHADOWS_CASCADE
+    #ifdef _SHADOWS_CASCADE
+#else
+    return mul(_WorldToShadow[0], float4(positionWS, 1.0));
+}
-    return mul(_WorldToShadow[0], float4(positionWS, 1.0));
+float4 ComputeShadowCoord(float4 clipPos)
+{
+    return ComputeScreenPos(clipPos);
 }
 
 half RealtimeShadowAttenuation(float4 shadowCoord)

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightCopyDepth.shader

 
         Pass
         {
-            ZTest Always ZWrite Off ColorMask 0
+            ZTest Always ZWrite On ColorMask 0
 
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightScreenSpaceShadows.shader

             float3 wpos = mul(unity_CameraToWorld, float4(vpos, 1)).xyz;
             
             //Fetch shadow coordinates for cascade.
-            float4 coords  = ComputeShadowCoord(wpos);
+            float4 coords  = ComputeScreenSpaceShadowCoords(wpos);
 
             return SampleShadowmap(coords);
         }
         Pass
-        {
-            ZTest Always ZWrite Off
+        {           
+            ZTest Always
+            ZWrite Off
+            Cull Off
 
             HLSLPROGRAM
             #pragma multi_compile _ _SHADOWS_SOFT

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
-            #pragma multi_compile _ _SHADOWS_ENABLED
-            #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             //--------------------------------------
             // GPU Instancing
             #pragma multi_compile_instancing
-
-            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
-            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
-            #ifdef DIRLIGHTMAP_COMBINED
-            #define LIGHTMAP_ON
-            #endif
 
             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragment

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
-            #pragma multi_compile _ _SHADOWS_ENABLED
-            #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             //--------------------------------------
             // GPU Instancing
             #pragma multi_compile_instancing
-
-            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
-            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
-            #ifdef DIRLIGHTMAP_COMBINED
-            #define LIGHTMAP_ON
-            #endif
 
             #pragma vertex LitPassVertex
             #pragma fragment LitPassFragmentSimple

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

 
             // -------------------------------------
             // Lightweight Pipeline keywords
-            #pragma multi_compile _MAIN_LIGHT_DIRECTIONAL _MAIN_LIGHT_SPOT
-            #pragma multi_compile _ _SHADOWS_ENABLED
-            #pragma multi_compile _ _MAIN_LIGHT_COOKIE
             #pragma multi_compile _ _ADDITIONAL_LIGHTS
             #pragma multi_compile _ _VERTEX_LIGHTS
             #pragma multi_compile _ _MIXED_LIGHTING_SUBTRACTIVE
             #pragma multi_compile _ LIGHTMAP_ON
 
             #pragma multi_compile __ _TERRAIN_NORMAL_MAP
-
-            // LW doesn't support dynamic GI. So we save 30% shader variants if we assume
-            // LIGHTMAP_ON when DIRLIGHTMAP_COMBINED is set
-            #ifdef DIRLIGHTMAP_COMBINED
-            #define LIGHTMAP_ON
-            #endif
 
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
 
 #endif
                 half4 fogFactorAndVertexLight   : TEXCOORD6; // x: fogFactor, yzw: vertex light
                 float3 positionWS               : TEXCOORD7;
-
-#ifdef _SHADOWS_ENABLED
-                float4 shadowCoord               : TEXCOORD8;
-#endif
-
+                float4 shadowCoord              : TEXCOORD8;
                 float4 clipPos                  : SV_POSITION;
             };
 
 #endif
 
                 input.viewDirectionWS = SafeNormalize(GetCameraPositionWS() - IN.positionWS);
-
-#ifdef _SHADOWS_ENABLED
-#endif
 
                 input.fogCoord = IN.fogFactorAndVertexLight.x;
 
                 o.fogFactorAndVertexLight.yzw = VertexLighting(positionWS, o.normal);
                 o.positionWS = positionWS;
                 o.clipPos = clipPos;
-
-#if defined(_SHADOWS_ENABLED) && !defined(_SHADOWS_CASCADE)
-                o.shadowCoord = ComputeShadowCoord(o.positionWS.xyz);
-#endif
+                o.shadowCoord = ComputeScreenPos(o.clipPos);
 
                 return o;
             }