AreaLight Sampler Reduction (#239)

Author: Cameron-Micka

com.microsoft.mrtk.graphicstools.unity/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this package will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.8.6] - 2025-04-21
+
+### Changed
+
+- Reduce the number of samplers AreaLights use.
+
+## [0.8.5] - 2025-04-18
+
+### Changed
+
+- Fix corrupt .meta file.
+
 ## [0.8.4] - 2025-04-03
 
 ### Changed

com.microsoft.mrtk.graphicstools.unity/Runtime/Experimental/AreaLight/AreaLight.cs

@@ -23,9 +23,7 @@ public partial class AreaLight : BaseLight, IComparable<AreaLight>
 		private const int lutMatrixDim = 3;
 		private static readonly Matrix4x4 rotation180Up = Matrix4x4.Rotate(Quaternion.AngleAxis(180.0f, Vector3.up));
 
-		private static Texture2D transformInvTextureSpecular;
-		private static Texture2D transformInvTextureDiffuse;
-		private static Texture2D ampDiffAmpSpecFresnel;
+		private static Texture2D areaLightLUTAtlas;
 
 		private static int lastAreaLightUpdate = -1;
 		private static List<AreaLight> activeAreaLights = new(maxAreaLights);
@@ -258,10 +256,16 @@ protected override void Initialize()
 				areaLightCookiesIDs[i] = Shader.PropertyToID($"_AreaLightCookie{i}");
 			}
 
-			facingID = Shader.PropertyToID("_facing");
-			uvStartsAtTopID = Shader.PropertyToID("_uvStartsAtTop");
+			facingID = Shader.PropertyToID("_Facing");
+			uvStartsAtTopID = Shader.PropertyToID("_UVStartsAtTop");
+
+			if (areaLightLUTAtlas == null)
+			{
+				areaLightLUTAtlas = CreateLUTAtlas();
+			}
+
+			Shader.SetGlobalTexture("_AreaLightLUTAtlas", areaLightLUTAtlas);
 
-			CreateLUTs();
 			UpdateLightSourceVisual();
 
 			// Only create a culling group when playing since we can't consistently dispose of them in edit mode.
@@ -522,28 +526,6 @@ private static Vector3 TransformVertex(int index, Vector2 size, Matrix4x4 localT
 			return localToWorld.MultiplyPoint(vertex);
 		}
 
-		private static void CreateLUTs()
-		{
-			if (transformInvTextureDiffuse == null)
-			{
-				transformInvTextureDiffuse = LoadLUT(LUTType.TransformInv_DisneyDiffuse);
-			}
-
-			if (transformInvTextureSpecular == null)
-			{
-				transformInvTextureSpecular = LoadLUT(LUTType.TransformInv_GGX);
-			}
-
-			if (ampDiffAmpSpecFresnel == null)
-			{
-				ampDiffAmpSpecFresnel = LoadLUT(LUTType.AmpDiffAmpSpecFresnel);
-			}
-
-			Shader.SetGlobalTexture("_TransformInvDiffuse", transformInvTextureDiffuse);
-			Shader.SetGlobalTexture("_TransformInvSpecular", transformInvTextureSpecular);
-			Shader.SetGlobalTexture("_AmpDiffAmpSpecFresnel", ampDiffAmpSpecFresnel);
-		}
-
 		private void UpdateLightSourceVisual()
 		{
 			if (drawLightSource && enabled)
@@ -598,46 +580,44 @@ private void DestroyLightVisual(bool destroyMaterial = true)
 			}
 		}
 
-		private enum LUTType
+		private static Texture2D CreateLUTAtlas()
 		{
-			TransformInv_DisneyDiffuse,
-			TransformInv_GGX,
-			AmpDiffAmpSpecFresnel
-		}
+			var diffusePixels = LoadLUT(s_LUTTransformInv_DisneyDiffuse);
+			var specularPixels = LoadLUT(s_LUTTransformInv_GGX);
+			var fresnelPixels = LoadLUT(s_LUTAmplitude_DisneyDiffuse, s_LUTAmplitude_GGX, s_LUTFresnel_GGX);
 
