Merge remote-tracking branch 'origin/Unity-2017.3' into Reorganize-HDRP-GraphicTests

ScriptableRenderPipeline/Core/ShaderLibrary/Fibonacci.hlsl

 // Computes a point using the Fibonacci sequence of length N.
 // Input: Fib[N - 1], Fib[N - 2], and the index 'i' of the point.
 // Ref: Efficient Quadrature Rules for Illumination Integrals
-float2 Fibonacci2dSeq(float fibN1, float fibN2, int i)
+float2 Fibonacci2dSeq(float fibN1, float fibN2, uint i)
 {
     // 3 cycles on GCN if 'fibN1' and 'fibN2' are known at compile time.
     // N.b.: According to Swinbank and Pusser [SP06], the uniformity of the distribution
 #define GOLDEN_RATIO 1.6180339887498948482
 
 // Replaces the Fibonacci sequence in Fibonacci2dSeq() with the Golden ratio.
-float2 Golden2dSeq(int i, float n)
+float2 Golden2dSeq(uint i, float n)
-static const int k_FibonacciSeq[] = {
+static const uint k_FibonacciSeq[] = {
     0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181
 };
 
         case 89: return k_Fibonacci2dSeq89[i];
         default:
         {
-            int fibN1 = sampleCount;
-            int fibN2 = sampleCount;
+            uint fibN1 = sampleCount;
+            uint fibN2 = sampleCount;
-            for (int j = 1; j < 20; j++)
+            for (uint j = 1; j < 20; j++)
             {
                 if (k_FibonacciSeq[j] == fibN1)
                 {

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

 // ----------------------------------------------------------------------------
 
 // Ref: Listing 18 in "Moving Frostbite to PBR" + https://knarkowicz.wordpress.com/2014/12/27/analytical-dfg-term-for-ibl/
-float4 IntegrateGGXAndDisneyFGD(float3 V, float3 N, float roughness, uint sampleCount = 4096)
+float4 IntegrateGGXAndDisneyFGD(float3 V, float3 N, float roughness, uint sampleCount = 8192)
 {
     float NdotV     = saturate(dot(N, V));
     float4 acc      = float4(0.0, 0.0, 0.0, 0.0);
 
         if (NdotL > 0.0)
         {
-            // Integral is
-            //   1 / NumSample * \int[  L * fr * (N.L) / pdf ]  with pdf =  D(H) * (N.H) / (4 * (L.H)) and fr = F(H) * G(V, L) * D(H) / (4 * (N.L) * (N.V))
-            // This is split  in two part:
-            //   A) \int[ L * (N.L) ]
-            //   B) \int[ F(H) * 4 * (N.L) * V(V, L) * (L.H) / (N.H) ] with V(V, L) = G(V, L) / (4 * (N.L) * (N.V))
-            //      = \int[ F(H) * weightOverPdf ]
+            // Integral{BSDF * <N,L> dw} =
+            // Integral{(F0 + (1 - F0) * (1 - <V,H>)^5) * (BSDF / F) * <N,L> dw} =
+            // F0 * Integral{(BSDF / F) * <N,L> dw} +
+            // (1 - F0) * Integral{(1 - <V,H>)^5 * (BSDF / F) * <N,L> dw} =
+            // (1 - F0) * x + F0 * y = lerp(x, y, F0)
-            // Recombine at runtime with: ( f0 * weightOverPdf * (1 - Fc) + f90 * weightOverPdf * Fc ) with Fc =(1 - V.H)^5
-            float Fc            = pow(1.0 - VdotH, 5.0);
-            acc.x               += (1.0 - Fc) * weightOverPdf;
-            acc.y               += Fc * weightOverPdf;
+            acc.x += weightOverPdf * pow(1 - VdotH, 5);
+            acc.y += weightOverPdf;
         }
 
         // for Disney we still use a Cosine importance sampling, true Disney importance sampling imply a look up table
         {
-            float3 H = normalize(L + V);
-            float LdotH = dot(L, H);
-            float disneyDiffuse = DisneyDiffuseNoPI(NdotV, NdotL, LdotH, RoughnessToPerceptualRoughness(roughness));
+            float LdotV = dot(L, V);
+            float disneyDiffuse = DisneyDiffuseNoPI(NdotV, NdotL, LdotV, RoughnessToPerceptualRoughness(roughness));
+
+    // Remap from [0, 1.5] to [0, 1] range.
+    acc.z /= 1.5;
 
     return acc / sampleCount;
 }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Editor/HDLightEditor.Styles.cs

             public readonly GUIContent shapeLengthLine = new GUIContent("Length", "Length of the line light");
             public readonly GUIContent shapeLengthRect = new GUIContent("Size X", "SizeX of the rectangle light");
             public readonly GUIContent shapeWidthRect = new GUIContent("Size Y", "SizeY of the rectangle light");
-            public readonly GUIContent shapeLengthPyramid = new GUIContent("Size X", "");
-            public readonly GUIContent shapeWidthPyramid = new GUIContent("Size Y", "");
+            public readonly GUIContent aspectRatioPyramid = new GUIContent("Aspect ratio", "");
             public readonly GUIContent shapeLengthBox = new GUIContent("Size X", "");
             public readonly GUIContent shapeWidthBox = new GUIContent("Size Y", "");
             public readonly GUIContent applyRangeAttenuation = new GUIContent("Apply Range Attenuation", "Allows disabling range attenuation. This is useful indoor (like a room) to avoid having to setup a large range for a light to get correct inverse square attenuation that may leak out of the indoor");

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Editor/HDLightEditor.cs

             public SerializedProperty spotLightShape;
             public SerializedProperty shapeLength;
             public SerializedProperty shapeWidth;
+            public SerializedProperty aspectRatio;
             public SerializedProperty shapeRadius;
             public SerializedProperty maxSmoothness;
             public SerializedProperty applyRangeAttenuation;
                 spotLightShape = o.Find(x => x.spotLightShape),
                 shapeLength = o.Find(x => x.shapeLength),
                 shapeWidth = o.Find(x => x.shapeWidth),
+                aspectRatio = o.Find(x => x.aspectRatio),
                 shapeRadius = o.Find(x => x.shapeRadius),
                 maxSmoothness = o.Find(x => x.maxSmoothness),
                 applyRangeAttenuation = o.Find(x => x.applyRangeAttenuation),
                     // TODO : replace with angle and ratio
                     else if (spotLightShape == SpotLightShape.Pyramid)
                     {
-                        EditorGUILayout.Slider(m_AdditionalLightData.shapeLength, 0.01f, 10f, s_Styles.shapeLengthPyramid);
-                        EditorGUILayout.Slider(m_AdditionalLightData.shapeWidth, 0.01f, 10f, s_Styles.shapeWidthPyramid);
+                        EditorGUILayout.Slider(m_BaseData.spotAngle, 0f, 179.9f, s_Styles.spotAngle);
+                        EditorGUILayout.Slider(m_AdditionalLightData.aspectRatio, 0.05f, 20.0f, s_Styles.aspectRatioPyramid);
                     }
                     else if (spotLightShape == SpotLightShape.Box)
                     {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/HDAdditionalLightData.cs

 #if UNITY_EDITOR
 using UnityEditor;
+using UnityEditor.Experimental.Rendering.HDPipeline;
 #endif
 using UnityEngine.Serialization;
 
         // Only for Spotlight, should be hide for other light
         public SpotLightShape spotLightShape = SpotLightShape.Cone;
 
-        // Only for Rectangle/Line/projector lights
+        // Only for Rectangle/Line/box projector lights
-        // Only for Rectangle/projector lights
+        // Only for Rectangle/box projector lights
+        // Only for pyramid projector
+        public float aspectRatio = 1.0f;
+
         // Only for Sphere/Disc
         public float shapeRadius = 0.0f;
 
                 switch (light.type)
                 {
                     case LightType.Directional:
-                        EditorLightUtilities.DrawDirectionalLightGizmo(light);
+                        HDLightEditorUtilities.DrawDirectionalLightGizmo(light);
-                        EditorLightUtilities.DrawPointlightGizmo(light, selected);
+                        HDLightEditorUtilities.DrawPointlightGizmo(light, selected);
-                            EditorLightUtilities.DrawSpotlightGizmo(light, selected);
+                            HDLightEditorUtilities.DrawSpotlightGizmo(light, selected);
-                            EditorLightUtilities.DrawFrustumlightGizmo(light);
-                        else if (spotLightShape == SpotLightShape.Box) // TODO
-                            EditorLightUtilities.DrawFrustumlightGizmo(light);
+                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
+                        else if (spotLightShape == SpotLightShape.Box)
+                            HDLightEditorUtilities.DrawFrustumlightGizmo(light);
                         break;
                 }
             }
                 {
                     case LightTypeExtent.Rectangle:
-                        EditorLightUtilities.DrawArealightGizmo(light);
+                        HDLightEditorUtilities.DrawArealightGizmo(light);
-                        EditorLightUtilities.DrawArealightGizmo(light);
+                        HDLightEditorUtilities.DrawArealightGizmo(light);
                         break;
                 }
             }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

 
                 lightData.size = new Vector2(additionalLightData.shapeLength, additionalLightData.shapeWidth);
 
-                if (lightData.lightType == GPULightType.ProjectorBox || lightData.lightType == GPULightType.ProjectorPyramid)
+                if (lightData.lightType == GPULightType.ProjectorBox)
-                    lightData.right *= 2 / additionalLightData.shapeLength;
-                    lightData.up    *= 2 / additionalLightData.shapeWidth;
+                    lightData.right *= 2.0f / additionalLightData.shapeLength;
+                    lightData.up    *= 2.0f / additionalLightData.shapeWidth;
+                }
+                else if (lightData.lightType == GPULightType.ProjectorPyramid)
+                {
+                    // Get width and height for the current frustum
+                    var spotAngle = light.spotAngle;
+
+                    float frustumHeight;
+                    float frustumWidth;
+                    if (additionalLightData.aspectRatio >= 1.0f)
+                    {
+                        frustumHeight = 2.0f * Mathf.Tan(spotAngle * 0.5f * Mathf.Deg2Rad);
+                        frustumWidth = frustumHeight * additionalLightData.aspectRatio;
+                    }
+                    else
+                    {
+                        frustumWidth = 2.0f * Mathf.Tan(spotAngle * 0.5f * Mathf.Deg2Rad);
+                        frustumHeight = frustumWidth / additionalLightData.aspectRatio;
+                    }
+
+                    lightData.size = new Vector2(frustumWidth, frustumHeight);
+
+                    // Rescale for cookies and windowing.
+                    lightData.right *= 2.0f / frustumWidth;
+                    lightData.up *= 2.0f / frustumHeight;
                 }
 
                 if (lightData.lightType == GPULightType.Spot)

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.cs

             m_InitPreFGD = CoreUtils.CreateEngineMaterial("Hidden/HDRenderPipeline/PreIntegratedFGD");
 
             // For DisneyDiffuse integration values goes from (0.5 to 1.53125). GGX need 0 to 1. Use float format.
-            m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.RGB111110Float, RenderTextureReadWrite.Linear);
+            m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
             m_PreIntegratedFGD.filterMode = FilterMode.Bilinear;
             m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp;
             m_PreIntegratedFGD.hideFlags = HideFlags.DontSave;
             {
                 CoreUtils.DrawFullScreen(cmd, m_InitPreFGD, new RenderTargetIdentifier(m_PreIntegratedFGD));
             }
+
             m_isInit = true;
         }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 
 // Reference Lambert diffuse / GGX Specular for IBL and area lights
 #ifdef HAS_LIGHTLOOP // Both reference define below need to be define only if LightLoop is present, else we get a compile error
-//#define LIT_DISPLAY_REFERENCE_AREA
-//#define LIT_DISPLAY_REFERENCE_IBL
+// #define LIT_DISPLAY_REFERENCE_AREA
+// #define LIT_DISPLAY_REFERENCE_IBL
 #endif
 // Use Lambert diffuse instead of Disney diffuse
 // #define LIT_DIFFUSE_LAMBERT_BRDF
+#define LIT_USE_GGX_ENERGY_COMPENSATION
 
 // Sampler use by area light, gaussian pyramid, ambient occlusion etc...
 SamplerState s_linear_clamp_sampler;
 
 // For image based lighting, a part of the BSDF is pre-integrated.
 // This is done both for specular and diffuse (in case of DisneyDiffuse)
-void GetPreIntegratedFGD(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 specularFGD, out float diffuseFGD)
+void GetPreIntegratedFGD(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 specularFGD, out float diffuseFGD, out float reflectivity)
-    //  _PreIntegratedFGD.x = Gv * (1 - Fc)  with Fc = (1 - H.L)^5
-    //  _PreIntegratedFGD.y = Gv * Fc
+    // Integral{BSDF * <N,L> dw} =
+    // Integral{(F0 + (1 - F0) * (1 - <V,H>)^5) * (BSDF / F) * <N,L> dw} =
+    // F0 * Integral{(BSDF / F) * <N,L> dw} +
+    // (1 - F0) * Integral{(1 - <V,H>)^5 * (BSDF / F) * <N,L> dw} =
+    // (1 - F0) * x + F0 * y = lerp(x, y, F0)
-    // _PreIntegratedFGD.z = DisneyDiffuse
+    // z = DisneyDiffuse
-    // f0 * Gv * (1 - Fc) + Gv * Fc
-    specularFGD = fresnel0 * preFGD.x + preFGD.y;
+    specularFGD = lerp(preFGD.xxx, preFGD.yyy, fresnel0);
-    diffuseFGD = preFGD.z;
+    // Remap from [0, 1] to [0, 1.5] range.
+    diffuseFGD = 1.5 * preFGD.z;
+
+    reflectivity = preFGD.y;
 }
 
 void ApplyDebugToSurfaceData(inout SurfaceData surfaceData)
 
     // GGX
     float partLambdaV;
+    float energyCompensation;
     float TdotV;
     float BdotV;
 
         iblR                     = reflect(-V, iblNormalWS);
     }
 
