nice

Author: Aaron Ma

examples/49_compute_splatter/binning.comp

@@ -42,6 +42,7 @@ layout(push_constant) uniform PushConstants {
 
 layout (local_size_x = 256) in;
 
+// --- UTILS ---
 float hash(uint x) {
     x = ((x >> 16) ^ x) * 0x45d9f3b;
     x = ((x >> 16) ^ x) * 0x45d9f3b;
@@ -54,6 +55,11 @@ float get_noise(uint seed) {
     return fract(raw + hash(seed));
 }
 
+vec3 safe_normalize(vec3 v) {
+    float len = length(v);
+    return len > 0.00001 ? v / len : vec3(0, 1, 0);
+}
+
 vec4 quatFromDir(vec3 dir) {
     vec3 v = normalize(dir);
     vec3 up = abs(v.y) > 0.9 ? vec3(1,0,0) : vec3(0,1,0);
@@ -81,88 +87,132 @@ vec3 computeCov2D(vec3 pos_view, vec3 scale, vec4 rot) {
     mat3 R = quatToMat3(rot);
     mat3 S = mat3(scale.x, 0, 0, 0, scale.y, 0, 0, 0, scale.z);
     mat3 Sigma3D = (R * S) * transpose(R * S);
-    float x = pos_view.x, y = pos_view.y, z = -pos_view.z; // Use positive depth
+    float x = pos_view.x, y = pos_view.y, z = -pos_view.z;
     mat3 J = mat3(pc.focal/z, 0, -(pc.focal*x)/(z*z), 0, pc.focal/z, -(pc.focal*y)/(z*z), 0, 0, 0);
     mat3 Sigma2D = J * mat3(pc.view) * Sigma3D * transpose(mat3(pc.view)) * transpose(J);
     return vec3(Sigma2D[0][0] + 0.3, Sigma2D[0][1], Sigma2D[1][1] + 0.3);
 }
 
-void splatCylinder(uint i, uint count, vec3 base, vec3 top, float radius, inout vec3 pos, inout vec3 scale, inout vec4 rot) {
+// --- SYMBOLIC PRIMITIVES ---
+
+void splatCylinder(uint i, uint count, vec3 base, vec3 top, float radius, float jitter, inout vec3 pos, inout vec3 scale, inout vec4 rot) {
     vec3 dir = top - base;
-    pos = base + normalize(dir) * (float(i)/float(count)) * length(dir);
-    scale = vec3(radius, radius, radius * 1.5);
+    float h = (float(i)/float(count));
+    // Add radial jitter to turn the line into a tube
+    float angle = get_noise(i + 500) * 6.28;
+    float r = radius * pow(get_noise(i + 600), 0.5);
+    vec3 tangent = normalize(abs(dir.y) > 0.9 ? vec3(1,0,0) : vec3(0,1,0));
+    tangent = normalize(cross(dir, tangent));
+    vec3 bitangent = cross(dir, tangent);
+    
+    pos = base + dir * h + (tangent * cos(angle) + bitangent * sin(angle)) * r;
+    scale = vec3(radius * 0.5 + jitter); // Thicker splats
     rot = quatFromDir(dir);
 }
 
-vec3 safe_normalize(vec3 v) {
-    float len = length(v);
-    return len > 0.00001 ? v / len : vec3(0, 1, 0);
+void splatBox(uint i, uint count, vec3 center, vec3 size, inout vec3 pos, inout vec3 scale, inout vec4 rot) {
+    float x = get_noise(i) - 0.5;
+    float y = get_noise(i + 1) - 0.5;
+    float z = get_noise(i + 2) - 0.5;
+    pos = center + vec3(x, y, z) * size;
+    scale = vec3(0.15); // Larger splats for better coverage
+    rot = vec4(1, 0, 0, 0);
 }
 
 void main() {
     uint global_i = gl_GlobalInvocationID.x;
-    uint lid = gl_LocalInvocationID.x;
-
     if (global_i >= pc.count) return;
 
-    uint p_asset = 16384;
+    uint p_asset = 4096; 
     uint asset_idx = global_i / p_asset;
     uint i = global_i % p_asset;
 
-    vec3 pos = vec3(0.0); vec3 scale = vec3(0.05); vec4 rot = vec4(1, 0, 0, 0);
-    vec3 color = vec3(1.0); float opacity = 0.005;
-    float x_offset = (float(asset_idx) - 1.0) * 5.0;
-    vec3 normal = vec3(0, 1, 0); 
-
-    if (asset_idx == 0) {
-        if (i < 2000) { 
-            splatCylinder(i, 2000, vec3(0, 0, 0), vec3(0, 3, 0), 0.25, pos, scale, rot); 
-            color = vec3(0.3, 0.15, 0.05); 
-            normal = safe_normalize(vec3(pos.x, 0.0, pos.z)); // Fixed: Trunk radial normal
-            if (length(vec3(pos.x, 0, pos.z)) < 0.001) normal = vec3(1, 0, 0);
+    vec3 pos = vec3(0.0); vec3 scale = vec3(0.1); vec4 rot = vec4(1, 0, 0, 0);
+    vec3 color = vec3(1.0); float opacity = 0.004; // Lower opacity for better blending
+    vec3 normal = vec3(0, 1, 0);
+
+    if (asset_idx == 0) { // FLOOR
+        splatBox(i, p_asset, vec3(0, -0.2, 0), vec3(40.0, 0.4, 40.0), pos, scale, rot);
+        color = vec3(0.02, 0.03, 0.02) * (0.8 + 0.2 * get_noise(i));
+        normal = vec3(0, 1, 0);
+        scale = vec3(0.4, 0.1, 0.4); // Much larger splats for the floor
+        opacity = 0.008;
+    } else if (asset_idx < 6) { // TREES
+        uint t_idx = asset_idx - 1;
+        float tx = (get_noise(t_idx * 10) - 0.5) * 20.0;
+        float tz = (get_noise(t_idx * 20) - 0.5) * 20.0;
+        vec3 center = vec3(tx, 0.0, tz);
+        if (i < 1500) { 
+            float h = float(i)/1500.0;
+            float angle = h * 3.0 + float(t_idx);
+            vec3 top = center + vec3(sin(angle)*1.2, 6.0, cos(angle)*1.2);
+            splatCylinder(i, 1500, center, top, 0.4 * (1.0 - h*0.6), 0.1, pos, scale, rot);
+            color = vec3(0.1, 0.08, 0.05);
+            normal = safe_normalize(vec3(pos.x - center.x, 0, pos.z - center.z));
+        } else {
+            uint b_i = i - 1500; uint b_idx = b_i / 600; uint b_sub = b_i % 600;
+            float b_angle = float(b_idx) * 1.57 + pc.time * 0.05 + float(t_idx);
+            vec3 b_start = center + vec3(0, 3.0 + float(b_idx)*0.8, 0);
+            vec3 b_end = b_start + vec3(sin(b_angle)*3.0, 2.5, cos(b_angle)*3.0);
+            splatCylinder(b_sub, 600, b_start, b_end, 0.15, 0.08, pos, scale, rot);
+            color = vec3(0.08, 0.06, 0.04);
+            normal = safe_normalize(b_end - b_start);
+        }
+    } else if (asset_idx < 26) { // TOMBSTONES
+        uint tomb_idx = asset_idx - 6;
+        float row = floor(float(tomb_idx) / 5.0);
+        float col = mod(float(tomb_idx), 5.0);
+        vec3 center = vec3(-8.0 + col * 4.0 + get_noise(tomb_idx)*0.5, 0.0, -8.0 + row * 5.0 + get_noise(tomb_idx+10)*0.5);
+        if (i < 3000) {
+            splatBox(i, 3000, center + vec3(0, 0.8, 0), vec3(1.2, 1.6, 0.3), pos, scale, rot);
+            color = vec3(0.25, 0.25, 0.27);
+        } else {
+            uint t_i = i - 3000;
+            splatCylinder(t_i, 1096, center + vec3(-0.6, 1.6, 0), center + vec3(0.6, 1.6, 0), 0.3, 0.1, pos, scale, rot);
+            color = vec3(0.22, 0.22, 0.24);
         }
-        else if (i < 5000) { uint b = i-2000; float a = (b%4)*1.57; splatCylinder(b, 3000, vec3(0, 2, 0), vec3(sin(a)*1.5, 3.5, cos(a)*1.5), 0.12, pos, scale, rot); color = vec3(0.3, 0.15, 0.05); normal = safe_normalize(pos.xyz); }
-        else { 
-            uint l = i-5000; float r = 2.0*pow(get_noise(l), 0.6), phi = get_noise(l+1)*6.28; 
-            pos = vec3(sin(phi)*r, 3.5+get_noise(l+2)*2.0, cos(phi)*r); scale = vec3(0.3, 0.1, 0.3); 
-            color = vec3(0.1, 0.5, 0.1); normal = safe_normalize(pos - vec3(0, 4.5, 0));
+        normal = vec3(0, 0, 1);
+    } else if (asset_idx == 26 || asset_idx == 27) { // CROSSES
+        vec3 center = (asset_idx == 26) ? vec3(-10, 0, -10) : vec3(10, 0, -10);
+        if (i < 2500) splatCylinder(i, 2500, center, center + vec3(0, 4.0, 0), 0.2, 0.1, pos, scale, rot);
+        else if (i < 3500) splatCylinder(i-2500, 1000, center + vec3(-1.0, 2.8, 0), center + vec3(1.0, 2.8, 0), 0.18, 0.08, pos, scale, rot);
+        else {
+            uint r_i = i - 3500; float angle = (float(r_i)/596.0) * 6.28;
+            pos = center + vec3(sin(angle)*0.8, 2.8 + cos(angle)*0.8, 0); 
+            pos += (vec3(get_noise(i), get_noise(i+1), get_noise(i+2)) - 0.5) * 0.15; // Ring jitter
+            scale = vec3(0.15); rot = vec4(1,0,0,0);
         }
-    } else if (asset_idx == 1) {
-        if (i < 4000) { uint l = i%4; vec3 lp = vec3((l<2?1:-1)*0.8, 0, (l%2==0?1:-1)*0.8); splatCylinder(i, 4000, lp, lp+vec3(0, 1.5, 0), 0.1, pos, scale, rot); color = vec3(0.5, 0.3, 0.1); normal = safe_normalize(vec3(lp.x, 0, lp.z)); }
-        else if (i < 6000) { uint s = i-4000; pos = vec3(get_noise(s)*2.0-1.0, 1.6, get_noise(s+1)*2.0-1.0); scale = vec3(0.15, 0.01, 0.15); color = vec3(0.6, 0.4, 0.2); normal = vec3(0, 1, 0); }
-        else { uint b = i-6000; pos = vec3(get_noise(b)*2.0-1.0, 1.6+get_noise(b+1)*2.5, -0.9); scale = vec3(0.1, 0.1, 0.01); color = vec3(0.5, 0.3, 0.1); normal = vec3(0, 0, 1); }
-    } else {
-        float u = float(i)/16384.0, t = pc.time, v = (float(i%1024)/1024.0)*6.28;
-        if (u < 0.2) { float phi = (u/0.2)*3.14, r = 1.2+0.1*sin(t*4.0+v*3.0); pos = vec3(r*sin(phi)*cos(v), 4.5+r*cos(phi), r*sin(phi)*sin(v)); normal = safe_normalize(pos - vec3(0, 4.5, 0)); }
-        else if (u < 0.7) { float h = (u-0.2)/0.5, vertical = mix(4.0, 0.0, h), radius = 1.5*(1.0-h*0.4), wave = sin(h*4.0-t*3.0)*(h*1.5); pos = vec3(radius*cos(v)+wave, vertical, radius*sin(v)); normal = safe_normalize(vec3(cos(v), 0, sin(v))); }
-        else { float h = (u-0.7)/0.3; bool left = (v<3.14); float aw = sin(t*5.0)*0.8; vec3 s = vec3(left?-1:1, 3.8, 0), e = vec3(left?-3:3, 2.5+aw, 1); pos = mix(s, e, h); float r = 0.3*(1.0-h*0.5); pos.y += r*cos(v*4.0); pos.z += r*sin(v*4.0); normal = safe_normalize(pos - s); }
-        scale = vec3(0.08); color = mix(vec3(0,1,1), vec3(1,0,1), sin(t+u*5.0)*0.5+0.5) * 2.5;
+        color = vec3(0.35, 0.35, 0.35); normal = vec3(0,0,1);
+    } else { // GHOSTS
+        float t = pc.time;
+        uint g_idx = asset_idx - 28;
+        vec3 center = vec3(sin(t*0.5 + float(g_idx))*6.0, 3.5 + cos(t*0.8 + float(g_idx))*1.5, cos(t*0.6 + float(g_idx))*6.0);
+        float u = float(i)/float(p_asset); float v = (float(i%1024)/1024.0)*6.28;
+        if (u < 0.2) { float phi = (u/0.2)*3.14, r = 0.8; pos = center + vec3(r*sin(phi)*cos(v), r*cos(phi), r*sin(phi)*sin(v)); normal = safe_normalize(pos - center); }
+        else { float h = (u-0.2)/0.8, vertical = mix(0.0, -2.5, h), radius = 0.8*(1.0-h*0.7), wave = sin(h*5.0-t*4.0)*(h*1.0); pos = center + vec3(radius*cos(v)+wave, vertical, radius*sin(v)); normal = safe_normalize(vec3(cos(v), 0, sin(v))); }
+        
+        // Ghost jitter for "whispiness"
+        pos += (vec3(get_noise(i), get_noise(i+1), get_noise(i+2)) - 0.5) * 0.2;
+        scale = vec3(0.12); color = mix(vec3(0,1,1), vec3(0.7,0.3,1), sin(t+u*5.0+float(g_idx))*0.5+0.5) * 4.0; opacity = 0.003;
     }
 
-    pos.x += x_offset; pos += pc.world_offset.xyz;
+    pos += pc.world_offset.xyz;
     vec3 ldir = normalize(pc.light_dir.xyz);
     vec3 view_dir = safe_normalize(pc.cam_pos.xyz - pos); 
 
-    // LIGHTING: Half-Lambert (Wrap) to preserve volume and saturation
     float diff = dot(normal, ldir);
-    float wrap = diff * 0.5 + 0.5;
-    vec3 lit_color = color * (wrap * 1.4); 
+    float wrap = diff * 0.4 + 0.6;
+    vec3 lit_color = color * (wrap * 1.1 + 0.1); 
 
-    // RIM: Golden "Glint" instead of Blue wash
     float rim = pow(1.0 - max(0.0, dot(normal, view_dir)), 4.0);
-    lit_color += vec3(1.0, 0.9, 0.7) * rim * 0.5; 
-
-    // SH: 1st Order (Subtle Color Shift)
-    float SH_C1 = 0.48860251190291992;
-    lit_color *= (1.0 + SH_C1 * (view_dir.x * 0.2 + view_dir.y * 0.1));
-    lit_color = max(vec3(0.0), lit_color);
+    lit_color += vec3(0.7, 0.8, 1.0) * rim * 0.6; 
 
     vec4 pos_v = pc.view * vec4(pos, 1.0);
-    if (pos_v.z > -0.1 || opacity < 0.001) return;
+    if (pos_v.z > -0.1 || opacity < 0.0001) return;
 
     vec3 cov2d = computeCov2D(pos_v.xyz, scale, rot);
     vec4 clip_p = pc.proj * pos_v; vec2 ndc = clip_p.xy / clip_p.w;
-    if (abs(ndc.x) > 1.2 || abs(ndc.y) > 1.2) return;
+    if (abs(ndc.x) > 1.4 || abs(ndc.y) > 1.4) return;
 
     uint packed_idx = atomicAdd(all_counts[pc.count_id].count, 1);
     if (packed_idx >= 131072) return; 
@@ -176,13 +226,11 @@ void main() {
     all_projected[pc.p_id].p[packed_idx].inv_cov = vec4(i_cov.x * -0.5, i_cov.y * -1.0, i_cov.z * -0.5, 0.0); 
     all_projected[pc.p_id].p[packed_idx].color_alpha = vec4(lit_color, opacity * 10.0); 
 
-    // Linearize depth for perfectly stable 2-pass sorting (0.0 to 51.2 meters)
     float depth = -pos_v.z;
-    uint linearized_depth = uint(clamp(depth * 5.0, 0.0, 65535.0));
+    uint linearized_depth = uint(clamp(depth * 50.0, 0.0, 65535.0));
     all_sort_bufs[pc.s_id].entries[packed_idx].depth_key = linearized_depth; 
     all_sort_bufs[pc.s_id].entries[packed_idx].splat_id = packed_idx;
 
-    // Fix: First-pass histogram (Pass 0, Bits 0-7)
     uint bucket = (linearized_depth >> 0) & 0xFF;
     atomicAdd(all_histograms[pc.hist_id].histogram[bucket], 1);
 

examples/49_compute_splatter/main.lua

@@ -9,10 +9,15 @@ local command = require("vulkan.command")
 local input = require("mc.input")
 local bit = require("bit")
 
-local M = { cam_pos = { 0, 0, 8 }, cam_rot = { 0, 0 }, current_time = 0, last_frame_ticks = 0, fps_frames = 0, fps_timer = 0 }
+local M = { 
+    cam_target = { 0, 1, 0 }, 
+    cam_dist = 18, 
+    cam_rot = { 0, 0.4 }, -- Longitude, Latitude
+    current_time = 0, last_frame_ticks = 0, fps_frames = 0, fps_timer = 0 
+}
 
 -- CONFIG
-local GAUSSIAN_COUNT = 32768
+local GAUSSIAN_COUNT = 131072
 local MAX_SORT_COUNT = 131072 
 local TILE_SIZE = 16
 local NUM_TILES_X = 1280 / TILE_SIZE
@@ -161,26 +166,32 @@ function M.update()
 	local idx = sw:acquire_next_image(image_available)
 	if idx == nil then return end
 
-	input.tick()
 	M.current_time = M.current_time + dt
 	local dx, dy = input.mouse_delta()
-	if input.mouse_down(3) then
-		M.cam_rot[1] = M.cam_rot[1] - dx * 0.005
-		M.cam_rot[2] = math.max(-math.pi / 2, math.min(math.pi / 2, M.cam_rot[2] - dy * 0.005))
+	if input.mouse_down(1) then
+		M.cam_rot[1] = M.cam_rot[1] - dx * 0.01
+		M.cam_rot[2] = math.max(-1.5, math.min(1.5, M.cam_rot[2] + dy * 0.01))
 	end
-	local fwd = { math.sin(M.cam_rot[1]) * math.cos(M.cam_rot[2]), math.sin(M.cam_rot[2]), -math.cos(M.cam_rot[1]) * math.cos(M.cam_rot[2]) }
-	local right = { math.cos(M.cam_rot[1]), 0, math.sin(M.cam_rot[1]) }
-	local speed = (input.key_down(input.SCANCODE_LSHIFT) and 15.0 or 5.0) * dt
-	if input.key_down(input.SCANCODE_W) then M.cam_pos[1], M.cam_pos[2], M.cam_pos[3] = M.cam_pos[1] + fwd[1] * speed, M.cam_pos[2] + fwd[2] * speed, M.cam_pos[3] + fwd[3] * speed end
-	if input.key_down(input.SCANCODE_S) then M.cam_pos[1], M.cam_pos[2], M.cam_pos[3] = M.cam_pos[1] - fwd[1] * speed, M.cam_pos[2] - fwd[2] * speed, M.cam_pos[3] - fwd[3] * speed end
-	if input.key_down(input.SCANCODE_A) then M.cam_pos[1], M.cam_pos[2], M.cam_pos[3] = M.cam_pos[1] - right[1] * speed, M.cam_pos[2] - right[2] * speed, M.cam_pos[3] - right[3] * speed end
-	if input.key_down(input.SCANCODE_D) then M.cam_pos[1], M.cam_pos[2], M.cam_pos[3] = M.cam_pos[1] + right[1] * speed, M.cam_pos[2] + right[2] * speed, M.cam_pos[3] + right[3] * speed end
-
-	local view = mc.math.mat4_look_at(M.cam_pos, { M.cam_pos[1] + fwd[1], M.cam_pos[2] + fwd[2], M.cam_pos[3] + fwd[3] }, { 0, 1, 0 })
+    if input.key_down(input.SCANCODE_Z) then
+        print(string.format("DEBUG | Cam Rot: %.2f, %.2f | Dist: %.2f", M.cam_rot[1], M.cam_rot[2], M.cam_dist))
+    end
+    local wheel = _G._MOUSE_WHEEL or 0
+    if wheel ~= 0 then 
+        M.cam_dist = math.max(1.0, M.cam_dist - wheel * M.cam_dist * 0.1)
+        _G._MOUSE_WHEEL = 0
+    end
+
+    local cam_pos = {
+        M.cam_target[1] + M.cam_dist * math.sin(M.cam_rot[1]) * math.cos(M.cam_rot[2]),
+        M.cam_target[2] + M.cam_dist * math.sin(M.cam_rot[2]),
+        M.cam_target[3] + M.cam_dist * math.cos(M.cam_rot[1]) * math.cos(M.cam_rot[2])
+    }
+
+	local view = mc.math.mat4_look_at(cam_pos, M.cam_target, { 0, 1, 0 })
 	local aspect = sw.extent.width / sw.extent.height
 	local proj = mc.math.mat4_perspective(mc.math.rad(70), aspect, 0.1, 100.0)
 	local focal = sw.extent.height / (2.0 * math.tan(mc.math.rad(70) * 0.5))
-	local light_dir = { math.sin(M.current_time * 1.5), 0.5, math.cos(M.current_time * 1.5), 0 }
+	local light_dir = { 0.5, 1.0, 0.5, 0 }
 
     command.encode(cb, function(cmd)
         -- 0. CLEAR COUNTERS & INVALIDATE SORT ENTRIES
@@ -194,20 +205,20 @@ function M.update()
 
         -- 1. PROJECT
         project_pc.view, project_pc.proj, project_pc.focal = view, proj, focal
-        project_pc.p_id, project_pc.s_id, project_pc.c_id, project_pc.count = 10, 15, 11, GAUSSIAN_COUNT * 3
+        project_pc.p_id, project_pc.s_id, project_pc.c_id, project_pc.count = 10, 15, 11, GAUSSIAN_COUNT
         project_pc.time, project_pc.noise_id, project_pc.count_id, project_pc.hist_id = M.current_time, 2, 16, 18
-        project_pc.cam_pos, project_pc.light_dir, project_pc.world_offset = { M.cam_pos[1], M.cam_pos[2], M.cam_pos[3], 0 }, light_dir, { 0, 0, 0, 0 }
+        project_pc.cam_pos, project_pc.light_dir, project_pc.world_offset = { cam_pos[1], cam_pos[2], cam_pos[3], 0 }, light_dir, { 0, 0, 0, 0 }
 
         vk.vkCmdBindPipeline(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_project)
         vk.vkCmdBindDescriptorSets(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_layout, 0, 1, ffi.new("VkDescriptorSet[1]", { bindless_set }), 0, nil)
         vk.vkCmdPushConstants(cmd.buffer, pipe_layout, bit.bor(vk.VK_SHADER_STAGE_ALL_GRAPHICS, vk.VK_SHADER_STAGE_COMPUTE_BIT), 0, 256, project_pc)
-        vk.vkCmdDispatch(cmd.buffer, math.ceil((GAUSSIAN_COUNT * 3) / 256), 1, 1)
+        vk.vkCmdDispatch(cmd.buffer, math.ceil(GAUSSIAN_COUNT / 256), 1, 1)
 
         local full_barrier = ffi.new("VkMemoryBarrier[1]", {{ sType = vk.VK_STRUCTURE_TYPE_MEMORY_BARRIER, srcAccessMask = vk.VK_ACCESS_SHADER_WRITE_BIT, dstAccessMask = bit.bor(vk.VK_ACCESS_SHADER_READ_BIT, vk.VK_ACCESS_SHADER_WRITE_BIT) }})
         vk.vkCmdPipelineBarrier(cmd.buffer, vk.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 1, full_barrier, 0, nil, 0, nil)
 
         -- 2. SORT (Pass 0: Bits 0-7)
-        sort_pc.buf_id, sort_pc.alt_id, sort_pc.hist_id, sort_pc.pass, sort_pc.count = 15, 17, 18, 0, GAUSSIAN_COUNT * 3
+        sort_pc.buf_id, sort_pc.alt_id, sort_pc.hist_id, sort_pc.pass, sort_pc.count = 15, 17, 18, 0, GAUSSIAN_COUNT
         vk.vkCmdBindPipeline(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_prefix_sum)
         vk.vkCmdPushConstants(cmd.buffer, pipe_layout, bit.bor(vk.VK_SHADER_STAGE_ALL_GRAPHICS, vk.VK_SHADER_STAGE_COMPUTE_BIT), 0, 256, sort_pc)
         vk.vkCmdDispatch(cmd.buffer, 1, 1, 1)
@@ -240,7 +251,7 @@ function M.update()
 
         -- 3. BINNING (Use slot 15 as the finally sorted buffer)
         binning_pc.s_id, binning_pc.c_id, binning_pc.tc_id, binning_pc.to_id, binning_pc.b_id = 15, 11, 12, 13, 14
-        binning_pc.count, binning_pc.screen_w, binning_pc.screen_h = GAUSSIAN_COUNT * 3, sw.extent.width, sw.extent.height
+        binning_pc.count, binning_pc.screen_w, binning_pc.screen_h = GAUSSIAN_COUNT, sw.extent.width, sw.extent.height
         binning_pc.tiles_x, binning_pc.tiles_y, binning_pc.scatter_mode = NUM_TILES_X, NUM_TILES_Y, 0
         vk.vkCmdBindPipeline(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_binning)
         vk.vkCmdPushConstants(cmd.buffer, pipe_layout, bit.bor(vk.VK_SHADER_STAGE_ALL_GRAPHICS, vk.VK_SHADER_STAGE_COMPUTE_BIT), 0, 256, binning_pc)
@@ -255,7 +266,7 @@ function M.update()
         vk.vkCmdPipelineBarrier(cmd.buffer, vk.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, vk.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, 1, full_barrier, 0, nil, 0, nil)
 
         -- 5. BINNING (Scatter-pass to fill tile splat lists)
-        binning_pc.count = GAUSSIAN_COUNT * 3 
+        binning_pc.count = GAUSSIAN_COUNT 
         binning_pc.scatter_mode = 1
         vk.vkCmdBindPipeline(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_binning)
         vk.vkCmdPushConstants(cmd.buffer, pipe_layout, bit.bor(vk.VK_SHADER_STAGE_ALL_GRAPHICS, vk.VK_SHADER_STAGE_COMPUTE_BIT), 0, 256, binning_pc)
@@ -264,8 +275,8 @@ function M.update()
 
         -- 6. RASTER
         raster_pc.p_id, raster_pc.s_id, raster_pc.b_id, raster_pc.tr_id, raster_pc.img_id = 10, 15, 14, 13, 3
-        raster_pc.screen_w, raster_pc.screen_h, raster_pc.count = sw.extent.width, sw.extent.height, GAUSSIAN_COUNT * 3
-        raster_pc.cam_pos, raster_pc.light_dir = { M.cam_pos[1], M.cam_pos[2], M.cam_pos[3], 0 }, light_dir
+        raster_pc.screen_w, raster_pc.screen_h, raster_pc.count = sw.extent.width, sw.extent.height, GAUSSIAN_COUNT
+        raster_pc.cam_pos, raster_pc.light_dir = { cam_pos[1], cam_pos[2], cam_pos[3], 0 }, light_dir
         vk.vkCmdBindPipeline(cmd.buffer, vk.VK_PIPELINE_BIND_POINT_COMPUTE, pipe_raster)
         vk.vkCmdPushConstants(cmd.buffer, pipe_layout, bit.bor(vk.VK_SHADER_STAGE_ALL_GRAPHICS, vk.VK_SHADER_STAGE_COMPUTE_BIT), 0, 256, raster_pc)
         vk.vkCmdDispatch(cmd.buffer, NUM_TILES_X, NUM_TILES_Y, 1)