Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderLoop

# Conflicts:
#	Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

Author: JulienIgnace-Unity

Assets/ScriptableRenderLoop/AdditionalLightData.cs

@@ -1,10 +1,13 @@
 namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
-    //@TODO: We should continously move these values
+    public enum LightArchetype {Punctual, Rectangle, Line};
+
+    //@TODO: We should continuously move these values
     // into the engine when we can see them being generally useful
     [RequireComponent(typeof(Light))]
     public class AdditionalLightData : MonoBehaviour
     {
+
         public const int DefaultShadowResolution = 512;
 
         public int shadowResolution = DefaultShadowResolution;
@@ -31,9 +34,8 @@ public float GetInnerSpotPercent01()
         public bool affectDiffuse = true;
         public bool affectSpecular = true;
 
-        // Area Light Hack
-        public bool treatAsAreaLight = false;
-        public bool isDoubleSided    = false;
+        public LightArchetype archetype = LightArchetype.Punctual;
+        public bool isDoubleSided = false;
 
         [RangeAttribute(0.0f, 20.0f)]
         public float areaLightLength = 0.0f;

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.asset.meta

@@ -50,7 +50,7 @@ public struct LightData
         public int IESIndex;
         public int cookieIndex;
 
-        public GPULightType lightType;        
+        public GPULightType lightType;   
         // Area Light specific
         public Vector2 size;
         public bool twoSided;
@@ -69,7 +69,7 @@ public struct DirectionalLightData
         public float cosAngle; // Distance to disk
         public float sinAngle; // Disk radius
         public int shadowIndex;
-        public float unsued;
+        public float unused;
     };
 
 
@@ -88,6 +88,18 @@ public struct PunctualShadowData
         public float unused;
     };
 
+    [GenerateHLSL]
+    public struct DirectionalShadowData
+    {
+        // World to ShadowMap matrix
+        // Include scale and bias for shadow atlas if any
+        public Matrix4x4 worldToShadow;
+
+        public float bias;
+        public float quality;
+        public Vector2 unused2;
+    };
+
     [GenerateHLSL]
     public enum EnvShapeType
     {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

@@ -60,7 +60,7 @@ struct DirectionalLightData
 	float cosAngle;
 	float sinAngle;
 	int shadowIndex;
-	float unsued;
+	float unused;
 };
 
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.PunctualShadowData
@@ -74,6 +74,16 @@ struct PunctualShadowData
 	float unused;
 };
 
+// Generated from UnityEngine.Experimental.ScriptableRenderLoop.DirectionalShadowData
+// PackingRules = Exact
+struct DirectionalShadowData
+{
+	float4x4 worldToShadow;
+	float bias;
+	float quality;
+	float2 unused2;
+};
+
 // Generated from UnityEngine.Experimental.ScriptableRenderLoop.EnvLightData
 // PackingRules = Exact
 struct EnvLightData
@@ -195,9 +205,9 @@ int GetShadowIndex(DirectionalLightData value)
 {
 	return value.shadowIndex;
 }
-float GetUnsued(DirectionalLightData value)
+float GetUnused(DirectionalLightData value)
 {
-	return value.unsued;
+	return value.unused;
 }
 
 //
@@ -224,6 +234,26 @@ float GetUnused(PunctualShadowData value)
 	return value.unused;
 }
 
+//
+// Accessors for UnityEngine.Experimental.ScriptableRenderLoop.DirectionalShadowData
+//
+float4x4 GetWorldToShadow(DirectionalShadowData value)
+{
+	return value.worldToShadow;
+}
+float GetBias(DirectionalShadowData value)
+{
+	return value.bias;
+}
+float GetQuality(DirectionalShadowData value)
+{
+	return value.quality;
+}
+float2 GetUnused2(DirectionalShadowData value)
+{
+	return value.unused2;
+}
+
 //
 // Accessors for UnityEngine.Experimental.ScriptableRenderLoop.EnvLightData
 //

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs

@@ -23,12 +23,16 @@ string GetKeyword()
             static ComputeBuffer s_EnvLightList;
             static ComputeBuffer s_AreaLightList;
             static ComputeBuffer s_PunctualShadowList;