+    float reflectivity;
+
-    GetPreIntegratedFGD(NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD);
+    GetPreIntegratedFGD(NdotV, bsdfData.perceptualRoughness, bsdfData.fresnel0, preLightData.specularFGD, preLightData.diffuseFGD, reflectivity);
 
     if (bsdfData.materialId == MATERIALID_LIT_CLEAR_COAT && HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_CLEAR_COAT))
     {
         preLightData.iblDirWS    = GetSpecularDominantDir(iblNormalWS, iblR, iblRoughness, NdotV);
         preLightData.iblMipLevel = PerceptualRoughnessToMipmapLevel(iblPerceptualRoughness);
     }
+
+#ifdef LIT_USE_GGX_ENERGY_COMPENSATION
+    // Ref: Practical multiple scattering compensation for microfacet models.
+    // We only apply the formulation for metals.
+    // For dielectrics, the change of reflectance is negligible.
+    // We deem the intensity difference of a couple of percent for high values of roughness
+    // to not be worth the cost of another precomputed table.
+    // Note: this formulation bakes the BSDF non-symmetric!
+    preLightData.energyCompensation = 1 / reflectivity - 1;
+#else
+    preLightData.energyCompensation = 0;
+#endif // LIT_USE_GGX_ENERGY_COMPENSATION
 
     // Area light
     // UVs for sampling the LUTs
     // envDiffuseLighting is used for refraction in this Lit material. Use the weight to balance between transmission and reflection
     diffuseLighting = lerp(directDiffuseLighting + bakeDiffuseLighting, accLighting.envDiffuseLighting, accLighting.envDiffuseLightingWeight);
     specularLighting = accLighting.dirSpecularLighting + accLighting.punctualSpecularLighting + accLighting.areaSpecularLighting + accLighting.envSpecularLighting;
