Change shaders push constants to reflect vulkan binding refactor

7 files changed, 218 insertions, 123 deletions

diff --git a/shaders/api-test-ui.frag b/shaders/api-test-ui.frag
index 06553df..8da6369 100644
--- a/shaders/api-test-ui.frag
+++ b/shaders/api-test-ui.frag
@@ -11,24 +11,40 @@ layout(location = 0) in struct {
 layout(set = 0, binding = 0) uniform sampler samplers[];

 layout(set = 0, binding = 1) uniform texture2D textures[];

 layout(set = 0, binding = 2, rgba32f) uniform image2D images[];

-// layout(set = 2, binding = 0) uniform parameters {

-//     uint vertex_buffer;

-//     vec2 scale;

-//     vec2 translate;

-//     uint texture_index;

-// } params;

 

-layout(buffer_reference) readonly buffer params {

+layout(buffer_reference) readonly buffer global_params {

+    uint padding;

+};

+

+layout(buffer_reference) readonly buffer pass_params {

+    uint padding;

+};

+

+struct vertex {

+    float    pos_x;

+    float    pos_y;

+    float    uv_x;

+    float    uv_y;

+    uint    color;

+};

+

+layout(buffer_reference) readonly buffer vertices {

+    vertex vertices[];

+};

+

+layout(buffer_reference) readonly buffer draw_params {

+    vertices vertex_buffer;

     vec2 scale;

     vec2 translate;

     uint texture_index;

-    uint padding;

 };

 

-layout(push_constant) uniform constants {

-    layout(offset = 16) params ui_params;

-} consts;

+layout(push_constant) uniform registers {

+    global_params globals;

+    pass_params pass;

+    draw_params draw;

+} regs;

 

 void main() {

-    o_Color = In.color * texture(sampler2D(textures[nonuniformEXT(consts.ui_params.texture_index)], samplers[nonuniformEXT(0U)]), In.uv.xy);

+    o_Color = In.color * texture(sampler2D(textures[nonuniformEXT(regs.draw.texture_index)], samplers[nonuniformEXT(0U)]), In.uv.xy);

 }

diff --git a/shaders/api-test-ui.vert b/shaders/api-test-ui.vert
index bf6acf8..f4d5fee 100644
--- a/shaders/api-test-ui.vert
+++ b/shaders/api-test-ui.vert
@@ -8,10 +8,35 @@ struct vertex {
     uint    color;

 };

 

-layout(buffer_reference, buffer_reference_align = 8) readonly buffer params {

-    vec2 scale;

-    vec2 translate;

-    uint texture_index;

+struct camera {

+    vec4 position;

+

+    vec4 forward;

+    vec4 up;

+    vec4 right;

+

+    vec4 horizontal;

+    vec4 vertical;

+    vec4 first_pixel;

+

+    float lens_radius;

+};

+

+layout(buffer_reference) readonly buffer global_params {

+    camera cam;

+

+    uint max_bounce;

+    uint min_bounce;

+    uint width;

+    uint height;

+    uint sample_index;

+

+    uint enable_dof;

+    uint debug_bvh;

+    int downscale_factor;

+};

+

+layout(buffer_reference) readonly buffer pass_params {

     uint padding;

 };

 

@@ -19,10 +44,19 @@ layout(buffer_reference) readonly buffer vertices {
     vertex vertices[];

 };

 

-layout(push_constant) uniform constants {

-    layout(offset = 16) params ui_params;

+layout(buffer_reference) readonly buffer params {

     vertices vertex_buffer;

-} consts;

+    vec2 scale;

+    vec2 translate;

+    uint texture_index;

+    uint padding;

+};

+

+layout(push_constant) uniform registers {

+    global_params globals;

+    pass_params pass;

+    params ui_params;

+} regs;

 

 out gl_PerVertex {

     vec4 gl_Position;

@@ -35,11 +69,11 @@ layout(location = 0) out struct {
 

 

 void main() {

-    vertex v = consts.vertex_buffer.vertices[gl_VertexIndex];

+    vertex v = regs.ui_params.vertex_buffer.vertices[gl_VertexIndex];

 

     Out.color = unpackUnorm4x8(v.color);

     Out.uv = vec2(v.uv_x, v.uv_y);

 

     vec2 pos = vec2(v.pos_x, v.pos_y);

-    gl_Position = vec4(pos * consts.ui_params.scale + consts.ui_params.translate, 0.0, 1.0);

+    gl_Position = vec4(pos * regs.ui_params.scale + regs.ui_params.translate, 0.0, 1.0);

 }

diff --git a/shaders/compute.comp b/shaders/compute.comp
index 14f1238..934ff70 100644
--- a/shaders/compute.comp
+++ b/shaders/compute.comp
@@ -54,7 +54,9 @@ struct camera {
     vec4 first_pixel;
 
     float lens_radius;
-    float[3] padding;
+    float fov;
+    float focus_distance;
+    float aspect_ratio;
 };
 
 struct bvh_node {
@@ -64,20 +66,6 @@ struct bvh_node {
     int primitive_id;
 };
 
-layout(buffer_reference) readonly buffer scene_metadata {
-    camera cam;
-
-    uint max_bounce;
-    uint min_bounce;
-    uint width;
-    uint height;
-    uint sample_index;
-
-    uint enable_dof;
-    uint debug_bvh;
-    int downscale_factor;
-};
-
 layout(buffer_reference) readonly buffer indices_array {
     uint indices[];
 };
@@ -102,12 +90,25 @@ layout(buffer_reference) readonly buffer nodes_array {
     bvh_node[] nodes;
 };
 
-layout(set = 0, binding = 0) uniform sampler samplers[];
-layout(set = 0, binding = 1) uniform texture2D textures[];
-layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
+layout(buffer_reference) readonly buffer global_params {
+    camera cam;
 
-layout(push_constant) uniform buffers {
-    scene_metadata scene;
+    uint max_bounce;
+    uint min_bounce;
+    uint width;
+    uint height;
+
+    uint sample_index;
+    uint enable_dof;
+    uint debug_bvh;
+    int downscale_factor;
+};
+
+layout(buffer_reference) readonly buffer pass_params {
+    uint padding;
+};
+
+layout(buffer_reference) readonly buffer draw_params {
     nodes_array bvh;
     indices_array indices_arr;
     positions_array positions_arr;
@@ -117,7 +118,17 @@ layout(push_constant) uniform buffers {
     uint output_image_index;
     uint accumulation_image_index;
     uint padding[2];
-} bufs;
+};
+
+layout(set = 0, binding = 0) uniform sampler samplers[];
+layout(set = 0, binding = 1) uniform texture2D textures[];
+layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
+
+layout(push_constant) uniform registers {
+    global_params globals;
+    pass_params pass;
+    draw_params draw;
+} regs;
 
 #include "ray.h"
 
@@ -126,7 +137,7 @@ vec3 ray_color(ray r, uint seed) {
     vec3 radiance = vec3(0.0);
     vec3 throughput = vec3(1.0);
 
-    for (uint bounce = 0; bounce < bufs.scene.max_bounce; bounce++) {
+    for (uint bounce = 0; bounce < regs.globals.max_bounce; bounce++) {
         if (!hit_node(r, info))
             return throughput * vec3(1.0);
 
@@ -236,7 +247,7 @@ vec3 ray_color(ray r, uint seed) {
         // Russian Roulette
         // As the throughput gets smaller, the ray is more likely to get terminated early.
         // Survivors have their value boosted to make up for fewer samples being in the average.
-        if (bounce > bufs.scene.min_bounce) {
+        if (bounce > regs.globals.min_bounce) {
             float probability = min(0.95f, luminance(throughput));
             if (probability < rand(seed)) break;
             throughput /= probability;
@@ -247,46 +258,42 @@ vec3 ray_color(ray r, uint seed) {
 }
 
 ray generate_camera_ray(ivec2 coords, uint seed) {
-    vec2 scene_size = vec2(bufs.scene.width - 1, bufs.scene.height - 1);
+    vec2 scene_size = vec2(regs.globals.width - 1, regs.globals.height - 1);
     vec2 uv = vec2(coords.x / scene_size.x, 1.0 - coords.y / scene_size.y);
     vec2 rand_disk = disk_vec(vec2(rand(seed), rand(seed)));
     vec2 jittered_uvs = uv + vec2(rand(seed), rand(seed)) / scene_size;
     vec2 lens_disk = vec2(0.0);
 
-    if (bufs.scene.enable_dof == 1) {
-        lens_disk = rand_disk * bufs.scene.cam.lens_radius;
+    if (regs.globals.enable_dof == 1) {
+        lens_disk = rand_disk * regs.globals.cam.lens_radius;
     }
 
-    vec3 offset = lens_disk.x * bufs.scene.cam.right.xyz + lens_disk.y * bufs.scene.cam.up.xyz;
-    vec3 proj_plane_pos = bufs.scene.cam.first_pixel.xyz + jittered_uvs.x * bufs.scene.cam.horizontal.xyz + jittered_uvs.y * bufs.scene.cam.vertical.xyz;
+    vec3 offset = lens_disk.x * regs.globals.cam.right.xyz + lens_disk.y * regs.globals.cam.up.xyz;
+    vec3 proj_plane_pos = regs.globals.cam.first_pixel.xyz + jittered_uvs.x * regs.globals.cam.horizontal.xyz + jittered_uvs.y * regs.globals.cam.vertical.xyz;
 
-    return ray(bufs.scene.cam.position.xyz + offset, proj_plane_pos.xyz - bufs.scene.cam.position.xyz - offset, 0.001f, 1e15);
+    return ray(regs.globals.cam.position.xyz + offset, proj_plane_pos.xyz - regs.globals.cam.position.xyz - offset, 0.001f, 1e15);
 }
 
 void main() {
-    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, uvec2(bufs.scene.width, bufs.scene.height))))
+    if (any(greaterThanEqual(gl_GlobalInvocationID.xy, uvec2(regs.globals.width, regs.globals.height))))
         return;
 
-    ivec2 coords = ivec2(gl_GlobalInvocationID.xy) * bufs.scene.downscale_factor;
+    ivec2 coords = ivec2(gl_GlobalInvocationID.xy) * regs.globals.downscale_factor;
 
-    uint seed = uint(coords.x * uint(1973) + coords.y * uint(9277) + bufs.scene.sample_index * uint(26699)) | uint(1);
+    uint seed = uint(coords.x * uint(1973) + coords.y * uint(9277) + regs.globals.sample_index * uint(26699)) | uint(1);
     ray r = generate_camera_ray(coords, seed);
 
     vec3 out_color = vec3(0.0);
-    if (bufs.scene.debug_bvh == 1) {
+    if (regs.globals.debug_bvh == 1) {
         out_color = hit_aabbs(r) * vec3(0.001, 0.0, 0.0);
     } else {
         out_color = ray_color(r, seed);
     }
 
-    float spp_scale = (1.0 / bufs.scene.sample_index);
-    vec3 acc_color = srgb_to_linear(imageLoad(images[nonuniformEXT(bufs.accumulation_image_index)], coords).xyz);
+    // TODO: what is going on with srgb here ?
+    float spp_scale = (1.0 / regs.globals.sample_index);
+    vec3 acc_color = srgb_to_linear(imageLoad(images[nonuniformEXT(regs.draw.accumulation_image_index)], coords).xyz);
     out_color = linear_to_srgb(mix(acc_color, out_color, spp_scale));
 
-    // for (uint i = 0; i < bufs.scene.downscale_factor; i++) {
-    //     for (uint j = 0; j < bufs.scene.downscale_factor; j++) {
-    //         imageStore(images[nonuniformEXT(bufs.output_image_index)], coords + ivec2(i, j), vec4(out_color, 1.0));
-    //     }
-    // }
-    imageStore(images[nonuniformEXT(bufs.output_image_index)], coords, vec4(out_color, 1.0));
+    imageStore(images[nonuniformEXT(regs.draw.output_image_index)], coords, vec4(out_color, 1.0));
 }
diff --git a/shaders/include/ray.h b/shaders/include/ray.h
index 221202f..2e9980b 100644
--- a/shaders/include/ray.h
+++ b/shaders/include/ray.h
@@ -18,38 +18,38 @@ struct hit_info {
 };

 

 uvec4 decode_triangle_indices(uint triangle_id) {

-    uint id1 = bufs.indices_arr.indices[triangle_id * 3]        & 0x00ffffff;

-    uint id2 = bufs.indices_arr.indices[triangle_id * 3 + 1]    & 0x00ffffff;

-    uint id3 = bufs.indices_arr.indices[triangle_id * 3 + 2]    & 0x00ffffff;

+    uint id1 = regs.draw.indices_arr.indices[triangle_id * 3]        & 0x00ffffff;

+    uint id2 = regs.draw.indices_arr.indices[triangle_id * 3 + 1]    & 0x00ffffff;

+    uint id3 = regs.draw.indices_arr.indices[triangle_id * 3 + 2]    & 0x00ffffff;

 

-    uint mat_id = (bufs.indices_arr.indices[triangle_id * 3]        & 0xff000000) >> 8

-                | (bufs.indices_arr.indices[triangle_id * 3 + 1]    & 0xff000000) >> 16

-                | (bufs.indices_arr.indices[triangle_id * 3 + 2]    & 0xff000000) >> 24;

+    uint mat_id = (regs.draw.indices_arr.indices[triangle_id * 3]        & 0xff000000) >> 8

+                | (regs.draw.indices_arr.indices[triangle_id * 3 + 1]    & 0xff000000) >> 16

+                | (regs.draw.indices_arr.indices[triangle_id * 3 + 2]    & 0xff000000) >> 24;

 

     return uvec4(id1, id2, id3, mat_id);

 }

 

 vec3[3] get_triangle_positions(uvec3 indices) {

     return vec3[3](

-        vec3(bufs.positions_arr.positions[indices[0] * 3], bufs.positions_arr.positions[indices[0] * 3 + 1], bufs.positions_arr.positions[indices[0] * 3 + 2]),

-        vec3(bufs.positions_arr.positions[indices[1] * 3], bufs.positions_arr.positions[indices[1] * 3 + 1], bufs.positions_arr.positions[indices[1] * 3 + 2]),

-        vec3(bufs.positions_arr.positions[indices[2] * 3], bufs.positions_arr.positions[indices[2] * 3 + 1], bufs.positions_arr.positions[indices[2] * 3 + 2])

+        vec3(regs.draw.positions_arr.positions[indices[0] * 3], regs.draw.positions_arr.positions[indices[0] * 3 + 1], regs.draw.positions_arr.positions[indices[0] * 3 + 2]),

+        vec3(regs.draw.positions_arr.positions[indices[1] * 3], regs.draw.positions_arr.positions[indices[1] * 3 + 1], regs.draw.positions_arr.positions[indices[1] * 3 + 2]),

+        vec3(regs.draw.positions_arr.positions[indices[2] * 3], regs.draw.positions_arr.positions[indices[2] * 3 + 1], regs.draw.positions_arr.positions[indices[2] * 3 + 2])

     );

 }

 

 vec3[3] get_triangle_normals(uvec3 indices) {

     return vec3[3](

-        vec3(bufs.normals_arr.normals[indices[0] * 3], bufs.normals_arr.normals[indices[0] * 3 + 1], bufs.normals_arr.normals[indices[0] * 3 + 2]),

-        vec3(bufs.normals_arr.normals[indices[1] * 3], bufs.normals_arr.normals[indices[1] * 3 + 1], bufs.normals_arr.normals[indices[1] * 3 + 2]),

-        vec3(bufs.normals_arr.normals[indices[2] * 3], bufs.normals_arr.normals[indices[2] * 3 + 1], bufs.normals_arr.normals[indices[2] * 3 + 2])

+        vec3(regs.draw.normals_arr.normals[indices[0] * 3], regs.draw.normals_arr.normals[indices[0] * 3 + 1], regs.draw.normals_arr.normals[indices[0] * 3 + 2]),

+        vec3(regs.draw.normals_arr.normals[indices[1] * 3], regs.draw.normals_arr.normals[indices[1] * 3 + 1], regs.draw.normals_arr.normals[indices[1] * 3 + 2]),

+        vec3(regs.draw.normals_arr.normals[indices[2] * 3], regs.draw.normals_arr.normals[indices[2] * 3 + 1], regs.draw.normals_arr.normals[indices[2] * 3 + 2])

     );

 }

 

 vec2[3] get_triangle_uvs(uvec3 indices) {

     return vec2[3](

-        vec2(bufs.uvs_arr.uvs[indices[0] * 2], bufs.uvs_arr.uvs[indices[0] * 2 + 1]),

-        vec2(bufs.uvs_arr.uvs[indices[1] * 2], bufs.uvs_arr.uvs[indices[1] * 2 + 1]),

-        vec2(bufs.uvs_arr.uvs[indices[2] * 2], bufs.uvs_arr.uvs[indices[2] * 2 + 1])

+        vec2(regs.draw.uvs_arr.uvs[indices[0] * 2], regs.draw.uvs_arr.uvs[indices[0] * 2 + 1]),

+        vec2(regs.draw.uvs_arr.uvs[indices[1] * 2], regs.draw.uvs_arr.uvs[indices[1] * 2 + 1]),

+        vec2(regs.draw.uvs_arr.uvs[indices[2] * 2], regs.draw.uvs_arr.uvs[indices[2] * 2 + 1])

     );

 }

 

@@ -59,7 +59,7 @@ triangle get_triangle(uint triangle_id) {
         get_triangle_positions(indices.xyz),

         get_triangle_normals(indices.xyz),

         get_triangle_uvs(indices.xyz),

-        bufs.materials_arr.materials[indices.w]

+        regs.draw.materials_arr.materials[indices.w]

     );

 }

 

@@ -82,20 +82,20 @@ uint hit_aabbs(ray r) {
     int id = 0;

 

     while(id != -1) {

-        if (bufs.bvh.nodes[id].primitive_id != -1) {

-            // triangle tri = bufs.geometry.triangles[bufs.bvh.nodes[id].primitive_id];

+        if (regs.draw.bvh.nodes[id].primitive_id != -1) {

+            // triangle tri = bufs.geometry.triangles[regs.draw.bvh.nodes[id].primitive_id];

             // vec3 minimum = min(tri.v1.position, min(tri.v2.position, tri.v3.position)).xyz;

             // vec3 maximum = max(tri.v1.position, max(tri.v2.position, tri.v3.position)).xyz;

 

             // if (hit_aabb(minimum, maximum, r)) {

             //     hit_count++;

             // }

-            id = bufs.bvh.nodes[id].next_id;

-        } else if (hit_aabb(bufs.bvh.nodes[id].min, bufs.bvh.nodes[id].max, r)) {

+            id = regs.draw.bvh.nodes[id].next_id;

+        } else if (hit_aabb(regs.draw.bvh.nodes[id].min, regs.draw.bvh.nodes[id].max, r)) {

                 hit_count++;

                 id++;

         } else {

-            id = bufs.bvh.nodes[id].next_id;

+            id = regs.draw.bvh.nodes[id].next_id;

         }

     }

 

@@ -169,22 +169,22 @@ bool hit_node(ray r, out hit_info info) {
 

     while(id != -1) {

         // Leafs

-        if (bufs.bvh.nodes[id].primitive_id != -1) {

-            // if (hit_sphere(bufs.geometry.spheres[bufs.bvh.nodes[id].primitive_id], r, temp_info)) {

+        if (regs.draw.bvh.nodes[id].primitive_id != -1) {

+            // if (hit_sphere(bufs.geometry.spheres[regs.draw.bvh.nodes[id].primitive_id], r, temp_info)) {

             //     info = temp_info;

             //     r.max_t = temp_info.t;

             //     hit = true;

             // }

-            if (hit_triangle(bufs.bvh.nodes[id].primitive_id, r, temp_info)) {

+            if (hit_triangle(regs.draw.bvh.nodes[id].primitive_id, r, temp_info)) {

                 info = temp_info;

                 r.max_t = temp_info.t;

                 hit = true;

             }

-            id = bufs.bvh.nodes[id].next_id;

-        } else if (hit_aabb(bufs.bvh.nodes[id].min, bufs.bvh.nodes[id].max, r)) {

+            id = regs.draw.bvh.nodes[id].next_id;

+        } else if (hit_aabb(regs.draw.bvh.nodes[id].min, regs.draw.bvh.nodes[id].max, r)) {

                 id++;

         } else {

-            id = bufs.bvh.nodes[id].next_id;

+            id = regs.draw.bvh.nodes[id].next_id;

         }

     }

 

diff --git a/shaders/test.comp b/shaders/test.comp
index a17de69..3a4230f 100644
--- a/shaders/test.comp
+++ b/shaders/test.comp
@@ -6,26 +6,24 @@ layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
 layout(set = 0, binding = 0) uniform sampler samplers[];
 layout(set = 0, binding = 1) uniform texture2D textures[];
 layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
-// layout(set = 2, binding = 0) uniform parameters {
-//     uint input_id1;
-//     uint input_id2;
-//     uint output_id;
-// } params;
-layout(push_constant) uniform parameters {
+
+layout(buffer_reference) readonly buffer draw_params {
     uint input_id1;
-    uint padding1;
     uint input_id2;
-    uint padding2;
     uint output_id;
-    uint padding3;
-} params;
+    uint pad;
+};
+
+layout(push_constant) uniform buffers {
+    layout(offset = 16) draw_params draw;
+} regs;
 
 void main() {
     ivec2 coords = ivec2(gl_GlobalInvocationID.xy);
     float t = 0.5;
-    vec3 color_1 = imageLoad(images[nonuniformEXT(params.input_id1)], coords).xyz;
-    vec3 color_2 = imageLoad(images[nonuniformEXT(params.input_id2)], coords).xyz;
+    vec3 color_1 = imageLoad(images[nonuniformEXT(regs.draw.input_id1)], coords).xyz;
+    vec3 color_2 = imageLoad(images[nonuniformEXT(regs.draw.input_id2)], coords).xyz;
     vec3 out_color = (t * color_1) + ((1.0 - t) * color_2);
 
-    imageStore(images[nonuniformEXT(params.output_id)], coords, vec4(out_color, 1.0));
+    imageStore(images[nonuniformEXT(regs.draw.output_id)], coords, vec4(out_color, 1.0));
 }
diff --git a/shaders/tonemapping.comp b/shaders/tonemapping.comp
index 35a7a13..65251df 100644
--- a/shaders/tonemapping.comp
+++ b/shaders/tonemapping.comp
@@ -3,28 +3,63 @@
 

 layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;

 

-layout(buffer_reference) readonly buffer scene_metadata {

-    uint[39] unused;

+layout(set = 0, binding = 2, rgba32f) uniform image2D images[];

+

+struct camera {

+    vec4 position;

+

+    vec4 forward;

+    vec4 up;

+    vec4 right;

+

+    vec4 horizontal;

+    vec4 vertical;

+    vec4 first_pixel;

+

+    float lens_radius;

+    float fov;

+    float focus_distance;

+    float aspect_ratio;

+};

+

+layout(buffer_reference) readonly buffer global_params {

+    camera cam;

+

+    uint max_bounce;

+    uint min_bounce;

+    uint width;

+    uint height;

+

+    uint sample_index;

+    uint enable_dof;

+    uint debug_bvh;

     int downscale_factor;

 };

 

-layout(set = 0, binding = 2, rgba32f) uniform image2D images[];

+layout(buffer_reference) readonly buffer pass_params {

+    uint padding;

+};

+

+layout(buffer_reference) readonly buffer draw_params {

+    uint output_image_index;

+    uint accumulation_image_index;

+};

 

-layout(push_constant) uniform constants {

-    scene_metadata scene;

-    layout(offset = 56) uint output_image_index;

-    layout(offset = 60) uint accumulation_image_index;

-} consts;

+layout(push_constant) uniform registers {

+    global_params globals;

+    pass_params pass;

+    draw_params draw;

+} regs;

 

 void main() {

-    ivec2 coords = ivec2(gl_GlobalInvocationID.xy) * consts.scene.downscale_factor;

+    ivec2 coords = ivec2(gl_GlobalInvocationID.xy) * regs.globals.downscale_factor;

 

-    vec3 color = imageLoad(images[nonuniformEXT(consts.accumulation_image_index)], coords).rgb;

+    vec3 color = imageLoad(images[nonuniformEXT(regs.draw.accumulation_image_index)], coords).rgb;

     vec3 out_color = sqrt(color);

 

-    for (uint i = 0; i < consts.scene.downscale_factor; i++) {

-        for (uint j = 0; j < consts.scene.downscale_factor; j++) {

-            imageStore(images[nonuniformEXT(consts.output_image_index)], coords + ivec2(i, j), vec4(out_color, 1.0));

+    for (uint i = 0; i < regs.globals.downscale_factor; i++) {

+        for (uint j = 0; j < regs.globals.downscale_factor; j++) {

+            imageStore(images[nonuniformEXT(regs.draw.output_image_index)], coords + ivec2(i, j), vec4(out_color, 1.0));

         }

     }

 }

diff --git a/shaders/transmittance_lut.comp b/shaders/transmittance_lut.comp
index bb7e621..aadc55a 100644
--- a/shaders/transmittance_lut.comp
+++ b/shaders/transmittance_lut.comp
@@ -7,11 +7,16 @@ layout(set = 0, binding = 0) uniform sampler samplers[];
 layout(set = 0, binding = 1) uniform texture2D textures[];
 layout(set = 0, binding = 2, rgba32f) uniform image2D images[];
 
-layout(push_constant) uniform buffers {
+layout(buffer_reference) readonly buffer draw_params {
     uint output_image_index;
-    uvec2 tex_size;
-    uint padding;
-} params;
+    uint width;
+    uint height;
+    uint pad;
+};
+
+layout(push_constant) uniform buffers {
+    layout(offset = 16) draw_params draw;
+} regs;
 
 vec2 sphere_intersection ( in vec3 orig, in vec3 dir, float radius ) {
     float b = dot(orig, dir);
@@ -37,7 +42,7 @@ void main() {
     const float top_radius = 6420.f;
     const float atmosphere_radius = top_radius - ground_radius;
 
-    vec2 uvs = vec2(coords) / params.tex_size;
+    vec2 uvs = vec2(coords) / vec2(regs.draw.width, regs.draw.height);
 
     float cos_mu = uvs.y * 2.f - 1.f;
     float mu = acos(cos_mu);
@@ -67,9 +72,9 @@ void main() {
     }
 
     // val.x = t;
-    // imageStore(images[nonuniformEXT(params.output_image_index)], coords, val);
+    // imageStore(images[nonuniformEXT(regs.draw.output_image_index)], coords, val);
     // return;
-    imageStore(images[nonuniformEXT(params.output_image_index)], coords, vec4(t, 0.f, 0.f, 1.f));
+    imageStore(images[nonuniformEXT(regs.draw.output_image_index)], coords, vec4(t, 0.f, 0.f, 1.f));
     return;
 
     vec3 transmittance = vec3(0.f);
@@ -89,5 +94,5 @@ void main() {
     color.xyz = vec3(0.f);
     color.x = t;
 
-    imageStore(images[nonuniformEXT(params.output_image_index)], coords, color);
+    imageStore(images[nonuniformEXT(regs.draw.output_image_index)], coords, color);
 }