HDRenderLoop: Commit second draft, need testing

Author: sebastienlagarde

Assets/ScriptableRenderLoop/HDRenderLoop/Editor/HDRenderLoopInspector.cs

@@ -46,9 +46,11 @@ private class Styles
 
             public readonly GUIContent tileLightLoopSettings = new GUIContent("Tile Light Loop settings");
             public readonly string[] tileLightLoopDebugTileFlagStrings = new string[] { "Direct Light", "Reflection Light", "Area Light"};
-            public readonly GUIContent directIndirectSinglePass = new GUIContent("Enable direct and indirect lighting in single pass", "Toggle");
+            public readonly GUIContent splitLightEvaluation = new GUIContent("Enable direct and indirect lighting in single pass", "Toggle");
             public readonly GUIContent bigTilePrepass = new GUIContent("Enable big tile prepass", "Toggle");
             public readonly GUIContent clustered = new GUIContent("Enable clustered", "Toggle");
+            public readonly GUIContent disableTileAndCluster = new GUIContent("Disable Tile/clustered", "Toggle");
+            
 
 
             public readonly GUIContent textureSettings = new GUIContent("texture Settings");
@@ -265,16 +267,19 @@ public override void OnInspectorGUI()
 
             EditorGUILayout.Space();
 
-            if (renderLoop.tilePassLightLoop != null)
+            // TODO: we should call a virtual method or something similar to setup the UI, inspector should not know about it
+            TilePass tilePass = renderLoop.lightLoop as TilePass;
+            if (tilePass != null)
             {
                 EditorGUILayout.LabelField(styles.tileLightLoopSettings);
                 EditorGUI.indentLevel++;
                 EditorGUI.BeginChangeCheck();
 
-                renderLoop.tilePassLightLoop.debugViewTilesFlags = EditorGUILayout.MaskField("DebugView Tiles", renderLoop.tilePassLightLoop.debugViewTilesFlags, styles.tileLightLoopDebugTileFlagStrings);
-                renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass = EditorGUILayout.Toggle(styles.directIndirectSinglePass, renderLoop.tilePassLightLoop.enableDirectIndirectSinglePass);
-                renderLoop.tilePassLightLoop.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, renderLoop.tilePassLightLoop.enableBigTilePrepass);
-                renderLoop.tilePassLightLoop.enableClustered = EditorGUILayout.Toggle(styles.clustered, renderLoop.tilePassLightLoop.enableClustered);
+                tilePass.debugViewTilesFlags = EditorGUILayout.MaskField("DebugView Tiles", tilePass.debugViewTilesFlags, styles.tileLightLoopDebugTileFlagStrings);
+                tilePass.enableSplitLightEvaluation = EditorGUILayout.Toggle(styles.directSplitLightEvaluation, tilePass.enableSplitLightEvaluation);
+                tilePass.enableBigTilePrepass = EditorGUILayout.Toggle(styles.bigTilePrepass, tilePass.enableBigTilePrepass);
+                tilePass.enableClustered = EditorGUILayout.Toggle(styles.clustered, tilePass.enableClustered);
+                tilePass.disableTileAndCluster = EditorGUILayout.Toggle(styles.disableTileAndCluster, tilePass.disableTileAndCluster);
 
                 if (EditorGUI.EndChangeCheck())
                 {

Assets/ScriptableRenderLoop/HDRenderLoop/HDRenderLoop.cs

@@ -59,7 +59,7 @@ public struct LightData
     [GenerateHLSL]
     public struct DirectionalLightData
     {
-        public Vector3 direction;
+        public Vector3 forward;
         public float   diffuseScale;
 
         public Vector3 up;

Assets/ScriptableRenderLoop/HDRenderLoop/Lighting/LightDefinition.cs

@@ -7,145 +7,28 @@ namespace UnityEngine.Experimental.ScriptableRenderLoop
 {
     public class LightLoop
     {
-        public virtual string GetKeyword()
-        {
-            return "";
-        }
+        // TODO: We should rather put the texture settings in LightLoop, but how do we serialize it ?
+        public virtual void Rebuild(TextureSettings textureSettings) {}
 
-        public virtual void Rebuild()
-        {
-            m_lightList = new LightList();
+        public virtual void Cleanup() {}
 
-            s_DirectionalLights = new ComputeBuffer(HDRenderLoop.k_MaxDirectionalLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalLightData)));
-            s_DirectionalShadowList = new ComputeBuffer(HDRenderLoop.k_MaxCascadeCount, System.Runtime.InteropServices.Marshal.SizeOf(typeof(DirectionalShadowData)));
-            s_PunctualLightList = new ComputeBuffer(HDRenderLoop.k_MaxPunctualLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
-            s_AreaLightList = new ComputeBuffer(HDRenderLoop.k_MaxAreaLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightData)));
-            s_EnvLightList = new ComputeBuffer(HDRenderLoop.k_MaxEnvLightsOnSCreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(EnvLightData)));
-            s_PunctualShadowList = new ComputeBuffer(HDRenderLoop.k_MaxShadowOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(PunctualShadowData)));
+        public virtual bool NeedResize() { return false;  }
 