+    specularLighting *= 1 + bsdfData.fresnel0 * preLightData.energyCompensation;
 }
 
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/HDLightEditorUtilities.cs

+#if UNITY_EDITOR
+using System;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+#endif
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+#if UNITY_EDITOR
+    public static class HDLightEditorUtilities
+    {
+        public static void DrawSpotlightGizmo(Light spotlight, bool selected)
+        {
+            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+
+            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+
+            var rangeDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.range;
+            var rangeDiscRadius = spotlight.range * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+            var nearDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.shadowNearPlane;
+            var nearDiscRadius = spotlight.shadowNearPlane * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
+
+
+            //Draw Range disc
+            Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius, false, 1);
+            //Draw Lines
+
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
+
+            if (selected)
+            {
+                //Draw Range Arcs
+                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.right, vectorLineUp, spotlight.spotAngle, spotlight.range);
+                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.up, vectorLineLeft, spotlight.spotAngle, spotlight.range);
+                //Draw Near Plane Disc
+                if (spotlight.shadows != LightShadows.None) Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius, false, 1);
+
+                //Inner Cone
+                var additionalLightData = spotlight.GetComponent<HDAdditionalLightData>();
+                DrawInnerCone(spotlight,additionalLightData);
+            }
+        }
+
+        public static void DrawInnerCone(Light spotlight, HDAdditionalLightData additionalLightData)
+        {
+            if (additionalLightData == null) return;
+
+            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * additionalLightData.m_InnerSpotPercent * 0.01f * Mathf.Deg2Rad * 0.5f);
+
+            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
+            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
+
+            //Draw Lines
+
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
+            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
+
+            var innerAngle = spotlight.spotAngle * additionalLightData.GetInnerSpotPercent01();
+            if (innerAngle > 0)
+            {
+                var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * spotlight.range;
+                var innerDiscRadius = spotlight.range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
+                //Draw Range disc
+                Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius, false, 1);
+            }
+        }
+
+        public static void DrawArealightGizmo(Light arealight)
+        {
+
+            var RectangleSize = new Vector3(arealight.areaSize.x, arealight.areaSize.y, 0);
+            Gizmos.matrix = arealight.transform.localToWorldMatrix;
+            Gizmos.DrawWireCube(Vector3.zero, RectangleSize);
+            Gizmos.matrix = Matrix4x4.identity;
+            Gizmos.DrawWireSphere(arealight.transform.position, arealight.range);
+        }
+
+        public static void DrawPointlightGizmo(Light pointlight, bool selected)
+        {
+            if (pointlight.shadows != LightShadows.None && selected) Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.shadowNearPlane);
+            Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.range);
+        }
+
+        public static void DrawSpherelightGizmo(Light spherelight)
+        {
+            var additionalLightData = spherelight.GetComponent<HDAdditionalLightData>();
+            if (additionalLightData == null) return;
+            Gizmos.DrawSphere(spherelight.transform.position, additionalLightData.shapeLength);
+            if (spherelight.shadows != LightShadows.None) Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.shadowNearPlane);
+            Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.range);
+        }
+
+        // Same as Gizmo.DrawFrustum except that when aspect is below one, fov represent fovX instead of fovY
+        // Use to match our light frustum pyramid behavior
+        public static void DrawLightPyramidFrustum(Vector3 center, float fov, float maxRange, float minRange, float aspect)
+        {
+            fov = Mathf.Deg2Rad * fov * 0.5f;
+            float tanfov = Mathf.Tan(fov);
+            Vector3 farEnd = new Vector3(0, 0, maxRange);
+            Vector3 endSizeX;
+            Vector3 endSizeY;
+
+            if (aspect >= 1.0f)
+            {
+                endSizeX = new Vector3(maxRange * tanfov * aspect, 0, 0);
+                endSizeY = new Vector3(0, maxRange * tanfov, 0);
+            }
+            else
+            {
+                endSizeX = new Vector3(maxRange * tanfov, 0, 0);
+                endSizeY = new Vector3(0, maxRange * tanfov / aspect, 0);
+            }
+
+            Vector3 s1, s2, s3, s4;
+            Vector3 e1 = farEnd + endSizeX + endSizeY;
+            Vector3 e2 = farEnd - endSizeX + endSizeY;
+            Vector3 e3 = farEnd - endSizeX - endSizeY;
+            Vector3 e4 = farEnd + endSizeX - endSizeY;
+            if (minRange <= 0.0f)
+            {
+                s1 = s2 = s3 = s4 = center;
+            }
+            else
+            {
+                Vector3 startSizeX;
+                Vector3 startSizeY;
+                if (aspect >= 1.0f)
+                {
+                    startSizeX = new Vector3(minRange * tanfov * aspect, 0, 0);
+                    startSizeY = new Vector3(0, minRange * tanfov, 0);
+                }
+                else
+                {
+                    startSizeY = new Vector3(minRange * tanfov / aspect, 0, 0);
+                    startSizeX = new Vector3(0, minRange * tanfov, 0);
+                }
+                Vector3 startPoint = center;
+                s1 =    startPoint + startSizeX + startSizeY;
+                s2 =    startPoint - startSizeX + startSizeY;
+                s3 =    startPoint - startSizeX - startSizeY;
+                s4 =    startPoint + startSizeX - startSizeY;
+                Gizmos.DrawLine(s1, s2);
+                Gizmos.DrawLine(s2, s3);
+                Gizmos.DrawLine(s3, s4);
+                Gizmos.DrawLine(s4, s1);
+            }
+
+            Gizmos.DrawLine(e1, e2);
+            Gizmos.DrawLine(e2, e3);
+            Gizmos.DrawLine(e3, e4);
+            Gizmos.DrawLine(e4, e1);
+
+            Gizmos.DrawLine(s1, e1);
+            Gizmos.DrawLine(s2, e2);
+            Gizmos.DrawLine(s3, e3);
+            Gizmos.DrawLine(s4, e4);
+        }
+
+        public static void DrawLightOrthoFrustum(Vector3 center, float width, float height, float maxRange, float minRange)
+        {
+            Vector3 farEnd = new Vector3(0, 0, maxRange);
+            Vector3 endSizeX = new Vector3(width, 0, 0);
+            Vector3 endSizeY = new Vector3(0, height, 0);
+
+            Vector3 s1, s2, s3, s4;
+            Vector3 e1 = farEnd + endSizeX + endSizeY;
+            Vector3 e2 = farEnd - endSizeX + endSizeY;
+            Vector3 e3 = farEnd - endSizeX - endSizeY;
+            Vector3 e4 = farEnd + endSizeX - endSizeY;
+            if (minRange <= 0.0f)
+            {
+                s1 = s2 = s3 = s4 = center;
+            }
+            else
+            {
+                Vector3 startSizeX = new Vector3(width, 0, 0);
+                Vector3 startSizeY = new Vector3(0, height, 0);
+
+                Vector3 startPoint = center;
+                s1 =    startPoint + startSizeX + startSizeY;
+                s2 =    startPoint - startSizeX + startSizeY;
+                s3 =    startPoint - startSizeX - startSizeY;
+                s4 =    startPoint + startSizeX - startSizeY;
+                Gizmos.DrawLine(s1, s2);
+                Gizmos.DrawLine(s2, s3);
+                Gizmos.DrawLine(s3, s4);
+                Gizmos.DrawLine(s4, s1);
+            }
+
+            Gizmos.DrawLine(e1, e2);
+            Gizmos.DrawLine(e2, e3);
+            Gizmos.DrawLine(e3, e4);
+            Gizmos.DrawLine(e4, e1);
+
+            Gizmos.DrawLine(s1, e1);
+            Gizmos.DrawLine(s2, e2);
+            Gizmos.DrawLine(s3, e3);
+            Gizmos.DrawLine(s4, e4);
+        }
+
+
+        public static void DrawFrustumlightGizmo(Light frustumlight)
+        {
+            var additionalLightData = frustumlight.GetComponent<HDAdditionalLightData>();
+            if (additionalLightData == null) return;
+
+            Matrix4x4 matrix = new Matrix4x4(frustumlight.transform.right, frustumlight.transform.up, frustumlight.transform.forward, frustumlight.transform.position);
+            Gizmos.matrix = matrix;
+            if (additionalLightData.spotLightShape == SpotLightShape.Pyramid)
+            {
+                DrawLightPyramidFrustum(Vector3.zero, frustumlight.spotAngle, frustumlight.range, 0.0f, additionalLightData.aspectRatio);
+            }
+            else // Ortho frustum
+            {
+                //DrawLightOrthoFrustum(Vector3.zero, additionalLightData.shapeLength, additionalLightData.shapeWidth, frustumlight.range, 0.0f);
+
+                Vector3 frustumCenter = new Vector3(0.0f, 0.0f, 0.5f * frustumlight.range);
+                Vector3 frustumsize = new Vector3(additionalLightData.shapeLength, additionalLightData.shapeWidth, frustumlight.range);
+                Gizmos.DrawWireCube(frustumCenter, frustumsize);
+            }
+            Gizmos.matrix = Matrix4x4.identity;
+        }
+
+        public static void DrawDirectionalLightGizmo(Light directionalLight)
+        {
+            var gizmoSize = 0.2f;
+            Handles.Disc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize, false, 1);
+            Gizmos.DrawLine(directionalLight.transform.position, directionalLight.transform.position + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * gizmoSize, directionalLight.transform.position + directionalLight.transform.up * gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * -gizmoSize, directionalLight.transform.position + directionalLight.transform.up * -gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * gizmoSize, directionalLight.transform.position + directionalLight.transform.right * gizmoSize + directionalLight.transform.forward);
+            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * -gizmoSize, directionalLight.transform.position + directionalLight.transform.right * -gizmoSize + directionalLight.transform.forward);
+        }
+
+        public static void DrawCross(Transform m_transform)
+        {
+            var gizmoSize = 0.25f;
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * gizmoSize / m_transform.localScale.z));
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * -gizmoSize / m_transform.localScale.z));
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * gizmoSize / m_transform.localScale.y));
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * -gizmoSize / m_transform.localScale.y));
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * gizmoSize / m_transform.localScale.x));
+            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * -gizmoSize / m_transform.localScale.x));
+        }
+    }
+#endif
+}

