Merge branch 'LineLights'

Author: EvgeniiG

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

@@ -137,6 +137,7 @@ public void BindBuffers(Material mat)
         public const int k_MaxAreaLightsOnSCreen = 128;
         public const int k_MaxEnvLightsOnSCreen = 64;
         public const int k_MaxShadowOnScreen = 16;
+        public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
 
         [SerializeField]
         TextureSettings m_TextureSettings = TextureSettings.Default;
@@ -157,12 +158,26 @@ public void BindBuffers(Material mat)
         public class LightList
         {
             public List<DirectionalLightData> directionalLights;
+            public List<DirectionalShadowData> directionalShadows;
             public List<LightData> punctualLights;
+            public List<PunctualShadowData> punctualShadows;
             public List<LightData> areaLights;
             public List<EnvLightData> envLights;
-            public List<PunctualShadowData> punctualShadows;            
+            public Vector4[] directionalShadowSplitSphereSqr;
+
+            public void Clear()
+            {
+                directionalLights.Clear();
+                directionalShadows.Clear();
+                punctualLights.Clear();
+                punctualShadows.Clear();
+                areaLights.Clear();
+                envLights.Clear();
+            }
         }
 
+        LightList m_lightList;
+
         // Detect when windows size is changing
         int m_WidthOnRecord;
         int m_HeightOnRecord;
@@ -254,6 +269,15 @@ public override void Rebuild()
             m_SinglePassLightLoop.Rebuild();
             // m_TilePassLightLoop = new TilePass.LightLoop();
             // m_TilePassLightLoop.Rebuild();
+
+            m_lightList = new LightList();
+            m_lightList.directionalLights = new List<DirectionalLightData>();
+            m_lightList.punctualLights = new List<LightData>();
+            m_lightList.areaLights = new List<LightData>();
+            m_lightList.envLights = new List<EnvLightData>();
+            m_lightList.punctualShadows = new List<PunctualShadowData>();
+            m_lightList.directionalShadows = new List<DirectionalShadowData>();
+            m_lightList.directionalShadowSplitSphereSqr = new Vector4[k_MaxCascadeCount];
         }
 
         void OnDisable()
@@ -680,15 +704,9 @@ void FinalPass(RenderLoop renderLoop)
         }
 
         // Function to prepare light structure for GPU lighting
-        void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput, out LightList lightList)
+        void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput, ref LightList lightList)
         {
-            // Init light list
-            lightList = new LightList();
-            lightList.directionalLights = new List<DirectionalLightData>();
-            lightList.punctualLights = new List<LightData>();
-            lightList.areaLights = new List<LightData>();
-            lightList.envLights = new List<EnvLightData>();
-            lightList.punctualShadows = new List<PunctualShadowData>();
+            lightList.Clear();
 
             for (int lightIndex = 0, numLights = cullResults.visibleLights.Length; lightIndex < numLights; ++lightIndex)
             {
@@ -710,7 +728,7 @@ void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput,
 
                 if (light.lightType == LightType.Directional)
                 {
-                    if (lightList.areaLights.Count >= k_MaxDirectionalLightsOnSCreen)
+                    if (lightList.directionalLights.Count >= k_MaxDirectionalLightsOnSCreen)
                         continue;
 
                     var directionalLightData = new DirectionalLightData();
@@ -723,7 +741,32 @@ void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput,
                     directionalLightData.sinAngle = 0.0f;
                     directionalLightData.shadowIndex = -1;
 
-                    // TODO: shadow
+                    bool hasDirectionalShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
+                    bool hasDirectionalNotReachMaxLimit = lightList.directionalShadows.Count == 0; // Only one cascade shadow allowed
+
+                    if (hasDirectionalShadows && hasDirectionalNotReachMaxLimit) // Note  < MaxShadows should be check at shadowOutput creation
+                    {
+                        // When we have a point light, we assumed that there is 6 consecutive PunctualShadowData
+                        directionalLightData.shadowIndex = 0;
+
+                        for (int sliceIndex = 0; sliceIndex < shadowOutput.GetShadowSliceCountLightIndex(lightIndex); ++sliceIndex)
+                        {
+                            DirectionalShadowData directionalShadowData = new DirectionalShadowData();
+
+                            int shadowSliceIndex = shadowOutput.GetShadowSliceIndex(lightIndex, sliceIndex);
+                            directionalShadowData.worldToShadow = shadowOutput.shadowSlices[shadowSliceIndex].shadowTransform.transpose; // Transpose for hlsl reading ?
+
+                            directionalShadowData.bias = light.light.shadowBias;
+
+                            lightList.directionalShadows.Add(directionalShadowData);
+                        }
+
+                        // Fill split information for shaders
+                        for (int s = 0; s < k_MaxCascadeCount; ++s)
+                        {
+                            lightList.directionalShadowSplitSphereSqr[s] = shadowOutput.directionalShadowSplitSphereSqr[s];
+                        }
+                    }
 
                     lightList.directionalLights.Add(directionalLightData);
 
@@ -733,15 +776,22 @@ void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput,
                 // Note: LightType.Area is offline only, use for baking, no need to test it
                 var lightData = new LightData();
 
-                // Early out if we reach the maximum
                 // Test whether we should treat this punctual light as an area light.
                 // It's a temporary hack until the proper UI support is added.
-                if (additionalData.treatAsAreaLight)
+                if (additionalData.archetype != LightArchetype.Punctual)
                 {
+                    // Early out if we reach the maximum
                     if (lightList.areaLights.Count >= k_MaxAreaLightsOnSCreen)
                         continue;
 
-                    lightData.lightType = GPULightType.Rectangle;
+                    if (additionalData.archetype == LightArchetype.Rectangle)
+                    {
+                        lightData.lightType = GPULightType.Rectangle;
+                    }
+                    else
+                    {
+                        lightData.lightType = GPULightType.Line;
+                    }
                 }
                 else
                 {
@@ -831,13 +881,14 @@ void ConvertLightForGPU(CullResults cullResults, ref ShadowOutput shadowOutput,
                 lightData.size = new Vector2(additionalData.areaLightLength, additionalData.areaLightWidth);
                 lightData.twoSided = additionalData.isDoubleSided;
 
-                if (additionalData.treatAsAreaLight)
+                if (additionalData.archetype == LightArchetype.Punctual)
                 {
-                    lightList.areaLights.Add(lightData);
+                    lightList.punctualLights.Add(lightData);
                 }
                 else
                 {
-                    lightList.punctualLights.Add(lightData);
+                    // Area and line lights are both currently stored as area lights on the GPU.
+                    lightList.areaLights.Add(lightData);
                 }
             }
 
@@ -967,9 +1018,8 @@ public override void Render(Camera[] cameras, RenderLoop renderLoop)
 
                     renderLoop.SetupCameraProperties(camera); // Need to recall SetupCameraProperties after m_ShadowPass.Render
 
-                    LightList lightList;
-                    ConvertLightForGPU(cullResults, ref shadows, out lightList);
-                    PushGlobalParams(camera, renderLoop, lightList);
+                    ConvertLightForGPU(cullResults, ref shadows, ref m_lightList);
+                    PushGlobalParams(camera, renderLoop, m_lightList);
 
                     // build per tile light lists
                     //var numLights = 0; // GenerateSourceLightBuffers(camera, cullResults);

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

@@ -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/Lighting/LightDefinition.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.hlsl

@@ -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();
@@ -70,20 +77,24 @@ public void OnDisable()
             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);
+                
             }
         }
     }