+            static ComputeBuffer s_DirectionalShadowList;
 
             void ClearComputeBuffers()
             {
                 if (s_DirectionalLights != null)
                     s_DirectionalLights.Release();
 
+                if (s_DirectionalShadowList != null)
+                    s_DirectionalShadowList.Release();
+
                 if (s_PunctualLightList != null)
                     s_PunctualLightList.Release();
 
@@ -47,6 +51,7 @@ public void Rebuild()
                 ClearComputeBuffers();
 
                 s_DirectionalLights = new ComputeBuffer(HDRenderLoop.k_MaxDirectionalLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
+                s_DirectionalShadowList = new ComputeBuffer(HDRenderLoop.k_MaxCascadeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalShadowData)));
                 s_PunctualLightList = new ComputeBuffer(HDRenderLoop.k_MaxPunctualLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 s_AreaLightList = new ComputeBuffer(HDRenderLoop.k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
                 s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
@@ -57,6 +62,8 @@ public void OnDisable()
             {
                 s_DirectionalLights.Release();
                 s_DirectionalLights = null;
+                s_DirectionalShadowList.Release();
+                s_DirectionalShadowList = null;
                 s_PunctualLightList.Release();
                 s_PunctualLightList = null;
                 s_AreaLightList.Release();
@@ -67,23 +74,30 @@ public void OnDisable()
                 s_PunctualShadowList = null;
             }
 
+            public void PrepareLightsForGPU(CullResults cullResults, Camera camera, HDRenderLoop.LightList lightList) {}
+
             public void PushGlobalParams(Camera camera, RenderLoop loop, HDRenderLoop.LightList lightList)
             {
                 s_DirectionalLights.SetData(lightList.directionalLights.ToArray());
+                s_DirectionalShadowList.SetData(lightList.directionalShadows.ToArray());
                 s_PunctualLightList.SetData(lightList.punctualLights.ToArray());
                 s_AreaLightList.SetData(lightList.areaLights.ToArray());
                 s_EnvLightList.SetData(lightList.envLights.ToArray());
                 s_PunctualShadowList.SetData(lightList.punctualShadows.ToArray());
 
                 Shader.SetGlobalBuffer("_DirectionalLightList", s_DirectionalLights);
                 Shader.SetGlobalInt("_DirectionalLightCount", lightList.directionalLights.Count);
+                Shader.SetGlobalBuffer("_DirectionalShadowList", s_DirectionalShadowList);
                 Shader.SetGlobalBuffer("_PunctualLightList", s_PunctualLightList);
                 Shader.SetGlobalInt("_PunctualLightCount", lightList.punctualLights.Count);
                 Shader.SetGlobalBuffer("_AreaLightList", s_AreaLightList);
                 Shader.SetGlobalInt("_AreaLightCount", lightList.areaLights.Count);  
                 Shader.SetGlobalBuffer("_PunctualShadowList", s_PunctualShadowList);
                 Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
-                Shader.SetGlobalInt("_EnvLightCount", lightList.envLights.Count);         
+                Shader.SetGlobalInt("_EnvLightCount", lightList.envLights.Count);
+
+                Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", lightList.directionalShadowSplitSphereSqr);
+                
             }
         }
     }

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs.hlsl

@@ -9,10 +9,11 @@
 
 
 StructuredBuffer<DirectionalLightData>  _DirectionalLightList;
+StructuredBuffer<DirectionalShadowData> _DirectionalShadowList;
 StructuredBuffer<LightData>             _PunctualLightList;
+StructuredBuffer<PunctualShadowData>    _PunctualShadowList;
 StructuredBuffer<LightData>  	        _AreaLightList;
 StructuredBuffer<EnvLightData>          _EnvLightList;
-StructuredBuffer<PunctualShadowData>    _PunctualShadowList;
 
 //TEXTURE2D_ARRAY(_ShadowArray);
 //SAMPLER2D_SHADOW(sampler_ShadowArray);
@@ -43,6 +44,7 @@ CBUFFER_START(UnityPerLightLoop)
     int _EnvLightCount;
     EnvLightData _EnvLightSky;
 	float4 _ShadowMapSize;
+    float4 _DirShadowSplitSpheres[4]; // TODO share this max between C# and hlsl
 CBUFFER_END
 
 struct LightLoopContext
@@ -84,6 +86,51 @@ float GetPunctualShadowAttenuation(LightLoopContext lightLoopContext, float3 pos
 	return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
 }
 
+// Gets the cascade weights based on the world position of the fragment and the positions of the split spheres for each cascade.
+// Returns an invalid split index if past shadowDistance (ie 4 is invalid for cascade)
+uint GetSplitSphereIndexForDirshadows(float3 positionWS, float4 dirShadowSplitSpheres[4])
+{
+    float3 fromCenter0 = positionWS.xyz - dirShadowSplitSpheres[0].xyz;
+    float3 fromCenter1 = positionWS.xyz - dirShadowSplitSpheres[1].xyz;
+    float3 fromCenter2 = positionWS.xyz - dirShadowSplitSpheres[2].xyz;
+    float3 fromCenter3 = positionWS.xyz - dirShadowSplitSpheres[3].xyz;
+    float4 distances2 = float4(dot(fromCenter0, fromCenter0), dot(fromCenter1, fromCenter1), dot(fromCenter2, fromCenter2), dot(fromCenter3, fromCenter3));
+
+    float4 dirShadowSplitSphereSqRadii;
+    dirShadowSplitSphereSqRadii.x = dirShadowSplitSpheres[0].w;
+    dirShadowSplitSphereSqRadii.y = dirShadowSplitSpheres[1].w;
+    dirShadowSplitSphereSqRadii.z = dirShadowSplitSpheres[2].w;
+    dirShadowSplitSphereSqRadii.w = dirShadowSplitSpheres[3].w;
+
+    float4 weights = float4(distances2 < dirShadowSplitSphereSqRadii);
+    weights.yzw = saturate(weights.yzw - weights.xyz);
+
+    return uint(4.0 - dot(weights, float4(4.0, 3.0, 2.0, 1.0)));
+}
+
+float GetDirectionalShadowAttenuation(LightLoopContext lightLoopContext, float3 positionWS, int index, float3 L, float2 unPositionSS)
+{
+    // Note Index is 0 for now, but else we need to provide the correct index in _DirShadowSplitSpheres and _DirectionalShadowList
+    uint shadowSplitIndex = GetSplitSphereIndexForDirshadows(positionWS, _DirShadowSplitSpheres);
+
+    DirectionalShadowData shadowData = _DirectionalShadowList[shadowSplitIndex];
+
+    // Note: scale and bias of shadow atlas are included in ShadowTransform but could be apply here.
+    float4 positionTXS = mul(float4(positionWS, 1.0), shadowData.worldToShadow);
+    positionTXS.xyz /= positionTXS.w;
+    //	positionTXS.z -=  shadowData.bias; // Apply a linear bias
+    positionTXS.z -= 0.003;
+
+#if UNITY_REVERSED_Z
+    positionTXS.z = 1.0 - positionTXS.z;
+#endif
+
+    // float3 shadowPosDX = ddx_fine(positionTXS);
+    // float3 shadowPosDY = ddy_fine(positionTXS);
+
+    return SAMPLE_TEXTURE2D_SHADOW(g_tShadowBuffer, samplerg_tShadowBuffer, positionTXS);
+}
+
 //-----------------------------------------------------------------------------
 // IES sampling function
 // ----------------------------------------------------------------------------

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/SinglePass/SinglePass.cs

