Merge pull request #334 from Unity-Technologies/Repeat-cookie-directional-light

support Repeat cookie for directional light

Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.hlsl

 //
-// This file was automatically generated from Assets/ScriptableRenderPipeline/core/Shadow/ShadowBase.cs.  Please don't edit by hand.
+// This file was automatically generated from Assets/ScriptableRenderPipeline/Core/Shadow/ShadowBase.cs.  Please don't edit by hand.
 //
 
 #ifndef SHADOWBASE_CS_HLSL

Assets/ScriptableRenderPipeline/HDRenderPipeline/AdditionalData/HDAdditionalLightData.cs

         public bool affectSpecular = true;
 
         public LightArchetype archetype = LightArchetype.Punctual;
-        public SpotLightShape spotLightShape = SpotLightShape.Cone;
+        public SpotLightShape spotLightShape = SpotLightShape.Cone; // Note: Only for Spotlight, should be hide for other light
 
         [Range(0.0f, 20.0f)]
         public float lightLength = 0.0f; // Area & projector lights

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

     public struct DirectionalLightData
     {
         public Vector3 positionWS;
-        public float unused;
+        public bool tileCookie;
 
         public Vector3 color;
         public int shadowIndex; // -1 if unused

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

 struct DirectionalLightData
 {
     float3 positionWS;
-    float unused;
+    bool tileCookie;
     float3 color;
     int shadowIndex;
     float3 forward;
 {
 	return value.positionWS;
 }
-float GetUnused(DirectionalLightData value)
+bool GetTileCookie(DirectionalLightData value)
-	return value.unused;
+	return value.tileCookie;
 }
 float3 GetColor(DirectionalLightData value)
 {

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 
             // binding code. This needs to be in sync with ShadowContext.hlsl
             ShadowContext.BindDel binder = (ShadowContext sc, CommandBuffer cb, ComputeShader computeShader, int computeKernel) =>
-                {
+                {
-                    if(computeShader)
-                    {
-                        // bind buffers
-                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowDatasExp", s_ShadowDataBuffer);
-                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowPayloads", s_ShadowPayloadBuffer);
-                        // bind textures
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_0", tex[0]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_1", tex[1]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_2", tex[2]);
-                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_PCF", tex[3]);
+                    if(computeShader)
+                    {
+                        // bind buffers
+                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowDatasExp", s_ShadowDataBuffer);
+                        cb.SetComputeBufferParam(computeShader, computeKernel, "_ShadowPayloads", s_ShadowPayloadBuffer);
+                        // bind textures
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_0", tex[0]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_1", tex[1]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_VSM_2", tex[2]);
+                        cb.SetComputeTextureParam(computeShader, computeKernel, "_ShadowmapExp_PCF", tex[3]);
-                    else
-                    {
-                        // bind buffers
-                        cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
-                        cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
-                        // bind textures
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_0", tex[0]);
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_1", tex[1]);
-                        cb.SetGlobalTexture("_ShadowmapExp_VSM_2", tex[2]);
-                        cb.SetGlobalTexture("_ShadowmapExp_PCF", tex[3]);
+                    else
+                    {
+                        // bind buffers
+                        cb.SetGlobalBuffer("_ShadowDatasExp", s_ShadowDataBuffer);
+                        cb.SetGlobalBuffer("_ShadowPayloads", s_ShadowPayloadBuffer);
+                        // bind textures
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_0", tex[0]);
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_1", tex[1]);
+                        cb.SetGlobalTexture("_ShadowmapExp_VSM_2", tex[2]);
+                        cb.SetGlobalTexture("_ShadowmapExp_PCF", tex[3]);
-                    
+
                     // TODO: Currently samplers are hard coded in ShadowContext.hlsl, so we can't really set them here
                 };
 
 
                 if (light.light.cookie != null)
                 {
+                    directionalLightData.tileCookie = light.light.cookie.wrapMode == TextureWrapMode.Repeat;
                     directionalLightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
                 }
                 // fix up shadow information
 
                 if (m_TileSettings.enableComputeLightEvaluation && outputSplitLighting)
                 {
-                    // The CS is always in the MRT mode. Do not execute the same shader twice.
-                    return;
+                    // The CS is always in the MRT mode. Do not execute the same shader twice.
+                    return;
                 }
 
                 // TODO: To reduce GC pressure don't do concat string here
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "_SkyTexture", skyTexture ? skyTexture : m_DefaultTexture2DArray);
 
                                 // Set SSS parameters.
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_EnableSSSAndTransmission", Shader.GetGlobalInt(       "_EnableSSSAndTransmission"));
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TexturingModeFlags",       Shader.GetGlobalInt(       "_TexturingModeFlags"));
-                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TransmissionFlags",        Shader.GetGlobalInt(       "_TransmissionFlags"));
-                                cmd.SetComputeFloatParams(shadeOpaqueShader, "_ThicknessRemaps",          Shader.GetGlobalFloatArray("_ThicknessRemaps"));
-                                // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
-                                // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
-                                // shader variant for forward, gbuffer and deferred shader. We want to avoid this.
-                                // So for transmittance we use Disney profile formulation (that we know is more correct) in both case, and in the case of Jimenez we hack the parameters with 2-Gaussian parameters (Ideally we should fit but haven't find good fit) so it approximately match.
-                                // Note: Jimenez SSS is in cm unit whereas Disney is in mm unit making an inconsistency here to compare model side by side
-                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ShapeParams",       Shader.GetGlobalVectorArray("_ShapeParams"));
+                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_EnableSSSAndTransmission", Shader.GetGlobalInt(       "_EnableSSSAndTransmission"));
+                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TexturingModeFlags",       Shader.GetGlobalInt(       "_TexturingModeFlags"));
+                                cmd.SetComputeIntParam(   shadeOpaqueShader, "_TransmissionFlags",        Shader.GetGlobalInt(       "_TransmissionFlags"));
+                                cmd.SetComputeFloatParams(shadeOpaqueShader, "_ThicknessRemaps",          Shader.GetGlobalFloatArray("_ThicknessRemaps"));
+                                // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
+                                // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
+                                // shader variant for forward, gbuffer and deferred shader. We want to avoid this.
+                                // So for transmittance we use Disney profile formulation (that we know is more correct) in both case, and in the case of Jimenez we hack the parameters with 2-Gaussian parameters (Ideally we should fit but haven't find good fit) so it approximately match.
+                                // Note: Jimenez SSS is in cm unit whereas Disney is in mm unit making an inconsistency here to compare model side by side
+                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ShapeParams",       Shader.GetGlobalVectorArray("_ShapeParams"));
                                 cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_TransmissionTints", Shader.GetGlobalVectorArray("_TransmissionTints"));
 
                                 cmd.SetComputeTextureParam(shadeOpaqueShader, kernel, "specularLightingUAV", colorBuffers[0]);

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePassLoop.hlsl

             float3 localDiffuseLighting, localSpecularLighting;
 
             EvaluateBSDF_Directional(context, V, posInput, prelightData,
-                                     GPULIGHTTYPE_DIRECTIONAL, _DirectionalLightDatas[i], bsdfData,
+                                     _DirectionalLightDatas[i], bsdfData,
                                      localDiffuseLighting, localSpecularLighting);
 
             diffuseLighting += localDiffuseLighting;
         float3 localDiffuseLighting, localSpecularLighting;
 
         EvaluateBSDF_Directional(context, V, posInput, prelightData,
-                                 GPULIGHTTYPE_DIRECTIONAL, _DirectionalLightDatas[i], bsdfData,
+                                 _DirectionalLightDatas[i], bsdfData,
                                  localDiffuseLighting, localSpecularLighting);
 
         diffuseLighting += localDiffuseLighting;

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 
 void EvaluateBSDF_Directional(LightLoopContext lightLoopContext,
                               float3 V, PositionInputs posInput, PreLightData preLightData,
-                              int lightType, DirectionalLightData lightData, BSDFData bsdfData,
+                              DirectionalLightData lightData, BSDFData bsdfData,
-    // Compute the NDC position (in [-1, 1]^2) by projecting 'positionWS' onto the near plane.
-    // 'lightData.right' and 'lightData.up' are pre-scaled on CPU.
-    float3   lightToSurface = positionWS - lightData.positionWS;
-    float3x3 lightToWorld   = float3x3(lightData.right, lightData.up, lightData.forward);
-    float3   positionLS     = mul(lightToSurface, transpose(lightToWorld));
-    float2   positionNDC    = positionLS.xy;
-
-    // Clip only box projector lights.
-    float clipFactor = 1;
-
-    // Static branch.
-    if (lightType == GPULIGHTTYPE_PROJECTOR_BOX)
-    {
-        bool isInBounds = Max3(abs(positionNDC.x), abs(positionNDC.y), 1 - positionLS.z) <= 1;
-        clipFactor = isInBounds ? 1 : 0;
-    }
-
-    float attenuation = clipFactor;
-
-    float illuminance = saturate(NdotL * attenuation);
+    float illuminance = saturate(NdotL);
 
     diffuseLighting  = float3(0, 0, 0); // TODO: check whether using 'out' instead of 'inout' increases the VGPR pressure
     specularLighting = float3(0, 0, 0); // TODO: check whether using 'out' instead of 'inout' increases the VGPR pressure
 
     [branch] if (lightData.cookieIndex >= 0)
     {
+    	// Compute the NDC position (in [-1, 1]^2) by projecting 'positionWS' onto the near plane.
+    	// 'lightData.right' and 'lightData.up' are pre-scaled on CPU.
+    	float3   lightToSurface = positionWS - lightData.positionWS;
+    	float3x3 lightToWorld   = float3x3(lightData.right, lightData.up, lightData.forward);
+    	float3   positionLS     = mul(lightToSurface, transpose(lightToWorld));
+    	float2   positionNDC    = positionLS.xy;
+
+        float clipFactor = 1.0f;
+
+        if (lightData.tileCookie)
+        {
+            // Tile the texture if the 'repeat' wrap mode is enabled.
+            coord = frac(coord);
+        }
+        else
+        {
+			bool isInBounds = Max3(abs(positionNDC.x), abs(positionNDC.y), 1 - positionLS.z) <= 1;
+        	clipFactor = isInBounds ? 1 : 0;
+        }
+
-        cookie = c.rgb * c.a;
+        cookie = c.rgb * c.a * clipFactor;
     }
 
     [branch] if (illuminance > 0.0)
         // (we reuse the illumination) with the reversed normal of the current sample.
         // We apply wrapped lighting instead of the regular Lambertian diffuse
         // to compensate for these approximations.
-        illuminance = ComputeWrappedDiffuseLighting(NdotL, SSS_WRAP_LIGHT) * attenuation;
+        illuminance = ComputeWrappedDiffuseLighting(NdotL, SSS_WRAP_LIGHT);
 
         // For low thickness, we can reuse the shadowing status for the back of the object.
         shadow       = bsdfData.useThinObjectMode ? shadow : 1;