Merge pull request #17 from EvgeniiG/master

Add the initial impl. of LTC line light Lambertian diffuse shading

Author: sebastienlagarde

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

@@ -814,8 +814,8 @@ void IntegrateBSDFLineRef(float3 V, float3 positionWS, PreLightData preLightData
     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 float3 p1  = lightData.positionWS - lightData.right * (0.5 * len);
     const float  dt  = len * rcp(sampleCount);
     const float  off = 0.5 * dt;
 
@@ -826,7 +826,7 @@ void IntegrateBSDFLineRef(float3 V, float3 positionWS, PreLightData preLightData
     {
         // Place the sample in the middle of the interval.
         float  t     = off + i * dt;
-        float3 sPos  = p0 + t * dir;
+        float3 sPos  = p1 + t * dir;
         float3 unL   = sPos - positionWS;
         float  dist2 = dot(unL, unL);
         float3 L     = normalize(unL);
@@ -849,7 +849,79 @@ void IntegrateBSDFLineRef(float3 V, float3 positionWS, PreLightData preLightData
 }
 
 //-----------------------------------------------------------------------------
-// EvaluateBSDF_Area
+// EvaluateBSDF_Line | Approximation with Linearly Transformed Cosines
+//-----------------------------------------------------------------------------
+
+void EvaluateBSDF_Line( LightLoopContext lightLoopContext,
+                        float3 V, float3 positionWS, PreLightData preLightData,
+                        LightData lightData, BSDFData bsdfData,
+                        out float3 diffuseLighting, out float3 specularLighting)
+{
+    diffuseLighting  = float3(0.0, 0.0, 0.0);
+    specularLighting = float3(0.0, 0.0, 0.0);
+
+    float  len = lightData.size.x;
+    float3 dir = lightData.right;
+
+    // TODO: precompute half-length. Same as for LTC area lights.
+    // In fact, why not store both endpoints? Saves us 7 cycles.
+    float3 p1 = lightData.positionWS - lightData.right * (0.5 * len);
+    float3 p2 = lightData.positionWS + lightData.right * (0.5 * len);
+
+    // Translate both points s.t. the shaded point is at the origin of the coordinate system.
+    p1 -= positionWS;
+    p2 -= positionWS;
+
+    // Construct an orthonormal basis (local coordinate system) around N.
+    // TODO: it could be stored in PreLightData. All LTC lights compute it more than once!
+    float3x3 basis;
+    basis[0] = normalize(V - bsdfData.normalWS * preLightData.NdotV);
+    basis[1] = normalize(cross(bsdfData.normalWS, basis[0]));
+    basis[2] = bsdfData.normalWS;
+
+    // Transform (rotate) both endpoints into the local coordinate system (left-handed).
+    p1 = mul(p1, transpose(basis));
+    p2 = mul(p2, transpose(basis));
+
+    // Terminate the algorithm if both points are below the horizon.
+    if (p1.z <= 0.0 && p2.z <= 0.0) return;
+
+    if (p2.z <= 0.0)
+    {
+        // Convention: 'p2' is above the horizon.
+        swap(p1, p2);
+        dir = -dir;
+    }
+
+    // Clip the part of the light below the horizon.
+    if (p1.z <= 0.0)
+    {
+        // p = p1 + t * dir; p.z == 0.
+        float t = -p1.z / dir.z;
+        p1 = float3(p1.xy + t * dir.xy, 0.0);
+
+        // Set the length of the visible part of the light.
+        len -= t;
+    }
+
+    // Compute the direction to the point on the line orthogonal to 'dir'.
+    // Its length is the shortest distance to the line.
+    float3 p0   = p1 - dot(p1, dir) * dir;
+    float  dist = length(p0);
+
+    // Compute the parameterization: distances from 'l1' and 'l2' to 'l0'.
+    float l1 = dot(p1 - p0, dir);
+    float l2 = l1 + len;
+
+    // Integrate the clamped cosine over the line segment.
+    float irradiance = LineIrradiance(l1, l2, dist, p0.z, dir.z);
+
+    // Only Lambertian for now. TODO: Disney Diffuse and GGX.
+    diffuseLighting = (lightData.diffuseScale * irradiance * INV_PI) * bsdfData.diffuseColor * lightData.color;
+}
+
+//-----------------------------------------------------------------------------
+// EvaluateBSDF_Area | Approximation with Linearly Transformed Cosines
 //-----------------------------------------------------------------------------
 
 void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
@@ -867,10 +939,17 @@ void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
         IntegrateGGXAreaRef(V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
     }
 #else
+    if (lightData.lightType == GPULIGHTTYPE_LINE)
+    {
+        EvaluateBSDF_Line(lightLoopContext, V, positionWS, preLightData, lightData, bsdfData, diffuseLighting, specularLighting);
+        return;
+    }
+    
     // TODO: This could be precomputed
     float halfWidth  = lightData.size.x * 0.5;
     float halfHeight = lightData.size.y * 0.5;
 
+    // TODO: store 4 points and save 24 cycles.
     float3 p0 = lightData.positionWS + lightData.right * -halfWidth + lightData.up *  halfHeight;
     float3 p1 = lightData.positionWS + lightData.right * -halfWidth + lightData.up * -halfHeight;
     float3 p2 = lightData.positionWS + lightData.right *  halfWidth + lightData.up * -halfHeight;
@@ -929,9 +1008,11 @@ void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
                                              0.0, 1.0, 0.0,
                                              0.0, 0.0, 1.0};
 
-        ltcValue = LTCEvaluate(V, bsdfData.normalWS, identity3x3, L, lightData.twoSided);
+        ltcValue = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+                               identity3x3);
     #else
-        ltcValue = LTCEvaluate(V, bsdfData.normalWS, preLightData.ltcXformDisneyDiffuse, L, lightData.twoSided);
+        ltcValue = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+                               preLightData.ltcXformDisneyDiffuse);
     #endif
 
         if (ltcValue == 0.0)
