From f745ba47651664048a4641676453d06f2319c3d1 Mon Sep 17 00:00:00 2001 From: ladevieq Date: Tue, 5 May 2026 00:51:57 +0200 Subject: Change shaders push constants to reflect vulkan binding refactor --- shaders/api-test-ui.frag | 42 ++++++++++++++------ shaders/api-test-ui.vert | 52 +++++++++++++++++++----- shaders/compute.comp | 89 +++++++++++++++++++++++------------------- shaders/include/ray.h | 54 ++++++++++++------------- shaders/test.comp | 24 ++++++------ shaders/tonemapping.comp | 61 +++++++++++++++++++++++------ shaders/transmittance_lut.comp | 21 ++++++---- 7 files changed, 219 insertions(+), 124 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); } -- cgit v1.3