16*16*16 seems to be a sweet spot between close hulls and overdraw

src/implicit.vert.glsl

@@ -10,9 +10,9 @@ void main() {
     uint base_index = gl_InstanceIndex; //gl_BaseInstance;
 
     vec3 internal_pos = vec3(
-            float((base_index >> 12) & 63) / 64.0,
+            float((base_index >> 8) & 15) / 16.0,
-            float((base_index >> 6) & 63) / 64.0,
+            float((base_index >> 4) & 15) / 16.0,
-            float((base_index >> 0) & 63) / 64.0
+            float((base_index >> 0) & 15) / 16.0
         );
 
     bool enable;
@@ -37,6 +37,6 @@ void main() {
         return;
     }
 
-    pos = vec4((((position / 64.0) + internal_pos) * object_uniforms.dimensions) + object_uniforms.lowest_corner, 1.);
+    pos = vec4((((position / 16.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[(64*64*64)/(4*32)];
+    uvec4 enable[(16*16*16)/(4*32)];
     vec3 dimensions;
     vec3 lowest_corner;
     uint material;

src/main.rs

@@ -1175,12 +1175,7 @@ impl App {
                 .push_constants(csg.deferred_pipeline.layout().clone(), 0, push_constants[i])
                 .unwrap();
 
-            for (i, x) in csg.enable.iter().enumerate() {
+            unsafe { builder.draw(VERTEX_COUNT as u32, 16 * 16 * 16, 0, 0) }.unwrap();
-                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,7 +47,6 @@ 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,7 +163,6 @@ 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();
@@ -434,9 +433,9 @@ fn interval_check(csg: &mut 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 XDIM: usize = 16;
-    const YDIM: usize = 64;
+    const YDIM: usize = 16;
-    const ZDIM: usize = 64;
+    const ZDIM: usize = 16;
 
     let mut obj = Object {
         dimensions: (highest_corner - lowest_corner).to_array().into(),
@@ -527,8 +526,6 @@ fn interval_check(csg: &mut CSG, material: u32, time: f32, frame_index: usize) {
     }
 
     *csg.enable_buffer[frame_index].write().unwrap() = obj;
-
-    csg.enable = obj.enable;
 }
 
 fn sdf_specialize_module(

src/trace.frag.glsl

@@ -10,7 +10,7 @@ layout(depth_greater) out float gl_FragDepth;
 layout(location = 0) out uint material;
 
 const float EPSILON = .001;
-float FARPLANE = length(object_uniforms.dimensions / 32.);
+float FARPLANE = length(object_uniforms.dimensions / 16.);
 
 void main() {
     vec3 raypos = pos.xyz;
@@ -19,10 +19,10 @@ void main() {
     vec3 p = raypos;
     float total_dist = 0.;
     do {
-        float dist = scene(vec4(p, camera_uniforms.campos_and_time.w)) * .98;
+        float dist = scene(vec4(p, camera_uniforms.campos_and_time.w));
         total_dist += dist;
         p = fma(raydir, vec3(total_dist), raypos);
-        if (dist < EPSILON) {
+        if (abs(dist) < EPSILON) {
             vec4 tpoint = camera_uniforms.proj_view * pc.world * vec4(p, 1);
             gl_FragDepth = (tpoint.z / tpoint.w);
             material = object_uniforms.material;