-            m_CookieTexArray = new TextureCache2D();
-            m_CookieTexArray.AllocTextureArray(8, m_TextureSettings.spotCookieSize, m_TextureSettings.spotCookieSize, TextureFormat.RGBA32, true);
-            m_CubeCookieTexArray = new TextureCacheCubemap();
-            m_CubeCookieTexArray.AllocTextureArray(4, m_TextureSettings.pointCookieSize, TextureFormat.RGBA32, true);
-            m_CubeReflTexArray = new TextureCacheCubemap();
-            m_CubeReflTexArray.AllocTextureArray(32, m_TextureSettings.reflectionCubemapSize, TextureFormat.BC6H, true);
-        }
+        public virtual void AllocResolutionDependentBuffers(int width, int height) { }
 
-        public virtual void Cleanup()
-        {
-            Utilities.SafeRelease(s_DirectionalLights);
-            Utilities.SafeRelease(s_DirectionalShadowList);
-            Utilities.SafeRelease(s_PunctualLightList);
-            Utilities.SafeRelease(s_AreaLightList);
-            Utilities.SafeRelease(s_EnvLightList);
-            Utilities.SafeRelease(s_PunctualShadowList);
+        public virtual void ReleaseResolutionDependentBuffers() {}
 
-            if (m_CubeReflTexArray != null)
-            {
-                m_CubeReflTexArray.Release();
-                m_CubeReflTexArray = null;
-            }
-            if (m_CookieTexArray != null)
-            {
-                m_CookieTexArray.Release();
-                m_CookieTexArray = null;
-            }
-            if (m_CubeCookieTexArray != null)
-            {
-                m_CubeCookieTexArray.Release();
-                m_CubeCookieTexArray = null;
-            }
-        }
+        public virtual void NewFrame() {}
 
-        virtual void NewFrame()
-        {
-            m_CookieTexArray.NewFrame();
-            m_CubeCookieTexArray.NewFrame();
-            m_CubeReflTexArray.NewFrame();
-        }
+        public virtual void PrepareLightsForGPU(CullResults cullResults, Camera camera, ref ShadowOutput shadowOutput) { }
+        
+        // TODO: this should not be aprt of the interface but for now make something working
+        public virtual void BuildGPULightLists(Camera camera, RenderLoop loop, RenderTargetIdentifier cameraDepthBufferRT) { }
 
