added shader and script side for conventional forward

added shader and script side for conventional forward

Assets/ScriptableRenderLoop/fptl/FptlLighting.cs

 
             bool useFptl = opaquesOnly && UsingFptl();     // requires depth pre-pass for forward opaques!
 
-            cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", useFptl ? 1 : 0);
+            bool haveTiledSolution = opaquesOnly || enableClustered;
+            cmd.EnableShaderKeyword(haveTiledSolution ? "TILED_FORWARD" : "REGULAR_FORWARD" );
+            cmd.SetGlobalFloat("g_isOpaquesOnlyEnabled", useFptl ? 1 : 0);      // leaving this as a dynamic toggle for now for forward opaques to keep shader variants down.
             cmd.SetGlobalBuffer("g_vLightListGlobal", useFptl ? s_LightList : s_PerVoxelLightLists);
 
             loop.ExecuteCommandBuffer(cmd);
         static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, RenderLoop loop)
         {
             var cmd = new CommandBuffer { name = "Forward Opaques - Depth Only" };
-            //cmd.SetRenderTarget(null, new RenderTargetIdentifier(s_GBufferZ));
             cmd.SetRenderTarget(new RenderTargetIdentifier(s_GBufferZ));
             loop.ExecuteCommandBuffer(cmd);
             cmd.Dispose();

Assets/ScriptableRenderLoop/fptl/Internal-DeferredReflections.shader

     g_localParams.Vworld = Vworld;
 
     uint numReflectionsProcessed = 0;
-    float3 c = ExecuteReflectionListTiled(numReflectionsProcessed, pixCoord, vP, data.normalWorld, Vworld, data.smoothness);
+    float3 c = ExecuteReflectionList(numReflectionsProcessed, pixCoord, vP, data.normalWorld, Vworld, data.smoothness);
 
     //c = OverlayHeatMap(numLightsProcessed, c);
     return float4(c,1.0);

Assets/ScriptableRenderLoop/fptl/Internal-DeferredShading.shader

     g_localParams.Vworld = Vworld;
 
     uint numLightsProcessed = 0;
-    float3 c = data.emission + ExecuteLightListTiled(numLightsProcessed, pixCoord, vP, vPw, Vworld);
+    float3 c = data.emission + ExecuteLightList(numLightsProcessed, pixCoord, vP, vPw, Vworld);
 
     //c = OverlayHeatMap(numLightsProcessed, c);
     return float4(c,1.0);

Assets/ScriptableRenderLoop/fptl/StandardTest.shader

             #pragma multi_compile DIRLIGHTMAP_OFF DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
             #pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
             #pragma multi_compile_fog
+			#pragma multi_compile TILED_FORWARD REGULAR_FORWARD
 
             #pragma vertex vertForward
             #pragma fragment fragNoLight

Assets/ScriptableRenderLoop/fptl/TiledLightingTemplate.hlsl

 
 
 
-float3 ExecuteLightListTiled(out uint numLightsProcessed, uint2 pixCoord, float3 vP, float3 vPw, float3 Vworld)
+float3 ExecuteLightList(out uint numLightsProcessed, uint2 pixCoord, float3 vP, float3 vPw, float3 Vworld)
 {
     uint nrTilesX = (g_widthRT+15)/16; uint nrTilesY = (g_heightRT+15)/16;
     uint2 tileIDX = pixCoord / 16;

Assets/ScriptableRenderLoop/fptl/TiledReflectionTemplate.hlsl

 
 
 
-float3 ExecuteReflectionListTiled(out uint numReflectionProbesProcessed, uint2 pixCoord, float3 vP, float3 vNw, float3 Vworld, float smoothness)
+float3 ExecuteReflectionList(out uint numReflectionProbesProcessed, uint2 pixCoord, float3 vP, float3 vNw, float3 Vworld, float smoothness)
 {
     uint nrTilesX = (g_widthRT+15)/16; uint nrTilesY = (g_heightRT+15)/16;
     uint2 tileIDX = pixCoord / 16;

Assets/ScriptableRenderLoop/fptl/UnityStandardForwardNew.cginc

 }
 
 
+#ifdef REGULAR_FORWARD
+
+#include "RegularForwardLightingTemplate.hlsl"
+#include "RegularForwardReflectionTemplate.hlsl"
+
+#else
+
+#endif
 
 
 half4 fragForward(VertexOutputForwardNew i) : SV_Target
 
     uint numLightsProcessed = 0, numReflectionsProcessed = 0;
     float3 res = 0;
-    res += ExecuteLightListTiled(numLightsProcessed, pixCoord, vP, vPw, Vworld);
-    res += ExecuteReflectionListTiled(numReflectionsProcessed, pixCoord, vP, gdata.normalWorld, Vworld, gdata.smoothness);
+    res += ExecuteLightList(numLightsProcessed, pixCoord, vP, vPw, Vworld);
+    res += ExecuteReflectionList(numReflectionsProcessed, pixCoord, vP, gdata.normalWorld, Vworld, gdata.smoothness);
 
     // don't really have a handle on this yet
     //UnityLight mainLight = MainLight ();

Assets/ScriptableRenderLoop/fptl/RegularForwardLightingTemplate.hlsl

+#ifndef __REGULARFORWARDLIGHTINGTEMPLATE_H__
+#define __REGULARFORWARDLIGHTINGTEMPLATE_H__
+
+
+#include "RegularForwardLightingUtils.hlsl"
+#include "LightingTemplate.hlsl"
+
+
+float3 ExecuteLightList(out uint numLightsProcessed, uint2 pixCoord, float3 vP, float3 vPw, float3 Vworld)
+{
+    uint start = 0, numLights = 0;
+	GetCountAndStart(start, numLights, DIRECT_LIGHT);
+
+    numLightsProcessed = numLights;     // mainly for debugging/heat maps
+    return ExecuteLightList(start, numLights, vP, vPw, Vworld);
+}
+
+
+#endif

Assets/ScriptableRenderLoop/fptl/RegularForwardLightingUtils.hlsl

+#ifndef __REGULARFORWARDLIGHTINGUTILS_H__
+#define __REGULARFORWARDLIGHTINGUTILS_H__
+
+
+#include "LightingUtils.hlsl"
+
+
+StructuredBuffer<SFiniteLightData> g_vLightData;
+StructuredBuffer<uint> g_vLightListMeshInst;		// build on CPU if in use. direct lights first, then reflection probes.
+
+uniform int g_numLights;
+uniform int g_numReflectionProbes;
+
+void GetCountAndStart(out uint start, out uint nrLights, uint model)
+{
+    start = model==REFLECTION_LIGHT ? g_numLights : 0;	// offset by numLights entries
+	nrLights = model==REFLECTION_LIGHT ? g_numReflectionProbes : g_numLights;
+}
+
+uint FetchIndex(const uint start, const uint l)
+{
+    return g_vLightListMeshInst[start+l];
+}
+
+#endif

Assets/ScriptableRenderLoop/fptl/RegularForwardReflectionTemplate.hlsl

+#ifndef __REGULARFORWARDREFLECTIONTEMPLATE_H__
+#define __REGULARFORWARDREFLECTIONTEMPLATE_H__
+
+
+#include "RegularForwardLightingUtils.hlsl"
+#include "ReflectionTemplate.hlsl"
+
+
+float3 ExecuteReflectionList(out uint numReflectionProbesProcessed, uint2 pixCoord, float3 vP, float3 vNw, float3 Vworld, float smoothness)
+{
+    uint start = 0, numReflectionProbes = 0;
+	GetCountAndStart(start, numReflectionProbes, REFLECTION_LIGHT);
+
+    numReflectionProbesProcessed = numReflectionProbes;     // mainly for debugging/heat maps
+    return ExecuteReflectionList(start, numReflectionProbes, vP, vNw, Vworld, smoothness);
+}
+
+#endif