--wip-- [skip ci]

src/implicit.vert.glsl

@@ -7,26 +7,28 @@ layout(location = 0) in vec3 position;
 layout(location = 0) out vec4 pos;
 
 void main() {
+    uint base_index = gl_InstanceIndex; //gl_BaseInstance;
+
     vec3 internal_pos = vec3(
-        float((gl_InstanceIndex >> 10) & 31) / 32.0,
+            float((base_index >> 12) & 63) / 64.0,
-        float((gl_InstanceIndex >> 5) & 31) / 32.0,
+            float((base_index >> 6) & 63) / 64.0,
-        float((gl_InstanceIndex >> 0) & 31) / 32.0
+            float((base_index >> 0) & 63) / 64.0
-    );
+        );
 
     bool enable;
-    switch ((gl_InstanceIndex >> 5) & 3) {
+    switch ((base_index >> 5) & 3) {
         default:
         case 0:
-        enable = (object_uniforms.enable[gl_InstanceIndex >> 7].x & (1 << (gl_InstanceIndex & 31))) != 0;
+        enable = (object_uniforms.enable[base_index >> 7].x & (1 << (base_index & 31))) != 0;
         break;
         case 1:
-        enable = (object_uniforms.enable[gl_InstanceIndex >> 7].y & (1 << (gl_InstanceIndex & 31))) != 0;
+        enable = (object_uniforms.enable[base_index >> 7].y & (1 << (base_index & 31))) != 0;
         break;
         case 2:
-        enable = (object_uniforms.enable[gl_InstanceIndex >> 7].z & (1 << (gl_InstanceIndex & 31))) != 0;
+        enable = (object_uniforms.enable[base_index >> 7].z & (1 << (base_index & 31))) != 0;
         break;
         case 3:
-        enable = (object_uniforms.enable[gl_InstanceIndex >> 7].w & (1 << (gl_InstanceIndex & 31))) != 0;
+        enable = (object_uniforms.enable[base_index >> 7].w & (1 << (base_index & 31))) != 0;
         break;
     }
 
@@ -35,6 +37,6 @@ void main() {
         return;
     }
 
-    pos = vec4((((position / 32.0) + internal_pos) * object_uniforms.dimensions) + object_uniforms.lowest_corner, 1.);
+    pos = vec4((((position / 64.0) + internal_pos) * object_uniforms.dimensions) + object_uniforms.lowest_corner, 1.);
     gl_Position = camera_uniforms.proj_view * pc.world * pos;
 }

src/implicit_include.glsl

@@ -2,7 +2,7 @@
 #define implicit_include
 
 layout(set = 1, binding = 0) uniform Object {
-    uvec4 enable[32 * 8];
+    uvec4 enable[(64*64*64)/(4*32)];
     vec3 dimensions;
     vec3 lowest_corner;
     uint material;

src/main.rs

@@ -1175,7 +1175,12 @@ impl App {
                 .push_constants(csg.deferred_pipeline.layout().clone(), 0, push_constants[i])
                 .unwrap();
 
-            unsafe { builder.draw(VERTEX_COUNT as u32, 32 * 32 * 32, 0, 0) }.unwrap();
+            for (i, x) in csg.enable.iter().enumerate() {
+                if x.iter().any(|f| *f != 0) {
+                    unsafe { builder.draw(VERTEX_COUNT as u32, 4 * 32, 0, (i * (4 * 32)) as u32) }
+                        .unwrap();
+                }
+            }
         }
     }
 

src/objects.rs

@@ -47,6 +47,7 @@ pub(crate) struct CSG {
     pub(crate) enable_buffer:           Vec<Subbuffer<Object>>,
     pub(crate) deferred_descriptor_set: Vec<Arc<DescriptorSet>>,
     pub(crate) normals_descriptor_set:  Vec<Arc<DescriptorSet>>,
+    pub(crate) enable:                  [[u32; 4]; (64 * 64 * 64) / (32 * 4)],
 }
 
 pub(crate) fn load_obj(

src/threads.rs

@@ -163,6 +163,7 @@ pub fn thread_loop(recv: mpmc::Receiver<WorkItem>, send: mpsc::SyncSender<WorkCo
                     enable_buffer,
                     deferred_descriptor_set,
                     normals_descriptor_set,
+                    enable: [[0; 4]; (64 * 64 * 64) / (32 * 4)],
                 }));
 
                 send.send(WorkComplete::CreateCSG(csg, index)).unwrap();
