aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--shaders/api-test-ui.frag40
-rw-r--r--shaders/api-test-ui.vert52
-rw-r--r--shaders/compute.comp89
-rw-r--r--shaders/include/ray.h54
-rw-r--r--shaders/test.comp24
-rw-r--r--shaders/tonemapping.comp61
-rw-r--r--shaders/transmittance_lut.comp21
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);
}
generated by cgit v1.3 (git 2.53.0) at 2026-10-25 05:26:11 +0000