Add computecullandlod rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -0,0 +1,14 @@
+[package]
+name = "computecullandlod-cull"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+spirv-std = { workspace = true }
+
+[package.metadata.rust-gpu.build]
+capabilities = ["VulkanMemoryModelDeviceScope"]
+

shaders/rust/computecullandlod/cull.comp.spv

@@ -0,0 +1,113 @@
+#![no_std]
+
+use spirv_std::spirv;
+use spirv_std::glam::{UVec3, Vec3, Vec4, Mat4, Vec4Swizzles};
+use spirv_std::arch::atomic_i_add;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct InstanceData {
+    pub pos: [f32; 3],
+    pub scale: f32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct IndexedIndirectCommand {
+    pub index_count: u32,
+    pub instance_count: u32,
+    pub first_index: u32,
+    pub vertex_offset: u32,
+    pub first_instance: u32,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UBO {
+    pub projection: Mat4,
+    pub modelview: Mat4,
+    pub camera_pos: Vec4,
+    pub frustum_planes: [Vec4; 6],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UBOOut {
+    pub draw_count: i32,
+    pub lod_count: [i32; 6], // MAX_LOD_LEVEL + 1
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct LOD {
+    pub first_index: u32,
+    pub index_count: u32,
+    pub distance: f32,
+    pub _pad0: f32,
+}
+
+fn frustum_check(pos: Vec4, radius: f32, frustum_planes: &[Vec4; 6]) -> bool {
+    for i in 0..6 {
+        if pos.dot(frustum_planes[i]) + radius < 0.0 {
+            return false;
+        }
+    }
+    true
+}
+
+#[spirv(compute(threads(16)))]
+pub fn main_cs(
+    #[spirv(global_invocation_id)] global_id: UVec3,
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 0)] instances: &[InstanceData],
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 1)] indirect_draws: &mut [IndexedIndirectCommand],
+    #[spirv(uniform, descriptor_set = 0, binding = 2)] ubo: &UBO,
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 3)] ubo_out: &mut UBOOut,
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 4)] lods: &[LOD],
+    #[spirv(spec_constant(id = 0, default = 5))] max_lod_level: u32,
+) {
+    let idx = global_id.x as usize;
+    
+    // Bounds check - important!
+    if idx >= instances.len() || idx >= indirect_draws.len() {
+        return;
+    }
+    
+    let pos = Vec4::new(instances[idx].pos[0], instances[idx].pos[1], instances[idx].pos[2], 1.0);
+    
+    // Check if object is within current viewing frustum
+    if frustum_check(pos, 1.0, &ubo.frustum_planes) {
+        indirect_draws[idx].instance_count = 1;
+        
+        // Increase number of indirect draw counts
+        unsafe {
+            atomic_i_add::<i32, { spirv_std::memory::Scope::Device as u32 }, { spirv_std::memory::Semantics::NONE.bits() }>(
+                &mut ubo_out.draw_count, 
+                1
+            );
+        }
+        
+        // Select appropriate LOD level based on distance to camera
+        let mut lod_level = max_lod_level;
+        let camera_pos_vec3 = ubo.camera_pos.xyz();
+        let instance_pos = Vec3::new(instances[idx].pos[0], instances[idx].pos[1], instances[idx].pos[2]);
+        let dist = instance_pos.distance(camera_pos_vec3);
+        for i in 0..max_lod_level {
+            if dist < lods[i as usize].distance {
+                lod_level = i;
+                break;
+            }
+        }
+        indirect_draws[idx].first_index = lods[lod_level as usize].first_index;
+        indirect_draws[idx].index_count = lods[lod_level as usize].index_count;
+        
+        // Update stats
+        unsafe {
+            atomic_i_add::<i32, { spirv_std::memory::Scope::Device as u32 }, { spirv_std::memory::Semantics::NONE.bits() }>(
+                &mut ubo_out.lod_count[lod_level as usize], 
+                1
+            );
+        }
+    } else {
+        indirect_draws[idx].instance_count = 0;
+    }
+}

shaders/rust/computecullandlod/cull/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "computecullandlod-indirectdraw"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+spirv-std = { workspace = true }

shaders/rust/computecullandlod/cull/src/lib.rs

@@ -0,0 +1,63 @@
+#![no_std]
+
+use spirv_std::spirv;
+use spirv_std::glam::{Vec3, Vec4, Mat4, Vec4Swizzles};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UBO {
+    pub projection: Mat4,
+    pub modelview: Mat4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    #[spirv(vertex_index)] _vertex_index: i32,
+    in_pos: Vec4,
+    in_normal: Vec3,
+    in_color: Vec3,
+    instance_pos: Vec3,
+    instance_scale: f32,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &UBO,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_normal: &mut Vec3,
+    out_color: &mut Vec3,
+    out_view_vec: &mut Vec3,
+    out_light_vec: &mut Vec3,
+) {
+    *out_color = in_color;
+    *out_normal = in_normal;
+    
+    let pos = Vec4::new(
+        (in_pos.x * instance_scale) + instance_pos.x,
+        (in_pos.y * instance_scale) + instance_pos.y,
+        (in_pos.z * instance_scale) + instance_pos.z,
+        1.0
+    );
+    
+    *out_position = ubo.projection * ubo.modelview * pos;
+    
+    let l_pos = Vec4::new(0.0, 10.0, 50.0, 1.0);
+    *out_light_vec = l_pos.xyz() - pos.xyz();
+    *out_view_vec = -pos.xyz();
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_normal: Vec3,
+    in_color: Vec3,
+    _in_view_vec: Vec3,
+    in_light_vec: Vec3,
+    out_frag_color: &mut Vec4,
+) {
+    let n = in_normal.normalize();
+    let l = in_light_vec.normalize();
+    let ambient = Vec3::splat(0.25);
+    let diffuse = Vec3::splat(n.dot(l).max(0.0));
+    *out_frag_color = Vec4::new(
+        (ambient.x + diffuse.x) * in_color.x,
+        (ambient.y + diffuse.y) * in_color.y,
+        (ambient.z + diffuse.z) * in_color.z,
+        1.0
+    );
+}