add enable gen shader

tape-drive/assemble_trace.py

@@ -44,14 +44,14 @@ for shader, ty in normal_shaders:
         sys.exit(result.returncode)
 
 replacement_shaders = [
-    ("trace.frag", "frag", (True, False, False)),
-    ("normals.frag", "frag", (True, False, False)),
-    ("fuzz.comp", "comp", (True, True, True)),
+    ("trace.frag", "frag"),
+    ("normals.frag", "frag"),
+    ("fuzz.comp", "comp"),
+    ("enable_gen.comp", "comp"),
 ]
 
-for shader, ty, usage in replacement_shaders:
+for shader, ty in replacement_shaders:
     print(f"{SHADERS_IN}/{shader}.glsl")
-    (uses_point, uses_interval, uses_gradient) = usage
     result = subprocess.run(
         [
             "glslangValidator",

tape-drive/src/main.rs

@@ -577,7 +577,9 @@ impl App {
         let block_enable_allocator = Arc::new(Mutex::new(SubbufferAllocator::new(
             memory_allocator.clone(),
             SubbufferAllocatorCreateInfo {
-                buffer_usage: BufferUsage::UNIFORM_BUFFER | BufferUsage::TRANSFER_DST,
+                buffer_usage: BufferUsage::UNIFORM_BUFFER
+                    | BufferUsage::STORAGE_BUFFER
+                    | BufferUsage::TRANSFER_DST,
                 memory_type_filter: MemoryTypeFilter::PREFER_DEVICE,
                 ..Default::default()
             },

tape-drive/src/shaders/compute_prepass_include.glsl

@@ -0,0 +1,31 @@
+#ifndef compute_prepass_include
+#define compute_prepass_include
+
+#extension GL_GOOGLE_include_directive:require
+#include "include.glsl"
+
+layout(set = 1, binding = 0) restrict buffer Object {
+    uvec4 enable[(SPEC_MAXIMUM_SUBDIVISION * SPEC_MAXIMUM_SUBDIVISION * SPEC_MAXIMUM_SUBDIVISION) / (4 * 32)];
+    vec3 dimensions;
+    vec3 lowest_corner;
+    uint material;
+    uint subdivision_log2;
+    float farplane;
+    vec3 colour;
+    float metallic;
+    float roughness;
+} object_uniforms;
+
+float scene(vec4 p) {
+    return 0.0;
+}
+
+vec2 interval_scene(vec4 pl, vec4 ph) {
+    return vec2(0.0);
+}
+
+vec4 gradient_scene(vec4 p) {
+    return vec4(0.0);
+}
+
+#endif

tape-drive/src/shaders/enable_gen.comp.glsl

@@ -0,0 +1,60 @@
+#version 460
+#extension GL_GOOGLE_include_directive:require
+#include "compute_prepass_include.glsl"
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 8) in;
+
+void main() {
+    if (SPEC_BRUTE_FORCE) {
+        return;
+    }
+
+    uvec3 total_invocations = gl_NumWorkGroups * gl_WorkGroupSize;
+    vec3 internal_pos = vec3(gl_GlobalInvocationID) / vec3(total_invocations);
+
+    vec3 box_dimensions = object_uniforms.dimensions / vec3(total_invocations);
+    vec3 low_corner = object_uniforms.lowest_corner + (box_dimensions * internal_pos);
+    vec3 high_corner = object_uniforms.lowest_corner + (box_dimensions * (internal_pos + 1));
+
+    vec2 interval = interval_scene(
+            vec4(low_corner, camera_uniforms.campos_and_time.w),
+            vec4(high_corner, camera_uniforms.campos_and_time.w)
+        );
+
+    bool enable = (interval.x < 0) && (interval.y > 0);
+
+    uint base_index = (gl_GlobalInvocationID.z * total_invocations.x * total_invocations.y) +
+            (gl_GlobalInvocationID.y * total_invocations.x) + gl_GlobalInvocationID.x;
+
+    switch ((base_index >> 5) & 3) {
+        default:
+        case 0:
+        if (enable) {
+            atomicOr(object_uniforms.enable[base_index >> 7].x, (1 << (base_index & 31)));
+        } else {
+            atomicAnd(object_uniforms.enable[base_index >> 7].x, (~(1 << (base_index & 31))));
+        }
+        break;
+        case 1:
+        if (enable) {
+            atomicOr(object_uniforms.enable[base_index >> 7].y, (1 << (base_index & 31)));
+        } else {
+            atomicAnd(object_uniforms.enable[base_index >> 7].y, (~(1 << (base_index & 31))));
+        }
+        break;
+        case 2:
+        if (enable) {
+            atomicOr(object_uniforms.enable[base_index >> 7].z, (1 << (base_index & 31)));
+        } else {
+            atomicAnd(object_uniforms.enable[base_index >> 7].z, (~(1 << (base_index & 31))));
+        }
+        break;
+        case 3:
+        if (enable) {
+            atomicOr(object_uniforms.enable[base_index >> 7].w, (1 << (base_index & 31)));
+        } else {
+            atomicAnd(object_uniforms.enable[base_index >> 7].w, (~(1 << (base_index & 31))));
+        }
+        break;
+    }
+}