Add deferredmultisampling rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -27,6 +27,8 @@ members = [
     "debugutils/toon",
     "deferred/deferred",
     "deferred/mrt",
+    "deferredmultisampling/deferred",
+    "deferredmultisampling/mrt",
     "descriptorbuffer/cube",
     "descriptorindexing",
     "descriptorsets/cube",

shaders/rust/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "deferredmultisampling-deferred"
+version = "0.1.0"
+edition.workspace = true
+
+[lib]
+crate-type = ["dylib"]
+
+[dependencies]
+spirv-std = { workspace = true }
+
+[package.metadata.rust-gpu.build]
+capabilities = ["ImageQuery"]

shaders/rust/deferredmultisampling/deferred.frag.spv

@@ -0,0 +1,125 @@
+#![no_std]
+
+use spirv_std::glam::{ivec2, vec2, vec4, IVec2, UVec2, Vec2, Vec3, Vec4, Vec4Swizzles};
+use spirv_std::image::{ImageWithMethods, sample_with};
+use spirv_std::{num_traits::Float, spirv, Image};
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct Light {
+    pub position: Vec4,     // 16 bytes, aligned to 16
+    pub color_radius: Vec4, // 16 bytes - store color.xyz in xyz, radius in w
+}
+
+#[repr(C, align(16))]
+#[derive(Copy, Clone)]
+pub struct UBO {
+    pub lights: [Light; 6],      // 6 * 32 = 192 bytes
+    pub view_pos: Vec4,           // 16 bytes, total = 208 bytes  
+    pub _padding1: Vec4,          // 16 bytes padding to align next member to 224
+    pub debug_display_target: Vec4, // Use Vec4 with debug_display_target in x component
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    #[spirv(vertex_index)] vert_index: i32,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_uv: &mut Vec2,
+) {
+    let uv = vec2(((vert_index << 1) & 2) as f32, (vert_index & 2) as f32);
+    *out_uv = uv;
+    *out_position = vec4(uv.x * 2.0 - 1.0, uv.y * 2.0 - 1.0, 0.0, 1.0);
+}
+
+const NUM_LIGHTS: usize = 6;
+
+fn resolve(tex: &Image!(2D, format=rgba8, sampled, multisampled), uv: IVec2, num_samples: u32) -> Vec4 {
+    let mut result = Vec4::ZERO;
+    for i in 0..num_samples {
+        let val: Vec4 = tex.fetch_with(uv, sample_with::sample_index(i as i32));
+        result += val;
+    }
+    // Average resolved samples
+    result / (num_samples as f32)
+}
+
+fn calculate_lighting(pos: Vec3, normal: Vec3, albedo: Vec4, ubo: &UBO) -> Vec3 {
+    let mut result = Vec3::ZERO;
+
+    for i in 0..NUM_LIGHTS {
+        // Vector to light
+        let l = ubo.lights[i].position.xyz() - pos;
+        // Distance from light to fragment position
+        let dist = l.length();
+
+        // Viewer to fragment
+        let v = (ubo.view_pos.xyz() - pos).normalize();
+        
+        // Light to fragment
+        let l = l.normalize();
+
+        // Attenuation
+        let atten = ubo.lights[i].color_radius.w / (dist.powf(2.0) + 1.0);
+
+        // Diffuse part
+        let n = normal.normalize();
+        let n_dot_l = n.dot(l).max(0.0);
+        let diff = ubo.lights[i].color_radius.xyz() * albedo.xyz() * n_dot_l * atten;
+
+        // Specular part
+        let r = (-l).reflect(n);
+        let n_dot_r = r.dot(v).max(0.0);
+        let spec = ubo.lights[i].color_radius.xyz() * albedo.w * n_dot_r.powf(8.0) * atten;
+
+        result += diff + spec;
+    }
+    result
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_uv: Vec2,
+    #[spirv(descriptor_set = 0, binding = 1)] sampler_position: &Image!(2D, format=rgba16f, sampled, multisampled),
+    #[spirv(descriptor_set = 0, binding = 2)] sampler_normal: &Image!(2D, format=rgba16f, sampled, multisampled),
+    #[spirv(descriptor_set = 0, binding = 3)] sampler_albedo: &Image!(2D, format=rgba8, sampled, multisampled),
+    #[spirv(uniform, descriptor_set = 0, binding = 4)] ubo: &UBO,
+    #[spirv(spec_constant(id = 0, default = 8))] num_samples: u32,
+    out_frag_color: &mut Vec4,
+) {
+    let att_dim: UVec2 = sampler_position.query_size();
+    let uv = ivec2((in_uv.x * att_dim.x as f32) as i32, (in_uv.y * att_dim.y as f32) as i32);
+    
+    // Debug display
+    if ubo.debug_display_target.x as i32 > 0 {
+        let val: Vec4 = match ubo.debug_display_target.x as i32 {
+            1 => sampler_position.fetch_with(uv, sample_with::sample_index(0)),
+            2 => sampler_normal.fetch_with(uv, sample_with::sample_index(0)),
+            3 => sampler_albedo.fetch_with(uv, sample_with::sample_index(0)),
+            4 => {
+                let alb: Vec4 = sampler_albedo.fetch_with(uv, sample_with::sample_index(0));
+                vec4(alb.w, alb.w, alb.w, 1.0)
+            },
+            _ => Vec4::ZERO,
+        };
+        *out_frag_color = vec4(val.x, val.y, val.z, 1.0);
+        return;
+    }
+
+    const AMBIENT: f32 = 0.15;
+
+    // Ambient part
+    let alb = resolve(sampler_albedo, uv, num_samples);
+    let mut frag_color = Vec3::ZERO;
+    
+    // Calculate lighting for every MSAA sample
+    for i in 0..num_samples {
+        let pos: Vec4 = sampler_position.fetch_with(uv, sample_with::sample_index(i as i32));
+        let normal: Vec4 = sampler_normal.fetch_with(uv, sample_with::sample_index(i as i32));
+        let albedo: Vec4 = sampler_albedo.fetch_with(uv, sample_with::sample_index(i as i32));
+        frag_color += calculate_lighting(pos.xyz(), normal.xyz(), albedo, ubo);
+    }
+
+    frag_color = (alb.xyz() * AMBIENT) + frag_color / (num_samples as f32);
+   
+    *out_frag_color = vec4(frag_color.x, frag_color.y, frag_color.z, 1.0);
+}

shaders/rust/deferredmultisampling/deferred.vert.spv

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

shaders/rust/deferredmultisampling/deferred/Cargo.toml

@@ -0,0 +1,76 @@
+#![no_std]
+
+use spirv_std::glam::{vec4, Mat3, Mat4, Vec2, Vec3, Vec4, Vec4Swizzles};
+use spirv_std::spirv;
+use spirv_std::Image;
+use spirv_std::image::SampledImage;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct UBO {
+    pub projection: Mat4,
+    pub model: Mat4,
+    pub view: Mat4,
+    pub instance_pos: [Vec4; 3],
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec4,
+    in_uv: Vec2,
+    in_color: Vec3,
+    in_normal: Vec3,
+    in_tangent: Vec3,
+    #[spirv(instance_index)] instance_index: i32,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &UBO,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_normal: &mut Vec3,
+    out_uv: &mut Vec2,
+    out_color: &mut Vec3,
+    out_world_pos: &mut Vec3,
+    out_tangent: &mut Vec3,
+) {
+    let tmp_pos = vec4(in_pos.x, in_pos.y, in_pos.z, 1.0) + ubo.instance_pos[instance_index as usize];
+    
+    *out_position = ubo.projection * ubo.view * ubo.model * tmp_pos;
+    
+    *out_uv = in_uv;
+    
+    // Vertex position in world space
+    *out_world_pos = (ubo.model * tmp_pos).xyz();
+    
+    // Normal in world space
+    let m_normal = Mat3::from_mat4(ubo.model).inverse().transpose();
+    *out_normal = (m_normal * in_normal.normalize()).normalize();
+    *out_tangent = (m_normal * in_tangent.normalize()).normalize();
+    
+    // Currently just vertex color
+    *out_color = in_color;
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_normal: Vec3,
+    in_uv: Vec2,
+    _in_color: Vec3,
+    in_world_pos: Vec3,
+    in_tangent: Vec3,
+    #[spirv(descriptor_set = 0, binding = 1)] sampler_color: &SampledImage<Image!(2D, type=f32, sampled)>,
+    #[spirv(descriptor_set = 0, binding = 2)] sampler_normal_map: &SampledImage<Image!(2D, type=f32, sampled)>,
+    out_position: &mut Vec4,
+    out_normal: &mut Vec4,
+    out_albedo: &mut Vec4,
+) {
+    *out_position = vec4(in_world_pos.x, in_world_pos.y, in_world_pos.z, 1.0);
+    
+    // Calculate normal in tangent space
+    let n = in_normal.normalize();
+    let t = in_tangent.normalize();
+    let b = n.cross(t);
+    let tbn = Mat3::from_cols(t, b, n);
+    let sampled_normal = sampler_normal_map.sample(in_uv).xyz() * 2.0 - Vec3::splat(1.0);
+    let tnorm = tbn * sampled_normal.normalize();
+    *out_normal = vec4(tnorm.x, tnorm.y, tnorm.z, 1.0);
+    
+    *out_albedo = sampler_color.sample(in_uv);
+}