WIP: light culling, shadow

Author: sheazywi

Core/Source/Lux/Renderer/Renderer.cpp

@@ -812,6 +812,13 @@ namespace Lux {
 			});
 	}
 
+	void Renderer::LightCulling(Ref<RenderCommandBuffer> renderCommandBuffer, Ref<ComputePass> computePass, Ref<Material> material, const glm::uvec3& workGroups)
+	{
+		Renderer::BeginComputePass(renderCommandBuffer, computePass);
+		Renderer::DispatchCompute(renderCommandBuffer, computePass, material, workGroups);
+		Renderer::EndComputePass(renderCommandBuffer, computePass);
+	}
+
 	void Renderer::BeginGPUPerfMarker(Ref<RenderCommandBuffer> renderCommandBuffer, const std::string& label, const glm::vec4& markerColor)
 	{
 		Renderer::Submit([renderCommandBuffer, s = label]() mutable

Core/Source/Lux/Renderer/SceneRenderer.cpp

@@ -4,7 +4,9 @@
 #include "Lux/Renderer/Camera.h"
 #include "Lux/Renderer/RenderCommandBuffer.h"
 #include "Lux/Renderer/RenderPass.h"
+#include "Lux/Renderer/ComputePass.h"
 #include "Lux/Renderer/Pipeline.h"
+#include "Lux/Renderer/PipelineCompute.h"
 #include "Lux/Renderer/Framebuffer.h"
 #include "Lux/Renderer/Material.h"
 #include "Lux/Renderer/Mesh.h"
@@ -138,6 +140,9 @@ namespace Lux {
 	class SceneRenderer : public RefCounted
 	{
 	public:
+		static constexpr uint32_t MaxSpotShadows = 16;
+		static constexpr uint32_t LightCullingTileSize = 16;
+		static constexpr uint32_t MaxVisibleLightsPerTile = 256;
 		struct Statistics
 		{
 			uint32_t DrawCalls = 0;
@@ -279,19 +284,23 @@ namespace Lux {
 		void FlushDrawList();
 
 		void ShadowMapPass();
+		void SpotShadowMapPass();
 		void PreDepthPass();
+		void LightCullingPass();
 		void SkyboxPass();
 		void GeometryPass();
 		void CompositePass();
 		void GridPass();
 
 		void UpdateStatistics();
+		void ResizeLightCullingResources();
 
 		// Render-thread draw helper (must be called inside Renderer::Submit).
 		void RT_DrawStaticMesh(Ref<RenderCommandBuffer> cmd,
 			const StaticDrawCommand& dc,
 			const TransformMapData& tmd,
-			bool                     bindMaterial);
+			bool                     bindMaterial,
+			uint32_t                 lightIndex = 0);
 
 		// ── Uniform buffer GPU structs ────────────────────────────────────────
 
@@ -332,10 +341,10 @@ namespace Lux {
 
 		struct UBSpotShadow
 		{
-			glm::mat4 ViewProjection[16];
+			glm::mat4 ViewProjection[MaxSpotShadows];
 			uint32_t Count = 0;
 			glm::vec3 Padding{};
-		};
+		} m_SpotShadowUB;
 
 		struct UBRendererData
 		{
@@ -355,6 +364,14 @@ namespace Lux {
 			char      Pad3[3] = { 0, 0, 0 };
 		} m_RendererDataUB;
 
+		struct UBScreenData
+		{
+			glm::vec2 InvFullResolution = { 1.0f, 1.0f };
+			glm::vec2 FullResolution = { 1.0f, 1.0f };
+			glm::vec2 InvHalfResolution = { 1.0f, 1.0f };
+			glm::vec2 HalfResolution = { 1.0f, 1.0f };
+		} m_ScreenDataUB;
+
 		struct UBPointLights
 		{
 			uint32_t   Count = 0;
@@ -397,24 +414,40 @@ namespace Lux {
 		Ref<UniformBufferSet> m_UBSShadow;
 		Ref<UniformBufferSet> m_UBSSpotShadow;
 		Ref<UniformBufferSet> m_UBSRendererData;
+		Ref<UniformBufferSet> m_UBSScreenData;
 		Ref<UniformBufferSet> m_UBSPointLights;
 		Ref<UniformBufferSet> m_UBSSpotLights;
 
 		Ref<StorageBufferSet> m_SBSInstanceTransforms;  // TransformVertexData[]
 		Ref<StorageBufferSet> m_SBSObjectIndexes;       // uint32_t[] – maps draw → transform
 		Ref<StorageBufferSet> m_SBSVisiblePointLightIndices;
 		Ref<StorageBufferSet> m_SBSVisibleSpotLightIndices;
+		uint32_t              m_LightTilesCountX = 1;
+		uint32_t              m_LightTilesCountY = 1;
+		uint32_t              m_VisibleLightIndexBufferSize = 0;
 
 		// ── Shadow map (single ortho cascade) ────────────────────────────────
 		Ref<Image2D>     m_ShadowMapImage;
 		Ref<RenderPass>  m_ShadowMapPass;
 		Ref<Material>    m_ShadowPassMaterial;
 
+		// ── Spot shadow atlas ───────────────────────────────────────────────
+		Ref<Image2D>     m_SpotShadowMapImage;
+		Ref<RenderPass>  m_SpotShadowMapPass;
+		Ref<Material>    m_SpotShadowPassMaterial;
+		uint32_t         m_SpotShadowMapSize = 2048;
+		uint32_t         m_SpotShadowAtlasGridSize = 1;
+		uint32_t         m_SpotShadowTileSize = 2048;
+		uint32_t         m_SpotShadowCount = 0;
+
 		// ── Pre-depth pass ────────────────────────────────────────────────────
 		Ref<Pipeline>    m_PreDepthPipeline;
 		Ref<Material>    m_PreDepthMaterial;
 		Ref<RenderPass>  m_PreDepthPass;
 
+		// ── Tiled light culling ──────────────────────────────────────────────
+		Ref<ComputePass> m_LightCullingPass;
+
 		// ── Geometry pass ─────────────────────────────────────────────────────
 		Ref<Framebuffer> m_GeometryPassFramebuffer;     // owns the attachments
 		Ref<Pipeline>    m_GeometryPipeline;            // opaque PBR

Core/Source/Lux/Renderer/SceneRenderer.h

@@ -69,7 +69,9 @@ layout(std140, set = 1, binding = 7) uniform SpotLightData
 
 layout(std140, set = 1, binding = 8) uniform SpotShadowData
 {
-	mat4 Mats[1024];
+	mat4 Mats[16];
+	uint Count;
+	vec3 Padding;
 } u_SpotLightMatrices;
 
 /*layout(std430, set = 1, binding = 9) readonly buffer VisiblePointLightIndicesBuffer

Editor/Resources/Shaders/Include/GLSL/Buffers.glslh

@@ -14,6 +14,9 @@ layout(std430, set = 1, binding = 10) readonly buffer VisibleSpotLightIndicesBuf
 	int Indices[];
 } s_VisibleSpotLightIndicesBuffer;
 
+const int LIGHT_CULLING_TILE_SIZE = 16;
+const int MAX_VISIBLE_LIGHTS_PER_TILE = 256;
+
 // Used in PBR shader
 struct PBRParameters
 {
@@ -64,25 +67,43 @@ vec3 CalculateDirLights(vec3 F0)
 
 int GetPointLightBufferIndex(int i)
 {
-	// Lux does not currently dispatch the Hazel-style light-culling pass, so
-	// fall back to iterating the uploaded point-light array directly.
-	return i;
+	if (u_RendererData.TilesCountX == 0)
+		return i;
+
+	ivec2 tileID = ivec2(gl_FragCoord.xy) / LIGHT_CULLING_TILE_SIZE;
+	tileID.x = clamp(tileID.x, 0, int(u_RendererData.TilesCountX) - 1);
+	int tileIndex = tileID.y * int(u_RendererData.TilesCountX) + tileID.x;
+	return s_VisiblePointLightIndicesBuffer.Indices[tileIndex * MAX_VISIBLE_LIGHTS_PER_TILE + i];
 }
 
 int GetPointLightCount()
 {
-	return int(u_PointLights.LightCount);
+	if (u_RendererData.TilesCountX == 0)
+		return int(u_PointLights.LightCount);
+
+	int result = 0;
+	for (int i = 0; i < MAX_VISIBLE_LIGHTS_PER_TILE; i++)
+	{
+		if (GetPointLightBufferIndex(i) < 0)
+			break;
+
+		result++;
+	}
+
+	return result;
 }
 
 vec3 CalculatePointLights(in vec3 F0, vec3 worldPos)
 {
 	vec3 result = vec3(0.0);
-	for (int i = 0; i < u_PointLights.LightCount; i++)
+	for (int i = 0; i < GetPointLightCount(); i++)
 	{
-		uint lightIndex = GetPointLightBufferIndex(i);
-		if (lightIndex == -1)
+		int visibleIndex = GetPointLightBufferIndex(i);
+		if (visibleIndex < 0)
 			break;
 
+		uint lightIndex = uint(visibleIndex);
+
 		PointLight light = u_PointLights.Lights[lightIndex];
 		vec3 Li = normalize(light.Position - worldPos);
 		float lightDistance = length(light.Position - worldPos);
@@ -119,32 +140,50 @@ vec3 CalculatePointLights(in vec3 F0, vec3 worldPos)
 
 int GetSpotLightBufferIndex(int i)
 {
-	// Lux does not currently dispatch the Hazel-style light-culling pass, so
-	// fall back to iterating the uploaded spot-light array directly.
-	return i;
+	if (u_RendererData.TilesCountX == 0)
+		return i;
+
+	ivec2 tileID = ivec2(gl_FragCoord.xy) / LIGHT_CULLING_TILE_SIZE;
+	tileID.x = clamp(tileID.x, 0, int(u_RendererData.TilesCountX) - 1);
+	int tileIndex = tileID.y * int(u_RendererData.TilesCountX) + tileID.x;
+	return s_VisibleSpotLightIndicesBuffer.Indices[tileIndex * MAX_VISIBLE_LIGHTS_PER_TILE + i];
 }
 
 
 int GetSpotLightCount()
 {
-	return int(u_SpotLights.LightCount);
+	if (u_RendererData.TilesCountX == 0)
+		return int(u_SpotLights.LightCount);
+
+	int result = 0;
+	for (int i = 0; i < MAX_VISIBLE_LIGHTS_PER_TILE; i++)
+	{
+		if (GetSpotLightBufferIndex(i) < 0)
+			break;
+
+		result++;
+	}
+
+	return result;
 }
 
 vec3 CalculateSpotLights(in vec3 F0, vec3 worldPos)
 {
 	vec3 result = vec3(0.0);
-	for (int i = 0; i < u_SpotLights.LightCount; i++)
+	for (int i = 0; i < GetSpotLightCount(); i++)
 	{
-		uint lightIndex = GetSpotLightBufferIndex(i); 
-		if (lightIndex == -1)
+		int visibleIndex = GetSpotLightBufferIndex(i);
+		if (visibleIndex < 0)
 			break;
 
+		uint lightIndex = uint(visibleIndex);
+
 		SpotLight light = u_SpotLights.Lights[lightIndex];
 		vec3 Li = normalize(light.Position - worldPos);
 		float lightDistance = length(light.Position - worldPos);
 
 		float cutoff = cos(radians(light.Angle * 0.5f));
-		float scos = max(dot(Li, light.Direction), cutoff);
+		float scos = max(dot(-Li, normalize(light.Direction)), cutoff);
 		float rim = (1.0 - scos) / (1.0 - cutoff);
 
 		float attenuation = clamp(1.0 - (lightDistance * lightDistance) / (light.Range * light.Range), 0.0, 1.0);

Editor/Resources/Shaders/Include/GLSL/Lighting.glslh

@@ -301,28 +301,33 @@ float PCSS_SpotLight(texture2D shadowMap, vec2 atlasOffset, float atlasScale, ve
 vec3 CalculateSpotLightsShadowed(in vec3 F0, vec3 worldPos, texture2D SpotAtlas)
 {
 	vec3 result = vec3(0.0);
-	for (int i = 0; i < u_SpotLights.LightCount; i++)
+	for (int i = 0; i < GetSpotLightCount(); i++)
 	{
-		uint lightIndex = GetSpotLightBufferIndex(i);
-		if (lightIndex == -1)
+		int visibleIndex = GetSpotLightBufferIndex(i);
+		if (visibleIndex < 0)
 			break;
 
+		uint lightIndex = uint(visibleIndex);
+
 		SpotLight light = u_SpotLights.Lights[lightIndex];
 		vec3 Li = normalize(light.Position - worldPos);
 		float lightDistance = length(light.Position - worldPos);
 
 		float cutoff = cos(radians(light.Angle * 0.5f));
-		float scos = max(dot(Li, light.Direction), cutoff);
+		float scos = max(dot(-Li, normalize(light.Direction)), cutoff);
 		float rim = (1.0 - scos) / (1.0 - cutoff);
 
 		float attenuation = clamp(1.0 - (lightDistance * lightDistance) / (light.Range * light.Range), 0.0, 1.0);
 		attenuation *= mix(attenuation, 1.0, light.Falloff);
 		attenuation *= 1.0 - pow(max(rim, 0.001), light.AngleAttenuation);
 
 		// Shadow sampling - supports up to 16 spotlights with dynamic atlas
-		if(light.CastsShadows && light.ShadowIndex < 16)
+		if(light.CastsShadows && light.ShadowIndex < 16 && light.ShadowIndex < u_SpotLightMatrices.Count)
 		{
 			vec4 coords = u_SpotLightMatrices.Mats[light.ShadowIndex] * vec4(worldPos, 1.0f);
+			if (coords.w <= 0.0f)
+				continue;
+
 			vec3 shadowMapCoords = (coords.xyz / coords.w);
 			// Flip Y to compensate for NVRHI viewport Y-axis inversion
 			shadowMapCoords.xy = ShadowCoordsToUV(shadowMapCoords.xy);