Add shadowmappingomni rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -9,6 +9,8 @@ members = [
     "bloom/skybox",
     "computecloth/cloth",
     "computecloth/sphere",
+    "computecullandlod/cull",
+    "computecullandlod/indirectdraw",
     "computeheadless/headless",
     "computenbody/particle",
     "computenbody/particle_calculate",
@@ -91,6 +93,9 @@ members = [
     "shadowmapping/offscreen",
     "shadowmapping/quad",
     "shadowmapping/scene",
+    "shadowmappingomni/cubemapdisplay",
+    "shadowmappingomni/offscreen",
+    "shadowmappingomni/scene",
     "specializationconstants/uber",
     "sphericalenvmapping/sem",
     "ssao/blur",

shaders/rust/Cargo.toml

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

shaders/rust/shadowmappingomni/cubemapdisplay.frag.spv

@@ -0,0 +1,83 @@
+#![no_std]
+
+use spirv_std::spirv;
+use spirv_std::glam::{Vec2, Vec3, Vec4, Mat4, Vec4Swizzles};
+use spirv_std::num_traits::Float;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UBO {
+    pub projection: Mat4,
+    pub view: Mat4,
+    pub model: Mat4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    #[spirv(vertex_index)] vertex_index: i32,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] _ubo: &UBO,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_uv: &mut Vec2,
+) {
+    let uv = Vec2::new(
+        ((vertex_index << 1) & 2) as f32,
+        (vertex_index & 2) as f32,
+    );
+    *out_uv = uv;
+    *out_position = Vec4::new(uv.x * 2.0 - 1.0, uv.y * 2.0 - 1.0, 0.0, 1.0);
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_uv: Vec2,
+    #[spirv(descriptor_set = 0, binding = 1)] shadow_cube_map: &spirv_std::Image!(cube, type=f32, sampled),
+    #[spirv(descriptor_set = 0, binding = 1)] sampler: &spirv_std::Sampler,
+    out_frag_color: &mut Vec4,
+) {
+    *out_frag_color = Vec4::new(0.05, 0.05, 0.05, 1.0);
+    
+    let mut sample_pos = Vec3::ZERO;
+    
+    // Crude statement to visualize different cube map faces based on UV coordinates
+    let x = (in_uv.x / 0.25).floor() as i32;
+    let y = (in_uv.y / (1.0 / 3.0)).floor() as i32;
+    
+    if y == 1 {
+        let mut uv = Vec2::new(in_uv.x * 4.0, (in_uv.y - 1.0/3.0) * 3.0);
+        uv = 2.0 * Vec2::new(uv.x - (x as f32) * 1.0, uv.y) - Vec2::ONE;
+        match x {
+            0 => {  // NEGATIVE_X
+                sample_pos = Vec3::new(-1.0, uv.y, uv.x);
+            }
+            1 => {  // POSITIVE_Z
+                sample_pos = Vec3::new(uv.x, uv.y, 1.0);
+            }
+            2 => {  // POSITIVE_X
+                sample_pos = Vec3::new(1.0, uv.y, -uv.x);
+            }
+            3 => {  // NEGATIVE_Z
+                sample_pos = Vec3::new(-uv.x, uv.y, -1.0);
+            }
+            _ => {}
+        }
+    } else {
+        if x == 1 {
+            let uv = 2.0 * Vec2::new((in_uv.x - 0.25) * 4.0, (in_uv.y - (y as f32) / 3.0) * 3.0) - Vec2::ONE;
+            match y {
+                0 => {  // NEGATIVE_Y
+                    sample_pos = Vec3::new(uv.x, -1.0, uv.y);
+                }
+                2 => {  // POSITIVE_Y
+                    sample_pos = Vec3::new(uv.x, 1.0, -uv.y);
+                }
+                _ => {}
+            }
+        }
+    }
+    
+    if sample_pos.x != 0.0 && sample_pos.y != 0.0 {
+        let sampled: Vec4 = shadow_cube_map.sample_by_lod(*sampler, sample_pos, 0.0);
+        let dist = sampled.xyz().length() * 0.005;
+        *out_frag_color = Vec4::new(dist, dist, dist, 1.0);
+    }
+}

shaders/rust/shadowmappingomni/cubemapdisplay.vert.spv

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

shaders/rust/shadowmappingomni/cubemapdisplay/Cargo.toml

@@ -0,0 +1,45 @@
+#![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 view: Mat4,
+    pub model: Mat4,
+    pub light_pos: Vec4,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct PushConsts {
+    pub view: Mat4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    #[spirv(vertex_index)] _vertex_index: i32,
+    in_pos: Vec3,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &UBO,
+    #[spirv(push_constant)] push_consts: &PushConsts,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_pos: &mut Vec4,
+    out_light_pos: &mut Vec3,
+) {
+    *out_position = ubo.projection * push_consts.view * ubo.model * Vec4::new(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    *out_pos = Vec4::new(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    *out_light_pos = ubo.light_pos.xyz();
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_pos: Vec4,
+    in_light_pos: Vec3,
+    out_frag_color: &mut f32,
+) {
+    // Store distance to light as 32 bit float value
+    let light_vec = in_pos.xyz() - in_light_pos;
+    *out_frag_color = light_vec.length();
+}