-		private static Texture2D LoadLUT(LUTType type)
-		{
-			switch (type)
+			// Combine all three LUTs into a single texture. Each LUT side by side.
+			//   Diffuse    Specular    Fresnel
+			// +----------+----------+----------+
+			// |          |          |          |
+			// |    XX    |    XX    |    XX    |
+			// |          |          |          |
+			// +----------+----------+----------+
+			int combinedWidth = lutResolution * 3;
+			int combinedHeight = lutResolution;
+			Texture2D combinedLUT = new Texture2D(combinedWidth, combinedHeight, TextureFormat.RGBAHalf, false, true);
+			combinedLUT.hideFlags = HideFlags.HideAndDontSave;
+			combinedLUT.wrapMode = TextureWrapMode.Clamp;
+
+			var combinedPixels = new Color[combinedWidth * combinedHeight];
+
+			for (int y = 0; y < lutResolution; y++)
 			{
-				case LUTType.TransformInv_DisneyDiffuse:
-					{
-						return LoadLUT(s_LUTTransformInv_DisneyDiffuse);
-					}
-				case LUTType.TransformInv_GGX:
-					{
-						return LoadLUT(s_LUTTransformInv_GGX);
-					}
-				case LUTType.AmpDiffAmpSpecFresnel:
-					{
-						return LoadLUT(s_LUTAmplitude_DisneyDiffuse, s_LUTAmplitude_GGX, s_LUTFresnel_GGX);
-					}
+				for (int x = 0; x < lutResolution; x++)
+				{
+					combinedPixels[y * combinedWidth + x] = diffusePixels[y * lutResolution + x];
+					combinedPixels[y * combinedWidth + x + lutResolution] = specularPixels[y * lutResolution + x];
+					combinedPixels[y * combinedWidth + x + 2 * lutResolution] = fresnelPixels[y * lutResolution + x];
+				}
 			}
 
-			return null;
-		}
-
-		private static Texture2D CreateLUT(TextureFormat format, Color[] pixels)
-		{
-			var texture = new Texture2D(lutResolution, lutResolution, format, false /*mipmap*/, true /*linear*/);
-			texture.hideFlags = HideFlags.HideAndDontSave;
-			texture.wrapMode = TextureWrapMode.Clamp;
-			texture.SetPixels(pixels);
-			texture.Apply();
+			combinedLUT.SetPixels(combinedPixels);
+			combinedLUT.Apply();
 
-			return texture;
+			return combinedLUT;
 		}
 
-		private static Texture2D LoadLUT(double[,] LUTTransformInv)
+		private static Color[] LoadLUT(double[,] LUTTransformInv)
 		{
 			const int count = lutResolution * lutResolution;
 			Color[] pixels = new Color[count];
@@ -651,10 +631,10 @@ private static Texture2D LoadLUT(double[,] LUTTransformInv)
 									  (float)LUTTransformInv[i, 6]);
 			}
 
-			return CreateLUT(TextureFormat.RGBAHalf, pixels);
+			return pixels;
 		}
 
-		private static Texture2D LoadLUT(float[] LUTScalar0, float[] LUTScalar1, float[] LUTScalar2)
+		private static Color[] LoadLUT(float[] LUTScalar0, float[] LUTScalar1, float[] LUTScalar2)
 		{
 			const int count = lutResolution * lutResolution;
 			Color[] pixels = new Color[count];
@@ -665,7 +645,7 @@ private static Texture2D LoadLUT(float[] LUTScalar0, float[] LUTScalar1, float[]
 				pixels[i] = new Color(LUTScalar0[i], LUTScalar1[i], LUTScalar2[i], 0);
 			}
 
-			return CreateLUT(TextureFormat.RGBAHalf, pixels);
+			return pixels;
 		}
 	}
 }

com.microsoft.mrtk.graphicstools.unity/Runtime/Experimental/AreaLight/Shaders/AreaLight.hlsl

@@ -6,6 +6,8 @@
 
 // Based off work from: https://github.com/Unity-Technologies/VolumetricLighting
 
