Integrate HDRI

com.unity.render-pipelines.core/Runtime/Textures/RTHandlesDeleter.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+
+namespace UnityEngine.Rendering
+{
+    /// <summary>
+    /// RTHandleDeleter to schedule a release of a RTHandle in N ('lifetime') frame
+    /// </summary>
+    public static class RTHandleDeleter
+    {
+        internal class RTHandleDesc
+        {
+            public int         lifetime = 3;
+            public RTHandle    rtHandle = null;
+        }
+
+        internal static List<RTHandleDesc> m_RTHandleDescs = new List<RTHandleDesc>();
+
+        /// <summary>
+        /// Schedule a release of a RTHandle in 'lifetime' frames
+        /// </summary>
+        /// <param name="rtHandle">Considered rtHandle.</param>
+        /// <param name="lifetime">lifetime remaining of this rtHandle (unit: frame), default: 3 frames.</param>
+        public static void ScheduleRelease(RTHandle rtHandle, int lifetime = 3)
+        {
+            if (rtHandle != null && lifetime > 0)
+            {
+                RTHandleDesc desc = new RTHandleDesc();
+                desc.lifetime = lifetime;
+                desc.rtHandle = rtHandle;
+                m_RTHandleDescs.Add(desc);
+            }
+            else
+            {
+                rtHandle?.Release();
+            }
+        }
+
+        /// <summary>
+        /// Schedule a release of a RTHandle in 'lifetime' frames
+        /// </summary>
+        public static void Update()
+        {
+            foreach (RTHandleDesc desc in m_RTHandleDescs)
+            {
+                --desc.lifetime;
+            }
+
+            // Release 'too old' RTHandle
+            for (int i = m_RTHandleDescs.Count - 1; i >= 0; i--)
+            {
+                var cur = m_RTHandleDescs[i];
+                if (cur.lifetime <= 0)
+                {
+                    cur.rtHandle.Release();
+                    m_RTHandleDescs.Remove(cur);
+                }
+            }
+        }
+    }
+}

com.unity.render-pipelines.high-definition/CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [Unreleased]
 
 ### Added
+- Update Integration of HDRI Sky for Lux intensity
 - Ray tracing support for VR single-pass
 - Added sharpen filter shader parameter and UI for TemporalAA to control image quality instead of hardcoded value
 - Added frame settings option for custom post process and custom passes as well as custom color buffer format option.

com.unity.render-pipelines.high-definition/Editor/Sky/HDRISky/HDRISkyEditor.cs

@@ -28,8 +28,9 @@ class HDRISkyEditor
         SerializedDataParameter m_ShadowTint;
 
         RTHandle m_IntensityTexture;
-        Material m_IntegrateHDRISkyMaterial; // Compute the HDRI sky intensity in lux for the skybox
         Texture2D m_ReadBackTexture;
+        Material m_CubeToHemiLatLong;
+
         public override bool hasAdvancedMode => true;
 
         public override void OnEnable()
@@ -63,7 +64,9 @@ public override void OnEnable()
             m_IntensityTexture = RTHandles.Alloc(1, 1, colorFormat: GraphicsFormat.R32G32B32A32_SFloat);
             var hdrp = HDRenderPipeline.defaultAsset;
             if (hdrp != null)
-                m_IntegrateHDRISkyMaterial = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.shaders.integrateHdriSkyPS);
+            {
+                m_CubeToHemiLatLong = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.shaders.cubeToHemiPanoPS);
+            }
             m_ReadBackTexture = new Texture2D(1, 1, TextureFormat.RGBAFloat, false, false);
         }
 
