HD: Fix scripting part of light intensity

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

                         }
                         else if (spotLightShape == SpotLightShape.Pyramid)
                         {
-                            var aspectRatio = m_AdditionalLightData.aspectRatio.floatValue;
-                            // Since the smallest angles is = to the fov, and we don't care of the angle order, simply make sure the aspect ratio is > 1
-                            if ( aspectRatio < 1f ) aspectRatio = 1f/aspectRatio;
-
-                            var angleA = settings.spotAngle.floatValue * Mathf.Deg2Rad;
-
-                            var halfAngle = angleA * 0.5f; // half of the smallest angle
-                            var length = Mathf.Tan(halfAngle); // half length of the smallest side of the rectangle
-                            length *= aspectRatio; // half length of the bigest side of the rectangle
-                            halfAngle = Mathf.Atan(length); // half of the bigest angle
-
-                            var angleB = halfAngle * 2f;
+                            float angleA, angleB;
+                            LightUtils.CalculateAnglesForPyramid(   m_AdditionalLightData.aspectRatio.floatValue, settings.spotAngle.floatValue,
+                                                                    out angleA, out angleB);
 
                             settings.intensity.floatValue = LightUtils.ConvertFrustrumLightIntensity(m_AdditionalLightData.punctualIntensity.floatValue, angleA, angleB );
                         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Light/HDAdditionalLightData.cs

                 switch (light.type)
                 {
                     case LightType.Directional:
-                        light.intensity = directionalIntensity;
+                        light.intensity = Mathf.Max(0, directionalIntensity);
-                        light.intensity = LightUtils.ConvertPointLightIntensity(punctualIntensity);
+                        light.intensity = LightUtils.ConvertPointLightIntensity(Mathf.Max(0, punctualIntensity));
-                        // Spot should used conversion which take into account the angle, and thus the intensity vary with angle.
-                        // This is not easy to manipulate for lighter, so we simply consider any spot light as just occluded point light. So reuse the same code.
-                        light.intensity = LightUtils.ConvertPointLightIntensity(punctualIntensity);
-                        // TODO: What to do with box shape ?
-                        // var spotLightShape = (SpotLightShape)m_AdditionalspotLightShape.enumValueIndex;
+
+                        if (enableSpotReflector)
+                        {
+                            if (spotLightShape == SpotLightShape.Cone)
+                            {
+                                light.intensity = LightUtils.ConvertSpotLightIntensity(Mathf.Max(0, punctualIntensity), light.spotAngle * Mathf.Deg2Rad, true);
+                            }
+                            else if (spotLightShape == SpotLightShape.Pyramid)
+                            {
+                                float angleA, angleB;
+                                LightUtils.CalculateAnglesForPyramid(aspectRatio, light.spotAngle,
+                                                                        out angleA, out angleB);
+
+                                light.intensity = LightUtils.ConvertFrustrumLightIntensity(Mathf.Max(0, punctualIntensity), angleA, angleB);
+                            }
+                            else // Box shape, fallback to punctual light.
+                            {
+                                light.intensity = LightUtils.ConvertPointLightIntensity(Mathf.Max(0, punctualIntensity));
+                            }
+
+                        }
+                        else
+                        {
+                            // Spot should used conversion which take into account the angle, and thus the intensity vary with angle.
+                            // This is not easy to manipulate for lighter, so we simply consider any spot light as just occluded point light. So reuse the same code.
+                            light.intensity = LightUtils.ConvertPointLightIntensity(Mathf.Max(0, punctualIntensity));
+                            // TODO: What to do with box shape ?
+                            // var spotLightShape = (SpotLightShape)m_AdditionalspotLightShape.enumValueIndex;
+                        }
                         break;
 
                 }
-                light.intensity = LightUtils.ConvertRectLightIntensity(areaIntensity, shapeWidth, shapeHeight);
+                light.intensity = LightUtils.ConvertRectLightIntensity(Mathf.Max(0, areaIntensity), shapeWidth, shapeHeight);
-                light.intensity = LightUtils.CalculateLineLightIntensity(areaIntensity, shapeWidth);
+                light.intensity = LightUtils.CalculateLineLightIntensity(Mathf.Max(0, areaIntensity), shapeWidth);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtils.cs

             //radiance = power / (length * (4 * Pi)).
             return intensity / (4.0f * Mathf.PI * lineWidth);
         }
+
+        public static void CalculateAnglesForPyramid(float aspectRatio, float spotAngle, out float angleA, out float angleB)
+        {
+            // Since the smallest angles is = to the fov, and we don't care of the angle order, simply make sure the aspect ratio is > 1
+            if (aspectRatio < 1.0f)
+                aspectRatio = 1.0f / aspectRatio;
+
+            angleA = spotAngle * Mathf.Deg2Rad;
+
+            var halfAngle = angleA * 0.5f; // half of the smallest angle
+            var length = Mathf.Tan(halfAngle); // half length of the smallest side of the rectangle
+            length *= aspectRatio; // half length of the bigest side of the rectangle
+            halfAngle = Mathf.Atan(length); // half of the bigest angle
+
+            angleB = halfAngle * 2.0f;
+        }
     }
 }