Shader optimizations/light indexing 16bitpacked

Author: Paulm-Unity

Packages/com.unity.render-pipelines.universal/ShaderLibrary/RealtimeLights.hlsl

@@ -195,39 +195,28 @@ uint GetPerObjectLightIndexOffset()
 // This abstract the underlying data implementation for storing lights/light indices
 int GetPerObjectLightIndex(uint index)
 {
+#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Structured Buffer Path                                                                   /
 //                                                                                          /
 // Lights and light indices are stored in StructuredBuffer. We can just index them.         /
 // Currently all non-mobile platforms take this path :(                                     /
 // There are limitation in mobile GPUs to use SSBO (performance / no vertex shader support) /
 /////////////////////////////////////////////////////////////////////////////////////////////
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
     uint offset = uint(unity_LightData.x);
     return _AdditionalLightsIndices[offset + index];
-
+#else
 /////////////////////////////////////////////////////////////////////////////////////////////
 // UBO path                                                                                 /
 //                                                                                          /
-// We store 8 light indices in half4 unity_LightIndices[2];                                 /
-// Due to memory alignment unity doesn't support int[] or float[]                           /
-// Even trying to reinterpret cast the unity_LightIndices to float[] won't work             /
-// it will cast to float4[] and create extra register pressure. :(                          /
+// We pack 8 x 16bit uint light indices into float4 unity_PackedLightIndices;               /
+// light index 0 is packed into lower 16 bits of unity_PackedLightIndices.x,                /
+// light index 1 is packed into high 16 bits of unity_PackedLightIndices.x and so on        /
 /////////////////////////////////////////////////////////////////////////////////////////////
-#else
-    // since index is uint shader compiler will implement
-    // div & mod as bitfield ops (shift and mask).
-
-    // TODO: Can we index a float4? Currently compiler is
-    // replacing unity_LightIndicesX[i] with a dp4 with identity matrix.
-    // u_xlat16_40 = dot(unity_LightIndices[int(u_xlatu13)], ImmCB_0_0_0[u_xlati1]);
-    // This increases both arithmetic and register pressure.
-    //
-    // NOTE: min16float4 bug workaround.
-    // Take the "vec4" part into float4 tmp variable in order to force float4 math.
-    // It appears indexing half4 as min16float4 on DX11 can fail. (dp4 {min16f})
-    float4 tmp = unity_LightIndices[index / 4];
-    return int(tmp[index % 4]);
+    uint4 packed4 = asuint(unity_PackedLightIndices);
+    uint2 pair = index >= 4 ? packed4.zw : packed4.xy;
+    uint word = (index & 2) ? pair.y : pair.x;
+    return (word >> ((index & 1) << 4)) & 0xFFFF;    
 #endif
 }
 

Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityInput.hlsl

@@ -120,8 +120,8 @@ float4 unity_RenderingLayer;
 
 // Light Indices block feature
 // These are set internally by the engine upon request by RendererConfiguration.
+float4 unity_PackedLightIndices;
 half4 unity_LightData;
-half4 unity_LightIndices[2];
 
 float4 unity_ProbesOcclusion;
 

Packages/com.unity.render-pipelines.universal/ShaderLibrary/UniversalDOTSInstancing.hlsl

@@ -48,7 +48,7 @@ UNITY_DOTS_INSTANCING_END(BuiltinPropertyMetadata)
 
 // Not supported by BatchRendererGroup. Just define them as constants.
 // ------------------------------------------------------------------------------
-static const float2x4 unity_LightIndices = float2x4(0,0,0,0, 0,0,0,0);
+static const float4 unity_PackedLightIndices = float4(0,0,0,0);
 
 static const float4 unity_SpecCube0_BoxMax = float4(1,1,1,1);
 static const float4 unity_SpecCube0_BoxMin = float4(0,0,0,0);

Packages/com.unity.shadergraph/Editor/Generation/Targets/BuiltIn/ShaderLibrary/Lighting.hlsl

@@ -202,34 +202,28 @@ int GetPerObjectLightIndex(uint index)
 {
 
 #ifndef BUILTIN_TARGET_API
+#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
 /////////////////////////////////////////////////////////////////////////////////////////////
 // Structured Buffer Path                                                                   /
 //                                                                                          /
 // Lights and light indices are stored in StructuredBuffer. We can just index them.         /
 // Currently all non-mobile platforms take this path :(                                     /
 // There are limitation in mobile GPUs to use SSBO (performance / no vertex shader support) /
 /////////////////////////////////////////////////////////////////////////////////////////////
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
-    uint offset = unity_LightData.x;
+    uint offset = uint(unity_LightData.x);
     return _AdditionalLightsIndices[offset + index];
-
+#else
 /////////////////////////////////////////////////////////////////////////////////////////////
 // UBO path                                                                                 /
 //                                                                                          /
-// We store 8 light indices in float4 unity_LightIndices[2];                                /
-// Due to memory alignment unity doesn't support int[] or float[]                           /
-// Even trying to reinterpret cast the unity_LightIndices to float[] won't work             /
-// it will cast to float4[] and create extra register pressure. :(                          /
+// We pack 8 x 16bit uint light indices into float4 unity_packedLightIndices;               /
+// light index 0 is packed into lower 16 bits of unity_packedLightIndices.x,                /
+// light index 1 is packed into high 16 bits of unity_packedLightIndices.x and so on        /
 /////////////////////////////////////////////////////////////////////////////////////////////
-#else
-    // since index is uint shader compiler will implement
-    // div & mod as bitfield ops (shift and mask).
-
-    // TODO: Can we index a float4? Currently compiler is
-    // replacing unity_LightIndicesX[i] with a dp4 with identity matrix.
-    // u_xlat16_40 = dot(unity_LightIndices[int(u_xlatu13)], ImmCB_0_0_0[u_xlati1]);
-    // This increases both arithmetic and register pressure.
-    return unity_LightIndices[index / 4][index % 4];
+    uint4 packed4 = asuint(unity_PackedLightIndices);
+    uint2 pair = index >= 4 ? packed4.zw : packed4.xy;
+    uint word = (index & 2) ? pair.y : pair.x;
+    return (word >> ((index & 1) << 4)) & 0xFFFF;
 #endif
 #else
     return 0;

Packages/com.unity.shadergraph/Editor/Generation/Targets/BuiltIn/ShaderLibrary/UnityInput.hlsl

@@ -107,8 +107,8 @@ real4 unity_WorldTransformParams; // w is usually 1.0, or -1.0 for odd-negative
 
 // Light Indices block feature
 // These are set internally by the engine upon request by RendererConfiguration.
+float4 unity_PackedLightIndices;
 real4 unity_LightData;
-real4 unity_LightIndices[2];
 
 float4 unity_ProbesOcclusion;