@@ -953,7 +1034,8 @@ void EvaluateBSDF_Area( LightLoopContext lightLoopContext,
         float3 fresnelTerm = bsdfData.fresnel0 * preLightData.ltcGGXFresnelMagnitudeDiff
                            + (float3)preLightData.ltcGGXFresnelMagnitude;
 
-        ltcValue  = LTCEvaluate(V, bsdfData.normalWS, preLightData.ltcXformGGX, L, lightData.twoSided);
+        ltcValue  = LTCEvaluate(L, V, bsdfData.normalWS, preLightData.NdotV, lightData.twoSided,
+                                preLightData.ltcXformGGX);
         ltcValue *= lightData.specularScale;
         specularLighting = fresnelTerm * lightData.color * ltcValue;
     }

Assets/ScriptableRenderLoop/ShaderLibrary/AreaLighting.hlsl

@@ -163,11 +163,12 @@ float PolygonRadiance(float4x3 L, bool twoSided)
     return twoSided ? abs(sum) : max(sum, 0.0);
 }
 
-float LTCEvaluate(float3 V, float3 N, float3x3 minV, float4x3 L, bool twoSided)
+float LTCEvaluate(float4x3 L, float3 V, float3 N, float NdotV, bool twoSided, float3x3 minV)
 {
     // Construct local orthonormal basis around N, aligned with N
+    // TODO: it could be stored in PreLightData. All LTC lights compute it more than once!
     float3x3 basis;
-    basis[0] = normalize(V - N * dot(V, N));
+    basis[0] = normalize(V - N * NdotV);
     basis[1] = normalize(cross(N, basis[0]));
     basis[2] = N;
 
@@ -179,4 +180,31 @@ float LTCEvaluate(float3 V, float3 N, float3x3 minV, float4x3 L, bool twoSided)
     return PolygonRadiance(L, twoSided);
 }
 
+float LineFpo(float rcpD, float rcpDL, float l)
+{
+    // Compute: l / d / (d * d + l * l) + 1.0 / (d * d) * atan(l / d).
+    return l * rcpDL + rcpD * rcpD * atan(l * rcpD);
+}
+
+float LineFwt(float sqL, float rcpDL)
+{
+    // Compute: l * l / d / (d * d + l * l).
+    return sqL * rcpDL;
+}
+
+// Computes the integral of the clamped cosine over the line segment.
+// 'dist' is the shortest distance to the line. 'l1' and 'l2' define the integration interval.
+float LineIrradiance(float l1, float l2, float dist, float pointZ, float tangentZ)
+{   
+    float sqD    = dist * dist;
+    float sqL1   = l1 * l1;
+    float sqL2   = l2 * l2;
+    float rcpD   = rcp(dist);
+    float rcpDL1 = rcpD * rcp(sqD + sqL1);
+    float rcpDL2 = rcpD * rcp(sqD + sqL2);
+    float intP0  = LineFpo(rcpD, rcpDL2, l2) - LineFpo(rcpD, rcpDL1, l1);
+    float intWt  = LineFwt(sqL2, rcpDL2) - LineFwt(sqL1, rcpDL1);
+    return intP0 * pointZ + intWt * tangentZ;
+}
+
 #endif // UNITY_AREA_LIGHTING_INCLUDED

Assets/ScriptableRenderLoop/ShaderLibrary/Common.hlsl

@@ -128,6 +128,26 @@ float4 Max3(float4 a, float4 b, float4 c)
 }
 #endif // INTRINSIC_MINMAX3
 