@@ -79,28 +82,46 @@ public override void OnDisable()
         public void GetUpperHemisphereLuxValue()
         {
             Cubemap hdri = m_hdriSky.value.objectReferenceValue as Cubemap;
-
-            // null material can happen when no HDRP asset is present.
-            if (hdri == null || m_IntegrateHDRISkyMaterial == null)
+            if (hdri == null || m_CubeToHemiLatLong == null)
                 return;
 
-            m_IntegrateHDRISkyMaterial.SetTexture(HDShaderIDs._Cubemap, hdri);
-
-            Graphics.Blit(Texture2D.whiteTexture, m_IntensityTexture.rt, m_IntegrateHDRISkyMaterial);
-
-            // Copy the rendertexture containing the lux value inside a Texture2D
-            RenderTexture.active = m_IntensityTexture.rt;
-            m_ReadBackTexture.ReadPixels(new Rect(0.0f, 0.0f, 1, 1), 0, 0);
+            // Render LatLong
+            RTHandle latLongMap = RTHandles.Alloc(  4*hdri.width, hdri.width,
+                                                    colorFormat: GraphicsFormat.R32G32B32A32_SFloat,
+                                                    enableRandomWrite: true);
+            RTHandleDeleter.ScheduleRelease(latLongMap);
+            m_CubeToHemiLatLong.SetTexture  ("_srcCubeTexture",             hdri);
+            m_CubeToHemiLatLong.SetInt      ("_cubeMipLvl",                 0);
+            m_CubeToHemiLatLong.SetInt      ("_cubeArrayIndex",             0);
+            m_CubeToHemiLatLong.SetInt      ("_buildPDF",                   0);
+            m_CubeToHemiLatLong.SetInt      ("_preMultiplyByJacobian",      1);
+            m_CubeToHemiLatLong.SetInt      ("_preMultiplyByCosTheta",      1);
+            m_CubeToHemiLatLong.SetInt      ("_preMultiplyBySolidAngle",    0);
+            m_CubeToHemiLatLong.SetVector   (HDShaderIDs._Sizes, new Vector4(      (float)latLongMap.rt.width,        (float)latLongMap.rt.height,
+                                                                             1.0f/((float)latLongMap.rt.width), 1.0f/((float)latLongMap.rt.height)));
+            Graphics.Blit(Texture2D.whiteTexture, latLongMap.rt, m_CubeToHemiLatLong, 0);
+
+            RTHandle totalRows = GPUScan.ComputeOperation(latLongMap, null, GPUScan.Operation.Total, GPUScan.Direction.Horizontal, latLongMap.rt.graphicsFormat);
+            RTHandle totalCols = GPUScan.ComputeOperation(totalRows,  null, GPUScan.Operation.Total, GPUScan.Direction.Vertical,   latLongMap.rt.graphicsFormat);
+            RTHandleDeleter.ScheduleRelease(totalRows);
+            RTHandleDeleter.ScheduleRelease(totalCols);
+
+            RenderTexture.active = totalCols.rt;
+            m_ReadBackTexture.ReadPixels(new Rect(0.0f, 0.0f, 1.0f, 1.0f), 0, 0);
             RenderTexture.active = null;
 
-            // And then the value inside this texture
             Color hdriIntensity = m_ReadBackTexture.GetPixel(0, 0);
-            m_UpperHemisphereLuxValue.value.floatValue = hdriIntensity.a;
+
+            m_UpperHemisphereLuxValue.value.floatValue =          Mathf.PI*Mathf.PI*Mathf.Max(hdriIntensity.r, hdriIntensity.g, hdriIntensity.b)
+                                                        / // ----------------------------------------------------------------------------------------
+                                                                            ((float)(latLongMap.rt.width*latLongMap.rt.height));
+
             float max = Mathf.Max(hdriIntensity.r, hdriIntensity.g, hdriIntensity.b);
             if (max == 0.0f)
                 max = 1.0f;
+
             m_UpperHemisphereLuxColor.value.vector3Value = new Vector3(hdriIntensity.r/max, hdriIntensity.g/max, hdriIntensity.b/max);
-            m_UpperHemisphereLuxColor.value.vector3Value *= 0.5f; // Arbitrary 25% to not have too dark or too bright shadow
+            m_UpperHemisphereLuxColor.value.vector3Value *= 0.5f; // Arbitrary 50% to not have too dark or too bright shadow
         }
 
         public override void OnInspectorGUI()

com.unity.render-pipelines.high-definition/Runtime/Core/CoreResources/Arithmetics.compute

@@ -0,0 +1,58 @@
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
+
+#pragma kernel CSMainAdd        Add                 KerName=CSMainAdd
+#pragma kernel CSMainSub        Sub                 KerName=CSMainSub
+#pragma kernel CSMainMult       Mult                KerName=CSMainMult
+#pragma kernel CSMainDiv        Div                 KerName=CSMainDiv
+#pragma kernel CSMainMAD        MAD                 KerName=CSMainMAD
+#pragma kernel CSMainMAD_RG     MAD_RG              KerName=CSMainMAD_RG
+#pragma kernel CSMainMean       Mean                KerName=CSMainMean
+#pragma kernel CSMainSelfAdd    READ_WRITE  Add     KerName=CSMainSelfAdd
+#pragma kernel CSMainSelfSub    READ_WRITE  Sub     KerName=CSMainSelfSub
+#pragma kernel CSMainSelfMult   READ_WRITE  Mult    KerName=CSMainSelfMult
+#pragma kernel CSMainSelfDiv    READ_WRITE  Div     KerName=CSMainSelfDiv
+#pragma kernel CSMainSelfMAD    READ_WRITE  MAD     KerName=CSMainSelfMAD
+#pragma kernel CSMainSelfMAD_RG READ_WRITE  MAD_RG  KerName=CSMainSelfMAD_RG
+#pragma kernel CSMainSelfMean   READ_WRITE  Mean    KerName=CSMainSelfMean
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Macros.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl"
+#include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariablesFunctions.hlsl"
+
+Texture2D<float4> _InputVal;
+
+#ifdef READ_WRITE
+    RWTexture2D<float4> _Output;
+    #define _Input      _Output
+#else
+      Texture2D<float4> _Input;
+    RWTexture2D<float4> _Output;
+#endif
+
+uint4 _Sizes; // xy: InputSize; zw: OutputSize
+
+[numthreads(8, 8, 1)]
+void KerName(uint3 id : SV_DispatchThreadID)
+{
+    if (all(id.xy < _Sizes.xy))
+    {
+        float4 v = _Input[id.xy];
+
+#ifdef Add
+        _Output[id.xy] = v + _InputVal[uint2(0, 0)];
+#elif defined(Sub)
+        _Output[id.xy] = v - _InputVal[uint2(0, 0)];
+#elif defined(Mult)
+        _Output[id.xy] = v*_InputVal[uint2(0, 0)];
+#elif defined(Div)
+        float4 a = _InputVal[uint2(0, 0)];
+        _Output[id.xy] = sign(a)*v/max(abs(a), 1e-4f);
+#elif defined(MAD)
+        _Output[id.xy] = v*_InputVal[uint2(0, 0)] + _InputVal[uint2(1, 0)];
+#elif defined(Mean)
+        float mean = dot(v.xyz, float3((1.0f/3.0f).xxx));
+        _Output[id.xy] = mean.xxxx;
+#endif
+    }
+}