-
-
-        public ShadowData GetShadowData(VisibleLight light, AdditionalLightData additionalData, int lightIndex, ref ShadowOutput shadowOutput)
-        {
-            bool hasDirectionalShadows = light.light.shadows != LightShadows.None && shadowOutput.GetShadowSliceCountLightIndex(lightIndex) != 0;
-
-            if (hasDirectionalShadows)
-            {
-                for (int sliceIndex = 0; sliceIndex < shadowOutput.GetShadowSliceCountLightIndex(lightIndex); ++sliceIndex)
-                {
-                    ShadowData shadowData = new ShadowData();
-
-                    int shadowSliceIndex = shadowOutput.GetShadowSliceIndex(lightIndex, sliceIndex);
-                    shadowData.worldToShadow = shadowOutput.shadowSlices[shadowSliceIndex].shadowTransform.transpose; // Transpose for hlsl reading ?
-                    shadowData.lightType = lightData.lightType;
-
-                    shadowData.bias = light.light.shadowBias;
-
-                    m_lightList.directionalShadows.Add(shadowData);
-                }
-            }
-        }
-
-        public DirectionalLightData GetDirectionalLightData(VisibleLight light, AdditionalLightData additionalData)
-        {
-            Debug.Assert(light.lightType == LightType.Directional);
-
-            var directionalLightData = new DirectionalLightData();
-            // Light direction for directional and is opposite to the forward direction
-            directionalLightData.direction = -light.light.transform.forward;
-            // up and right are use for cookie
-            directionalLightData.up = light.light.transform.up;
-            directionalLightData.right = light.light.transform.right;
-            directionalLightData.positionWS = light.light.transform.position;
-            directionalLightData.color = GetLightColor(light);
-            directionalLightData.diffuseScale = additionalData.affectDiffuse ? 1.0f : 0.0f;
-            directionalLightData.specularScale = additionalData.affectSpecular ? 1.0f : 0.0f;
-            directionalLightData.invScaleX = 1.0f / light.light.transform.localScale.x;
-            directionalLightData.invScaleY = 1.0f / light.light.transform.localScale.y;
-            directionalLightData.cosAngle = 0.0f;
-            directionalLightData.sinAngle = 0.0f;
-            directionalLightData.shadowIndex = -1;
-            directionalLightData.cookieIndex = -1;
-
-            if (light.light.cookie != null)
-            {
-                directionalLightData.tileCookie = (light.light.cookie.wrapMode == TextureWrapMode.Repeat);
-                directionalLightData.cookieIndex = m_CookieTexArray.FetchSlice(light.light.cookie);
-            }
-
-            directionalLightData.shadowIndex = 0;
-        }
-
-        public virtual void PrepareLightsForGPU(CullResults cullResults, Camera camera) { }
-
-        public virtual void PushGlobalParams(Camera camera, RenderLoop loop)
-        {
-            Shader.SetGlobalTexture("_CookieTextures", m_CookieTexArray.GetTexCache());
-            Shader.SetGlobalTexture("_CookieCubeTextures", m_CubeCookieTexArray.GetTexCache());
-            Shader.SetGlobalTexture("_EnvTextures", m_CubeReflTexArray.GetTexCache());
-
-            s_DirectionalLights.SetData(m_lightList.directionalLights.ToArray());
-            s_DirectionalShadowList.SetData(m_lightList.directionalShadows.ToArray());
-            s_PunctualLightList.SetData(m_lightList.punctualLights.ToArray());
-            s_AreaLightList.SetData(m_lightList.areaLights.ToArray());
-            s_EnvLightList.SetData(m_lightList.envLights.ToArray());
-            s_PunctualShadowList.SetData(m_lightList.punctualShadows.ToArray());
-
-            Shader.SetGlobalBuffer("_DirectionalLightList", s_DirectionalLights);
-            Shader.SetGlobalInt("_DirectionalLightCount", m_lightList.directionalLights.Count);
-            Shader.SetGlobalBuffer("_DirectionalShadowList", s_DirectionalShadowList);
-            Shader.SetGlobalBuffer("_PunctualLightList", s_PunctualLightList);
-            Shader.SetGlobalInt("_PunctualLightCount", m_lightList.punctualLights.Count);
-            Shader.SetGlobalBuffer("_AreaLightList", s_AreaLightList);
-            Shader.SetGlobalInt("_AreaLightCount", m_lightList.areaLights.Count);
-            Shader.SetGlobalBuffer("_PunctualShadowList", s_PunctualShadowList);
-            Shader.SetGlobalBuffer("_EnvLightList", s_EnvLightList);
-            Shader.SetGlobalInt("_EnvLightCount", m_lightList.envLights.Count);
-
-            Shader.SetGlobalVectorArray("_DirShadowSplitSpheres", m_lightList.directionalShadowSplitSphereSqr);     
-        }
+        public virtual void PushGlobalParams(Camera camera, RenderLoop loop) {}
 
         public virtual void RenderDeferredLighting(Camera camera, RenderLoop renderLoop, RenderTargetIdentifier cameraColorBufferRT) {}
+
+        public virtual void RenderForward(Camera camera, RenderLoop renderLoop, bool renderOpaque) {}
     }
 }