| // Take from here: | |
| // https://github.com/shrekshao/webgpu-deferred-renderer/blob/4f8bf0910793100aa8d60dbd1319bddb5357b1fa/renderer/LightCulling.js | |
| // With these token replacements: | |
| // $NUM_TILE_LIGHT_SLOT = 64 | |
| // $NUM_TILES = 4 | |
| // $TILE_COUNT_Y = 2 | |
| // $TILE_COUNT_X = 2 | |
| // $TILE_SIZE = 16 | |
| struct LightData { | |
| position : vec4<f32>, | |
| color : vec3<f32>, | |
| radius : f32, | |
| }; | |
| struct LightsBuffer { | |
| lights: array<LightData>, | |
| }; | |
| @group(0) @binding(0) var<storage, read_write> lightsBuffer: LightsBuffer; | |
| struct TileLightIdData { | |
| count: atomic<u32>, | |
| lightId: array<u32, 64>, | |
| }; | |
| struct Tiles { | |
| data: array<TileLightIdData, 4>, | |
| }; | |
| @group(1) @binding(0) var<storage, read_write> tileLightId: Tiles; | |
| struct Config { | |
| numLights : u32, | |
| numTiles : u32, | |
| tileCountX : u32, | |
| tileCountY : u32, | |
| numTileLightSlot : u32, | |
| tileSize : u32, | |
| }; | |
| @group(2) @binding(0) var<uniform> config: Config; | |
| struct Uniforms { | |
| min : vec4<f32>, | |
| max : vec4<f32>, | |
| // camera | |
| viewMatrix : mat4x4<f32>, | |
| projectionMatrix : mat4x4<f32>, | |
| // Tile info | |
| fullScreenSize : vec4<f32>, // width, height | |
| }; | |
| @group(3) @binding(0) var<uniform> uniforms: Uniforms; | |
| @compute @workgroup_size(64, 1, 1) | |
| fn main(@builtin(global_invocation_id) GlobalInvocationID : vec3<u32>) { | |
| var index = GlobalInvocationID.x; | |
| if (index >= config.numLights) { | |
| return; | |
| } | |
| // Light position updating | |
| lightsBuffer.lights[index].position.y = lightsBuffer.lights[index].position.y - 0.1 + 0.001 * (f32(index) - 64.0 * floor(f32(index) / 64.0)); | |
| if (lightsBuffer.lights[index].position.y < uniforms.min.y) { | |
| lightsBuffer.lights[index].position.y = uniforms.max.y; | |
| } | |
| // Light culling | |
| // Implementation here is Tiled without per tile min-max depth | |
| // You could also implement cluster culling | |
| // Feel free to add more compute passes if necessary | |
| // some math reference: http://www.txutxi.com/?p=444 | |
| var M: mat4x4<f32> = uniforms.projectionMatrix; | |
| var viewNear: f32 = - M[3][2] / ( -1.0 + M[2][2]); | |
| var viewFar: f32 = - M[3][2] / (1.0 + M[2][2]); | |
| var lightPos = lightsBuffer.lights[index].position; | |
| lightPos = uniforms.viewMatrix * lightPos; | |
| lightPos = lightPos / lightPos.w; | |
| var lightRadius: f32 = lightsBuffer.lights[index].radius; | |
| var boxMin: vec4<f32> = lightPos - vec4<f32>(vec3<f32>(lightRadius), 0.0); | |
| var boxMax: vec4<f32> = lightPos + vec4<f32>(vec3<f32>(lightRadius), 0.0); | |
| var frustumPlanes: array<vec4<f32>, 6>; | |
| frustumPlanes[4] = vec4<f32>(0.0, 0.0, -1.0, viewNear); // near | |
| frustumPlanes[5] = vec4<f32>(0.0, 0.0, 1.0, -viewFar); // far | |
| let TILE_SIZE: i32 = 16; | |
| let TILE_COUNT_X: i32 = 2; | |
| let TILE_COUNT_Y: i32 = 2; | |
| for (var y : i32 = 0; y < TILE_COUNT_Y; y = y + 1) { | |
| for (var x : i32 = 0; x < TILE_COUNT_X; x = x + 1) { | |
| var tilePixel0Idx : vec2<i32> = vec2<i32>(x * TILE_SIZE, y * TILE_SIZE); | |
| // tile position in NDC space | |
| var floorCoord: vec2<f32> = 2.0 * vec2<f32>(tilePixel0Idx) / uniforms.fullScreenSize.xy - vec2<f32>(1.0); // -1, 1 | |
| var ceilCoord: vec2<f32> = 2.0 * vec2<f32>(tilePixel0Idx + vec2<i32>(TILE_SIZE)) / uniforms.fullScreenSize.xy - vec2<f32>(1.0); // -1, 1 | |
| var viewFloorCoord: vec2<f32> = vec2<f32>( (- viewNear * floorCoord.x - M[2][0] * viewNear) / M[0][0] , (- viewNear * floorCoord.y - M[2][1] * viewNear) / M[1][1] ); | |
| var viewCeilCoord: vec2<f32> = vec2<f32>( (- viewNear * ceilCoord.x - M[2][0] * viewNear) / M[0][0] , (- viewNear * ceilCoord.y - M[2][1] * viewNear) / M[1][1] ); | |
| frustumPlanes[0] = vec4<f32>(1.0, 0.0, - viewFloorCoord.x / viewNear, 0.0); // left | |
| frustumPlanes[1] = vec4<f32>(-1.0, 0.0, viewCeilCoord.x / viewNear, 0.0); // right | |
| frustumPlanes[2] = vec4<f32>(0.0, 1.0, - viewFloorCoord.y / viewNear, 0.0); // bottom | |
| frustumPlanes[3] = vec4<f32>(0.0, -1.0, viewCeilCoord.y / viewNear, 0.0); // top | |
| var dp: f32 = 0.0; // dot product | |
| for (var i: u32 = 0u; i < 6u; i = i + 1u) | |
| { | |
| var p: vec4<f32>; | |
| if (frustumPlanes[i].x > 0.0) { | |
| p.x = boxMax.x; | |
| } else { | |
| p.x = boxMin.x; | |
| } | |
| if (frustumPlanes[i].y > 0.0) { | |
| p.y = boxMax.y; | |
| } else { | |
| p.y = boxMin.y; | |
| } | |
| if (frustumPlanes[i].z > 0.0) { | |
| p.z = boxMax.z; | |
| } else { | |
| p.z = boxMin.z; | |
| } | |
| p.w = 1.0; | |
| dp = dp + min(0.0, dot(p, frustumPlanes[i])); | |
| } | |
| if (dp >= 0.0) { | |
| // light is overlapping with the tile | |
| var tileId: u32 = u32(x + y * TILE_COUNT_X); | |
| if (tileId < 0u || tileId >= config.numTiles) { | |
| continue; | |
| } | |
| var offset: u32 = atomicAdd(&(tileLightId.data[tileId].count), 1u); | |
| if (offset >= config.numTileLightSlot) { | |
| continue; | |
| } | |
| tileLightId.data[tileId].lightId[offset] = GlobalInvocationID.x; | |
| } | |
| } | |
| } | |
| } |