@@ -174,7 +175,7 @@ pub fn thread_loop(recv: mpmc::Receiver<WorkItem>, send: mpsc::SyncSender<WorkCo
                 );
             },
             WorkItem::GetPushConstants(csg, time, frame_index, index) => {
-                let csg = csg.read().unwrap();
+                let mut csg = csg.write().unwrap();
 
                 let world = Mat4::from_translation(csg.pos * 0.01)
                     * Mat4::from_euler(
@@ -190,7 +191,7 @@ pub fn thread_loop(recv: mpmc::Receiver<WorkItem>, send: mpsc::SyncSender<WorkCo
                     inv_world: world.inverse().to_cols_array_2d(),
                 };
 
-                interval_check(&csg, index as u32 + 1, time, frame_index);
+                interval_check(&mut csg, index as u32 + 1, time, frame_index);
 
                 send.send(WorkComplete::GetPushConstants(push_constants, index))
                     .unwrap();
@@ -406,7 +407,7 @@ fn create_csg() -> SSATape {
     tape
 }
 
-fn interval_check(csg: &CSG, material: u32, time: f32, frame_index: usize) {
+fn interval_check(csg: &mut CSG, material: u32, time: f32, frame_index: usize) {
     const INTERPRET_INPUT_X: interpreter::Value =
         interpreter::Value::from_array([10000.0, 0.0, 0.0, -10000.0, 0.0, 0.0, 0.0, 0.0]);
     const INTERPRET_INPUT_Y: interpreter::Value =
@@ -433,51 +434,71 @@ fn interval_check(csg: &CSG, material: u32, time: f32, frame_index: usize) {
     let highest_corner = Vec3::new(interpreter_out[0], interpreter_out[1], interpreter_out[2]);
     let lowest_corner = Vec3::new(interpreter_out[3], interpreter_out[4], interpreter_out[5]);
 
+    const XDIM: usize = 64;
+    const YDIM: usize = 64;
+    const ZDIM: usize = 64;
+
     let mut obj = Object {
         dimensions: (highest_corner - lowest_corner).to_array().into(),
         lowest_corner: lowest_corner.into(),
-        enable: [[0; 4]; 32 * 8],
+        enable: [[0; 4]; (XDIM * YDIM * ZDIM) / (32 * 4)],
         material,
     };
 
-    for x in 0..32 {
+    for x in 0..XDIM {
-        for y in 0..32 {
+        for y in 0..YDIM {
-            for z in 0..4 {
+            for z in 0..(ZDIM / 8) {
                 let interval_input_z: Interval = Interval::new_unchecked(
                     interpreter::Value::from_array([
-                        ((((8.0 / 32.0) * z as f32) + (0.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (0.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (1.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (1.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (2.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (2.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (3.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (3.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (4.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (4.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (5.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (5.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (6.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (6.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (7.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (7.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
                     ]),
                     interpreter::Value::from_array([
-                        ((((8.0 / 32.0) * z as f32) + (1.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (1.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (2.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (2.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (3.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (3.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (4.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (4.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (5.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (5.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (6.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (6.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (7.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (7.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
-                        ((((8.0 / 32.0) * z as f32) + (8.0 / 32.0)) * obj.dimensions[2])
+                        ((((8.0 / (ZDIM as f32)) * z as f32) + (8.0 / (ZDIM as f32)))
+                            * obj.dimensions[2])
                             + obj.lowest_corner[2],
                     ]),
                 );
@@ -485,26 +506,29 @@ fn interval_check(csg: &CSG, material: u32, time: f32, frame_index: usize) {
                 let mut interpreter = IntervalInterpreter::new(csg);
                 let output = interpreter.scene(
                     Interval::const_splat2(
-                        (x as f32 / 32.0) * obj.dimensions[0] + obj.lowest_corner[0],
+                        (x as f32 / (XDIM as f32)) * obj.dimensions[0] + obj.lowest_corner[0],
-                        ((x + 1) as f32 / 32.0) * obj.dimensions[0] + obj.lowest_corner[0],
+                        ((x + 1) as f32 / (XDIM as f32)) * obj.dimensions[0] + obj.lowest_corner[0],
                     ),
                     Interval::const_splat2(
-                        (y as f32 / 32.0) * obj.dimensions[1] + obj.lowest_corner[1],
+                        (y as f32 / (YDIM as f32)) * obj.dimensions[1] + obj.lowest_corner[1],
-                        ((y + 1) as f32 / 32.0) * obj.dimensions[1] + obj.lowest_corner[1],
+                        ((y + 1) as f32 / (YDIM as f32)) * obj.dimensions[1] + obj.lowest_corner[1],
                     ),
                     interval_input_z,
                     Interval::const_splat(time),
                 );
 
+                let total_index = (x * ZDIM * YDIM) + (y * ZDIM) + (z * 8);
                 let output = ((output.lower().simd_le(VALUE_0) & output.upper().simd_ge(VALUE_0))
                     .to_bitmask() as u32)
-                    << (z * 8);
+                    << (total_index & 31);
-                obj.enable[(x << 3) | (y >> 2)][y & 0b11] |= output;
+                obj.enable[total_index >> 7][(total_index >> 5) & 3] |= output;
             }
         }
     }
 
     *csg.enable_buffer[frame_index].write().unwrap() = obj;
+
+    csg.enable = obj.enable;
 }
 
 fn sdf_specialize_module(