+void swap(inout float a, inout float b)
+{
+    float  t = a; a = b; b = t;
+}
+
+void swap(inout float2 a, inout float2 b)
+{
+    float2 t = a; a = b; b = t;
+}
+
+void swap(inout float3 a, inout float3 b)
+{
+    float3 t = a; a = b; b = t;
+}
+
+void swap(inout float4 a, inout float4 b)
+{
+    float4 t = a; a = b; b = t;
+}
+
 #ifndef INTRINSIC_CUBEMAP_FACE_ID
 // TODO: implement this. Is the reference implementation of cubemapID provide by AMD the reverse of our ? 
 /*

Assets/TestScenes/HDTest/HDRenderLoopTest.unity

@@ -2736,10 +2736,10 @@ MonoBehaviour:
   shadowDimmer: 1
   affectDiffuse: 1
   affectSpecular: 1
-  archetype: 0
+  archetype: 2
   isDoubleSided: 1
   areaLightLength: 16
-  areaLightWidth: 2
+  areaLightWidth: 0
 --- !u!108 &710116622
 Light:
   m_ObjectHideFlags: 0
@@ -2888,8 +2888,6 @@ GameObject:
   - component: {fileID: 740109900}
   - component: {fileID: 740109899}
   - component: {fileID: 740109898}
-  - component: {fileID: 740109897}
-  - component: {fileID: 740109896}
   m_Layer: 0
   m_Name: LightQuad
   m_TagString: Untagged
@@ -2910,59 +2908,6 @@ Transform:
   m_Father: {fileID: 710116623}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &740109896
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 740109894}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  shadowResolution: 512
-  shadowDimmer: 1
-  affectDiffuse: 1
-  affectSpecular: 1
-  archetype: 2
-  isDoubleSided: 1
-  areaLightLength: 16
-  areaLightWidth: 2
---- !u!108 &740109897
-Light:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 740109894}
-  m_Enabled: 1
-  serializedVersion: 7
-  m_Type: 2
-  m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 1
-  m_Range: 10
-  m_SpotAngle: 30
-  m_CookieSize: 10
-  m_Shadows:
-    m_Type: 0
-    m_Resolution: -1
-    m_CustomResolution: -1
-    m_Strength: 1
-    m_Bias: 0.05
-    m_NormalBias: 0.4
-    m_NearPlane: 0.2
-  m_Cookie: {fileID: 0}
-  m_DrawHalo: 0
-  m_Flare: {fileID: 0}
-  m_RenderMode: 0
-  m_CullingMask:
-    serializedVersion: 2
-    m_Bits: 4294967295
-  m_Lightmapping: 4
-  m_AreaSize: {x: 1, y: 1}
-  m_BounceIntensity: 1
-  m_ShadowRadius: 0
-  m_ShadowAngle: 0
 --- !u!23 &740109898
 MeshRenderer:
   m_ObjectHideFlags: 0
@@ -3574,7 +3519,7 @@ MonoBehaviour:
   shadowDimmer: 1
   affectDiffuse: 1
   affectSpecular: 1
-  archetype: 0
+  archetype: 1
   isDoubleSided: 1
   areaLightLength: 16
   areaLightWidth: 2
@@ -3791,8 +3736,6 @@ GameObject:
   - component: {fileID: 925222277}
   - component: {fileID: 925222276}
   - component: {fileID: 925222275}
-  - component: {fileID: 925222279}
-  - component: {fileID: 925222278}
   m_Layer: 0
   m_Name: LightQuad
   m_TagString: Untagged
@@ -3866,59 +3809,6 @@ MeshFilter:
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 925222273}
   m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!114 &925222278
-MonoBehaviour:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 925222273}
-  m_Enabled: 1
-  m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
-  m_Name: 
-  m_EditorClassIdentifier: 
-  shadowResolution: 512
-  shadowDimmer: 1
-  affectDiffuse: 1
-  affectSpecular: 1
-  archetype: 1
-  isDoubleSided: 1
-  areaLightLength: 16
-  areaLightWidth: 2
---- !u!108 &925222279
-Light:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 925222273}
-  m_Enabled: 1
-  serializedVersion: 7
-  m_Type: 2
-  m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 1
-  m_Range: 10
-  m_SpotAngle: 30
-  m_CookieSize: 10
-  m_Shadows:
-    m_Type: 0
-    m_Resolution: -1
-    m_CustomResolution: -1
-    m_Strength: 1
-    m_Bias: 0.05
-    m_NormalBias: 0.4
-    m_NearPlane: 0.2
-  m_Cookie: {fileID: 0}
-  m_DrawHalo: 0
-  m_Flare: {fileID: 0}
-  m_RenderMode: 0
-  m_CullingMask:
-    serializedVersion: 2
-    m_Bits: 4294967295
-  m_Lightmapping: 4
-  m_AreaSize: {x: 1, y: 1}
-  m_BounceIntensity: 1
-  m_ShadowRadius: 0
-  m_ShadowAngle: 0
 --- !u!1 &928571527
 GameObject:
   m_ObjectHideFlags: 0