grow compute shaders

shaders/rt_compute_grow_two.comp

@@ -0,0 +1,94 @@
+#version 450
+
+layout(binding = 0) uniform UniformBufferObject {
+    mat4 model;
+    mat4 geom_rot;
+    mat4 view;
+    mat4 proj;
+    vec3 camera_pos;
+    bool[16] use_geom_shader;
+} ubo;
+
+layout(binding = 3) readonly buffer CompoundBuffer {
+   uint compounds[];
+};
+
+layout(binding = 4) readonly buffer ColorBuffer {
+   uint grid_in[];
+};
+
+layout(binding = 9) readonly buffer TransparentBuffer {
+   bool transparent_grid[];
+};
+
+layout(binding = 7) buffer SizeBuffer2D {
+   uint grid_out[];
+};
+
+layout(binding = 8) readonly buffer SizeBuffer3D {
+   uint grid_size_in[];
+};
+
+layout (local_size_x = 16, local_size_y = 1, local_size_z = 1) in;
+
+void main() {
+    uint index = gl_GlobalInvocationID.x;
+    uint output_offset = 0;
+    uint compound_start = 0;
+    // iterate over the compounds and find the work index inside of it
+    while (index > compounds[compound_start] * compounds[compound_start]) {
+        output_offset += compounds[compound_start] * compounds[compound_start] * compounds[compound_start] * 2;
+        index -= compounds[compound_start] * compounds[compound_start];
+        compound_start = compounds[compound_start + 2];
+    }
+    // grid pos in the task
+    uint compound_grid_size = compounds[compound_start];
+    float compound_scale = uintBitsToFloat(compounds[compound_start + 1]);
+    vec3 mid_offset = vec3(compound_scale * 0.5, compound_scale * 0.5, compound_scale * 0.5);
+    uint x = index % compound_grid_size;
+    uint z = (index - x) / compound_grid_size;
+    vec3 compound_pos = vec3(uintBitsToFloat(compounds[compound_start + 5]), uintBitsToFloat(compounds[compound_start + 6]), uintBitsToFloat(compounds[compound_start + 7]));
+    // iterate upwards along the x axis
+    bool seen_empty = false;
+    uint start = 0;
+    uint start_x_size = 0;
+    uint last_col = 0;
+    for (uint y=0; y < compound_grid_size; y++) {
+        uint color_val = grid_in[output_offset + x * compound_grid_size * compound_grid_size + y * compound_grid_size + z];
+        bool transparent = transparent_grid[output_offset + x * compound_grid_size * compound_grid_size + y * compound_grid_size + z];
+        uint current_x_size = grid_size_in[output_offset + x * compound_grid_size * compound_grid_size + y * compound_grid_size + z];
+        
+        grid_out[output_offset + (x * compound_grid_size * compound_grid_size + y * compound_grid_size + z) * 2] = 0;
+        grid_out[output_offset + (x * compound_grid_size * compound_grid_size + y * compound_grid_size + z) * 2 + 1] = 0;
+        // check if we need to stop a volume
+        if (color_val != 0 && !transparent) {
+            // check if we are in a volume right now
+            if (seen_empty) {
+                // close the current volume
+                grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2] = start_x_size;
+                grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2 + 1] = y - start;
+                seen_empty = false;
+                last_col = 0;
+            }
+        } else {
+            // check if transparency changed
+            if (seen_empty && ((transparent && last_col != color_val) || (start_x_size != current_x_size))) {
+                // if we switch colors or size close the current volume and prepare for a new one
+                grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2] = start_x_size;
+                grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2 + 1] = y - start;
+                seen_empty = false;
+            }
+            // start a new volume if we are not in one right now
+            if (!seen_empty && current_x_size != 0) {
+                seen_empty = true;
+                start = y;
+                start_x_size = current_x_size;
+                last_col = color_val;
+            }
+        }
+    }
+    if (seen_empty) {
+        grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2] = start_x_size;
+        grid_out[output_offset + (x * compound_grid_size * compound_grid_size + start * compound_grid_size + z) * 2 + 1] = compound_grid_size - start;
+    }
+}