ScriptableRenderPipeline/HDRenderPipeline/Lighting/HDLightEditorUtilities.cs.meta

+fileFormatVersion: 2
+guid: 8f89186f308429942b61ec29b405e2dd
+timeCreated: 1508806968
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/EditorLightUtilities.cs.meta

-fileFormatVersion: 2
-guid: f38354ca887c51245a6780e4cd3e6609
-timeCreated: 1505227267
-licenseType: Pro
-MonoImporter:
-  externalObjects: {}
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/EditorLightUtilities.cs

-#if UNITY_EDITOR
-using UnityEditor;
-#endif
-
-namespace UnityEngine.Experimental.Rendering.HDPipeline
-{
-#if UNITY_EDITOR
-    public static class EditorLightUtilities
-    {
-        public static void DrawSpotlightGizmo(Light spotlight, bool selected)
-        {
-            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-
-            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-
-            var rangeDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.range;
-            var rangeDiscRadius = spotlight.range * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-            var nearDiscDistance = Mathf.Cos(Mathf.Deg2Rad * spotlight.spotAngle / 2) * spotlight.shadowNearPlane;
-            var nearDiscRadius = spotlight.shadowNearPlane * Mathf.Sin(spotlight.spotAngle * Mathf.Deg2Rad * 0.5f);
-
-
-            //Draw Range disc
-            Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * rangeDiscDistance, spotlight.gameObject.transform.forward, rangeDiscRadius, false, 1);
-            //Draw Lines
-
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
-
-            if (selected)
-            {
-                //Draw Range Arcs
-                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.right, vectorLineUp, spotlight.spotAngle, spotlight.range);
-                Handles.DrawWireArc(spotlight.gameObject.transform.position, spotlight.gameObject.transform.up, vectorLineLeft, spotlight.spotAngle, spotlight.range);
-                //Draw Near Plane Disc
-                if (spotlight.shadows != LightShadows.None) Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * nearDiscDistance, spotlight.gameObject.transform.forward, nearDiscRadius, false, 1);
-
-                //Inner Cone
-                var additionalLightData = spotlight.GetComponent<HDAdditionalLightData>();
-                DrawInnerCone(spotlight,additionalLightData);
-            }
-        }
-
-        public static void DrawInnerCone(Light spotlight, HDAdditionalLightData additionalLightData)
-        {
-            if (additionalLightData == null) return;
-
-            var flatRadiusAtRange = spotlight.range * Mathf.Tan(spotlight.spotAngle * additionalLightData.m_InnerSpotPercent * 0.01f * Mathf.Deg2Rad * 0.5f);
-
-            var vectorLineUp = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineDown = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.up * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineRight = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * flatRadiusAtRange - spotlight.gameObject.transform.position);
-            var vectorLineLeft = Vector3.Normalize(spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * spotlight.range + spotlight.gameObject.transform.right * -flatRadiusAtRange - spotlight.gameObject.transform.position);
-
-            //Draw Lines
-
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineUp * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineDown * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineRight * spotlight.range);
-            Gizmos.DrawLine(spotlight.gameObject.transform.position, spotlight.gameObject.transform.position + vectorLineLeft * spotlight.range);
-
-            var innerAngle = spotlight.spotAngle * additionalLightData.GetInnerSpotPercent01();
-            if (innerAngle > 0)
-            {
-                var innerDiscDistance = Mathf.Cos(Mathf.Deg2Rad * innerAngle * 0.5f) * spotlight.range;
-                var innerDiscRadius = spotlight.range * Mathf.Sin(innerAngle * Mathf.Deg2Rad * 0.5f);
-                //Draw Range disc
-                Handles.Disc(spotlight.gameObject.transform.rotation, spotlight.gameObject.transform.position + spotlight.gameObject.transform.forward * innerDiscDistance, spotlight.gameObject.transform.forward, innerDiscRadius, false, 1);
-            }
-        }
-
-        public static void DrawArealightGizmo(Light arealight)
-        {
-
-            var RectangleSize = new Vector3(arealight.areaSize.x, arealight.areaSize.y, 0);
-            Gizmos.matrix = arealight.transform.localToWorldMatrix;
-            Gizmos.DrawWireCube(Vector3.zero, RectangleSize);
-            Gizmos.matrix = Matrix4x4.identity;
-            Gizmos.DrawWireSphere(arealight.transform.position, arealight.range);
-        }
-
-        public static void DrawPointlightGizmo(Light pointlight, bool selected)
-        {
-            if (pointlight.shadows != LightShadows.None && selected) Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.shadowNearPlane);
-            Gizmos.DrawWireSphere(pointlight.transform.position, pointlight.range);
-        }
-
-        public static void DrawSpherelightGizmo(Light spherelight)
-        {
-            var additionalLightData = spherelight.GetComponent<HDAdditionalLightData>();
-            if (additionalLightData == null) return;
-            Gizmos.DrawSphere(spherelight.transform.position, additionalLightData.shapeLength);
-            if (spherelight.shadows != LightShadows.None) Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.shadowNearPlane);
-            Gizmos.DrawWireSphere(spherelight.transform.position, spherelight.range);
-        }
-
-        public static void DrawFrustumlightGizmo(Light frustumlight)
-        {
-            var additionalLightData = frustumlight.GetComponent<HDAdditionalLightData>();
-            if (additionalLightData == null) return;
-            var frustumSize = new Vector3(additionalLightData.shapeLength / frustumlight.gameObject.transform.localScale.x, additionalLightData.shapeWidth / frustumlight.gameObject.transform.localScale.y, frustumlight.range - frustumlight.shadowNearPlane / frustumlight.gameObject.transform.localScale.z);
-            Gizmos.matrix = frustumlight.transform.localToWorldMatrix;
-            Gizmos.DrawWireCube(Vector3.forward * (frustumSize.z * 0.5f + frustumlight.shadowNearPlane), frustumSize);
-            Gizmos.matrix = Matrix4x4.identity;
-        }
-
-        public static void DrawDirectionalLightGizmo(Light directionalLight)
-        {
-            var gizmoSize = 0.2f;
-            Handles.Disc(directionalLight.transform.rotation, directionalLight.transform.position, directionalLight.gameObject.transform.forward, gizmoSize, false, 1);
-            Gizmos.DrawLine(directionalLight.transform.position, directionalLight.transform.position + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * gizmoSize, directionalLight.transform.position + directionalLight.transform.up * gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.up * -gizmoSize, directionalLight.transform.position + directionalLight.transform.up * -gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * gizmoSize, directionalLight.transform.position + directionalLight.transform.right * gizmoSize + directionalLight.transform.forward);
-            Gizmos.DrawLine(directionalLight.transform.position + directionalLight.transform.right * -gizmoSize, directionalLight.transform.position + directionalLight.transform.right * -gizmoSize + directionalLight.transform.forward);
-        }
-
-        public static void DrawCross(Transform m_transform)
-        {
-            var gizmoSize = 0.25f;
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * gizmoSize / m_transform.localScale.z));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.forward * -gizmoSize / m_transform.localScale.z));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * gizmoSize / m_transform.localScale.y));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.up * -gizmoSize / m_transform.localScale.y));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * gizmoSize / m_transform.localScale.x));
-            Gizmos.DrawLine(m_transform.position, m_transform.position + m_transform.TransformVector(m_transform.root.right * -gizmoSize / m_transform.localScale.x));
-        }
-    }
-#endif
-}