@@ -0,0 +1,90 @@
+#ifndef __CLUSTEREDUTILS_H__
+#define __CLUSTEREDUTILS_H__
+
+#ifndef FLT_EPSILON
+    #define FLT_EPSILON     1.192092896e-07f
+#endif
+
+float GetScaleFromBase(float base)
+{
+    const float C = (float)(1 << g_iLog2NumClusters);
+    const float geomSeries = (1.0 - pow(base, C)) / (1 - base);     // geometric series: sum_k=0^{C-1} base^k
+    return geomSeries / (g_fFarPlane - g_fNearPlane);
+}
+
+int SnapToClusterIdxFlex(float z_in, float suggestedBase, bool logBasePerTile)
+{
+#if USE_LEFTHAND_CAMERASPACE
+    float z = z_in;
+#else
+    float z = -z_in;
+#endif
+
+    float userscale = g_fClustScale;
+    if (logBasePerTile)
+        userscale = GetScaleFromBase(suggestedBase);
+
+    // using the inverse of the geometric series
+    const float dist = max(0, z - g_fNearPlane);
+    return (int)clamp(log2(dist * userscale * (suggestedBase - 1.0f) + 1) / log2(suggestedBase), 0.0, (float)((1 << g_iLog2NumClusters) - 1));
+}
+
+int SnapToClusterIdx(float z_in, float suggestedBase)
+{
+#ifdef ENABLE_DEPTH_TEXTURE_BACKPLANE
+    bool logBasePerTile = true;     // resolved compile time
+#else
+    bool logBasePerTile = false;
+#endif
+
+    return SnapToClusterIdxFlex(z_in, suggestedBase, logBasePerTile);
+}
+
+float ClusterIdxToZFlex(int k, float suggestedBase, bool logBasePerTile)
+{
+    float res;
+
+    float userscale = g_fClustScale;
+    if (logBasePerTile)
+        userscale = GetScaleFromBase(suggestedBase);
+
+    float dist = (pow(suggestedBase, (float)k) - 1.0) / (userscale * (suggestedBase - 1.0f));
+    res = dist + g_fNearPlane;
+
+#if USE_LEFTHAND_CAMERASPACE
+    return res;
+#else
+    return -res;
+#endif
+}
+
+float ClusterIdxToZ(int k, float suggestedBase)
+{
+#ifdef ENABLE_DEPTH_TEXTURE_BACKPLANE
+    bool logBasePerTile = true;     // resolved compile time
+#else
+    bool logBasePerTile = false;
+#endif
+
+    return ClusterIdxToZFlex(k, suggestedBase, logBasePerTile);
+}
+
+// generate a log-base value such that half of the clusters are consumed from near plane to max. opaque depth of tile.
+float SuggestLogBase50(float tileFarPlane)
+{
+    const float C = (float)(1 << g_iLog2NumClusters);
+    float normDist = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float suggested_base = pow((1.0 + sqrt(max(0.0, 1.0 - 4.0 * normDist * (1.0 - normDist)))) / (2.0 * normDist), 2.0 / C);      //
+    return max(g_fClustBase, suggested_base);
+}
+
+// generate a log-base value such that (approximately) a quarter of the clusters are consumed from near plane to max. opaque depth of tile.
+float SuggestLogBase25(float tileFarPlane)
+{
+    const float C = (float)(1 << g_iLog2NumClusters);
+    float normDist = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float suggested_base = pow((1 / 2.3) * max(0.0, (0.8 / normDist) - 1), 4.0 / (C * 2));     // approximate inverse of d*x^4 + (-x) + (1-d) = 0       - d is normalized distance
+    return max(g_fClustBase, suggested_base);
+}
+
+#endif