+#include "HLSLSupport.cginc"
+
 #pragma multi_compile _ _AREA_LIGHT_ACTIVE _AREA_LIGHTS_ACTIVE
 
 #define AREA_LIGHT_COUNT 2
@@ -16,15 +18,18 @@
 /// Global properties.
 /// </summary>
 
-#if defined(AREA_LIGHT_ENABLE_DIFFUSE)
-sampler2D _TransformInvDiffuse;
-#endif // AREA_LIGHT_ENABLE_DIFFUSE
-sampler2D _TransformInvSpecular;
-sampler2D _AmpDiffAmpSpecFresnel;
+// LUTs are atlased in the following order:
+//   Diffuse    Specular    Fresnel
+// +----------+----------+----------+
+// |          |          |          |
+// |    XX    |    XX    |    XX    |
+// |          |          |          |
+// +----------+----------+----------+
+UNITY_DECLARE_TEX2D(_AreaLightLUTAtlas);
 
 // Shader.SetGlobalTexture…Array(…) does not exist, so this is the best we can do.
-sampler2D _AreaLightCookie0;
-sampler2D _AreaLightCookie1;
+UNITY_DECLARE_TEX2D(_AreaLightCookie0);
+UNITY_DECLARE_TEX2D_NOSAMPLER(_AreaLightCookie1); // Reuse _AreaLightCookie0's sampler.
 
 float4 _AreaLightData[AREA_LIGHT_COUNT * AREA_LIGHT_DATA_SIZE];
 float4x4 _AreaLightVerts[AREA_LIGHT_COUNT];
@@ -46,14 +51,14 @@ half4 SampleAreaLightCookie(in int lightIndex, in float2 uv)
 	switch (lightIndex)
 	{
 		case 0:
-			return tex2D(_AreaLightCookie0, uv);
+			return UNITY_SAMPLE_TEX2D(_AreaLightCookie0, uv);
 		case 1:
-			return tex2D(_AreaLightCookie1, uv);
+			return UNITY_SAMPLE_TEX2D_SAMPLER(_AreaLightCookie1, _AreaLightCookie0, uv);
 		default:
 			return half4(1, 1, 1, 1);
 	}
 #else
-	return tex2D(_AreaLightCookie0, uv);
+	return UNITY_SAMPLE_TEX2D(_AreaLightCookie0, uv);
 #endif // _AREA_LIGHTS_ACTIVE
 }
 
@@ -101,7 +106,7 @@ float3 IntegrateEdge(in float3 v1, in float3 v2)
 	return cross(v1, v2) * theta_sintheta;
 }
 
-float4 PolygonRadiance(in int lightIndex, in float4x3 L)
+float3 PolygonRadiance(in int lightIndex, in float4x3 L)
 {
 	// Baum's equation
 	// Expects non-normalized vertex positions
@@ -260,25 +265,31 @@ float4 PolygonRadiance(in int lightIndex, in float4x3 L)
 	}
 
 	float3 direction = normalize(sum);
-	return float4(max(0, sum.z * 0.15915) * SampleDiffuseFilteredTexture(lightIndex, unclippedL, direction), direction.z);
+	sum.z = max(0, sum.z * 0.15915); // 1 / (2 * Pi).
+	return SampleDiffuseFilteredTexture(lightIndex, unclippedL, direction) * sum.z;
+}
+
+half4 SampleAtlas(in float2 uv, in half index)
+{
+	return UNITY_SAMPLE_TEX2D(_AreaLightLUTAtlas, float2(uv.x / 3.0 + (index / 3.0), uv.y));
 }
 
