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

Author: sebastienlagarde

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.cs

@@ -776,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
                 {
@@ -874,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);
                 }
             }
 

Assets/ScriptableRenderLoop/HDRenderLoop/Material/Lit/Lit.hlsl

@@ -751,19 +751,25 @@ void IntegrateGGXAreaRef(   float3 V, float3 positionWS, PreLightData preLightDa
 
         float4x4 localToWorld = float4x4(float4(lightData.right, 0.0), float4(lightData.up, 0.0), float4(lightData.forward, 0.0), float4(lightData.positionWS, 1.0));
 
-        if (lightData.lightType == GPULIGHTTYPE_SPHERE)
-            SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-        else if (lightData.lightType == GPULIGHTTYPE_HEMISPHERE)
-            SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-        else if (lightData.lightType == GPULIGHTTYPE_CYLINDER)
-            SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
-        else if (lightData.lightType == GPULIGHTTYPE_RECTANGLE)
-            SampleRectangle(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
-        else if (lightData.lightType == GPULIGHTTYPE_DISK)
-            SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
-        else if (lightData.lightType == GPULIGHTTYPE_LINE)
-            // SampleLine(u, localToWorld, areaLight.lightRadius0, lightPdf, P, Ns);
-            ; // TODO
+        switch (lightData.lightType)
+        {
+            case GPULIGHTTYPE_SPHERE:
+                SampleSphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_HEMISPHERE:
+                SampleHemisphere(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_CYLINDER:
+                SampleCylinder(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_RECTANGLE:
+                SampleRectangle(u, localToWorld, lightData.size.x, lightData.size.y, lightPdf, P, Ns);
+                break;
+            case GPULIGHTTYPE_DISK:
+                SampleDisk(u, localToWorld, lightData.size.x, lightPdf, P, Ns);
+                break;
+            // case GPULIGHTTYPE_LINE: handled by a separate function.
+        }
 
         // Get distance
         float3 unL = P - positionWS;
@@ -795,6 +801,53 @@ void IntegrateGGXAreaRef(   float3 V, float3 positionWS, PreLightData preLightDa
     specularLighting /= float(sampleCount);
 }
 
+//-----------------------------------------------------------------------------
+// EvaluateBSDFLine - Reference
+//-----------------------------------------------------------------------------
+
+void IntegrateBSDFLineRef(float3 V, float3 positionWS, PreLightData preLightData,
+                          LightData lightData, BSDFData bsdfData,
+                          out float3 diffuseLighting, out float3 specularLighting,
+                          int sampleCount = 128)
+{
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    const float  len = lightData.size.x;
+    const float3 p0  = lightData.positionWS - lightData.right * (0.5 * len);
+    const float3 dir = lightData.right;
+    const float  dt  = len * rcp(sampleCount);
+    const float  off = 0.5 * dt;
+
+    // Uniformly sample the line segment with the Pdf = 1 / len.
+    const float invPdf = len;
+
+    for (int i = 0; i < sampleCount; ++i)
+    {
+        // Place the sample in the middle of the interval.
+        float  t     = off + i * dt;
+        float3 sPos  = p0 + t * dir;
+        float3 unL   = sPos - positionWS;
+        float  dist2 = dot(unL, unL);
+        float3 L     = normalize(unL);
+        float  sinLD = length(cross(L, dir));
+        float  NdotL = saturate(dot(bsdfData.normalWS, L));
+
+        float3 lightDiff, lightSpec;
+
+        BSDF(V, L, positionWS, preLightData, bsdfData, lightDiff, lightSpec);
+
+        diffuseLighting  += lightDiff * (sinLD / dist2 * NdotL);
+        specularLighting += lightSpec * (sinLD / dist2 * NdotL);
+    }
+
+    // The factor of 2 is due to the fact: Integral{0, 2 PI}{max(0, cos(x))dx} = 2.
+    float normFactor = 2.0 * invPdf * rcp(sampleCount);
+
+    diffuseLighting  *= normFactor * lightData.diffuseScale  * lightData.color;
+    specularLighting *= normFactor * lightData.specularScale * lightData.color;
+}
+
 //-----------------------------------------------------------------------------
 // EvaluateBSDF_Area
 //-----------------------------------------------------------------------------
@@ -805,7 +858,14 @@ void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
                         out float3 specularLighting)
 {
 #ifdef LIT_DISPLAY_REFERENCE_AREA
-    IntegrateGGXAreaRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+    if (lightData.lightType == GPULIGHTTYPE_LINE)
+    {
+        IntegrateBSDFLineRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+    }
+    else
+    {
+        IntegrateGGXAreaRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+    }
 #else
     // TODO: This could be precomputed
     float halfWidth  = lightData.size.x * 0.5;