-half4 TransformedPolygonRadiance(in int lightIndex, 
+half3 TransformedPolygonRadiance(in int lightIndex, 
 								 in float4x3 L, 
 								 in float2 uv, 
-								 in sampler2D transformInv, 
+								 in half transformIndex,
 								 in float amplitude)
 {
 	// Get the inverse LTC matrix M.
 	float3x3 Minv = 0;
 	Minv._m22 = 1;
-	Minv._m00_m02_m11_m20 = tex2D(transformInv, uv);
+	Minv._m00_m02_m11_m20 = SampleAtlas(uv, transformIndex);
 
 	// Transform light vertices into diffuse configuration.
 	float4x3 LTransformed = mul(L, Minv);
 
 	// Polygon radiance in transformed configuration - specular.
-	return PolygonRadiance(lightIndex, LTransformed) * float4(amplitude.xxx, 1);
+	return PolygonRadiance(lightIndex, LTransformed) * amplitude.xxx;
 }
 
 void CalculateAreaLight(in float3 worldPosition,
@@ -308,17 +319,17 @@ void CalculateAreaLight(in float3 worldPosition,
 
 	// UVs for sampling the LUTs.
 	float theta = acos(dot(V, worldNormal));
-	half2 uv = half2(roughness, theta / 1.57);
+	half2 uv = half2(roughness, theta / 1.57); // Half Pi.
 
-	half3 AmpDiffAmpSpecFresnel = tex2D(_AmpDiffAmpSpecFresnel, uv).rgb;
+	half3 AmpDiffAmpSpecFresnel = SampleAtlas(uv, 2).rgb;
 
 	half3 result = 0;
 #if defined(AREA_LIGHT_ENABLE_DIFFUSE)
-	half3 diffuseTerm = TransformedPolygonRadiance(lightIndex, L, uv, _TransformInvDiffuse, AmpDiffAmpSpecFresnel.x);
+	half3 diffuseTerm = TransformedPolygonRadiance(lightIndex, L, uv, 0, AmpDiffAmpSpecFresnel.x);
 	result = diffuseTerm * baseColor;
 #endif // AREA_LIGHT_ENABLE_DIFFUSE
 
-	half3 specularTerm = TransformedPolygonRadiance(lightIndex, L, uv, _TransformInvSpecular, AmpDiffAmpSpecFresnel.y);
+	half3 specularTerm = TransformedPolygonRadiance(lightIndex, L, uv, 1, AmpDiffAmpSpecFresnel.y);
 	half3 fresnelTerm = (half) (specularColor + (1.0 - specularColor) * AmpDiffAmpSpecFresnel.z);
 	result += specularTerm * fresnelTerm * 3.14159265359; // Pi.
 

com.microsoft.mrtk.graphicstools.unity/Runtime/Experimental/AreaLight/Shaders/AreaLightVisualize.shader

@@ -41,8 +41,8 @@ Shader "Hidden/Graphics Tools/Experimental/Area Light Visualize"
 			CBUFFER_START(UnityPerMaterial)
 			fixed4 _Color;
 			float4 _MainTex_ST;
-			float _facing;
-			float _uvStartsAtTop;
+			float _Facing;
+			float _UVStartsAtTop;
 			CBUFFER_END
 
 			v2f vert (appdata_t input)
@@ -57,10 +57,10 @@ Shader "Hidden/Graphics Tools/Experimental/Area Light Visualize"
 
 			fixed4 frag (v2f input, bool facing : SV_IsFrontFace) : SV_Target
 			{
-				facing = _facing ? !facing : facing;
+				facing = _Facing ? !facing : facing;
 				float2 texcoord = input.texcoord;
-				texcoord.x = abs(_facing - texcoord.x);
-				texcoord.y = abs(_uvStartsAtTop - texcoord.y);
+				texcoord.x = abs(_Facing - texcoord.x);
+				texcoord.y = abs(_UVStartsAtTop - texcoord.y);
 				fixed4 output = facing ? tex2D(_MainTex, texcoord) : fixed4(0.05, 0.05, 0.05, 1.0);
 				UNITY_OPAQUE_ALPHA(output.a);
 				return output * _Color;

com.microsoft.mrtk.graphicstools.unity/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.microsoft.mrtk.graphicstools.unity",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "displayName": "MRTK Graphics Tools",
   "description": "Graphics tools and components for developing Mixed Reality applications in Unity.",
   "documentationUrl": "https://aka.ms/mrtk3graphics",