Add subpasses rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -110,6 +110,9 @@ members = [
     "ssao/ssao",
     "stencilbuffer/outline",
     "stencilbuffer/toon",
+    "subpasses/composition",
+    "subpasses/gbuffer",
+    "subpasses/transparent",
     "tessellation/base",
     "tessellation/passthrough",
     "tessellation/pntriangles",

shaders/rust/Cargo.toml

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

shaders/rust/subpasses/composition.frag.spv

@@ -0,0 +1,66 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{Vec2, Vec3, Vec4}};
+use spirv_std::num_traits::Float;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Light {
+    pub position: Vec4,
+    pub color: [f32; 3],
+    pub radius: f32,
+}
+
+const AMBIENT: f32 = 0.05;
+
+#[spirv(vertex)]
+pub fn main_vs(
+    #[spirv(vertex_index)] vertex_index: i32,
+    #[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(
+    #[spirv(input_attachment_index = 0, descriptor_set = 0, binding = 0)] input_position: &spirv_std::Image!(subpass, type=f32, sampled=false),
+    #[spirv(input_attachment_index = 1, descriptor_set = 0, binding = 1)] input_normal: &spirv_std::Image!(subpass, type=f32, sampled=false),
+    #[spirv(input_attachment_index = 2, descriptor_set = 0, binding = 2)] input_albedo: &spirv_std::Image!(subpass, type=f32, sampled=false),
+    #[spirv(storage_buffer, descriptor_set = 0, binding = 3)] lights: &[Light],
+    _in_uv: Vec2,
+    out_color: &mut Vec4,
+) {
+    // Read G-Buffer values from previous sub pass
+    let coord = spirv_std::glam::IVec2::new(0, 0); // Subpass reads at current fragment location
+    let frag_pos = input_position.read_subpass(coord).truncate();
+    let normal = input_normal.read_subpass(coord).truncate();
+    let albedo = input_albedo.read_subpass(coord);
+    
+    // Ambient part
+    let mut frag_color = albedo.truncate() * AMBIENT;
+    
+    for i in 0..64 {
+        let light = &lights[i];
+        let l = light.position.truncate() - frag_pos;
+        let dist = l.length();
+        
+        let l = l.normalize();
+        let atten = light.radius / (dist.powf(3.0) + 1.0);
+        
+        let n = normal.normalize();
+        let n_dot_l = n.dot(l).max(0.0);
+        let color = Vec3::new(light.color[0], light.color[1], light.color[2]);
+        let diff = color * albedo.truncate() * n_dot_l * atten;
+        
+        frag_color += diff;
+    }
+    
+    *out_color = Vec4::new(frag_color.x, frag_color.y, frag_color.z, 1.0);
+}

shaders/rust/subpasses/composition.vert.spv

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

shaders/rust/subpasses/composition/Cargo.toml

@@ -0,0 +1,72 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{Mat3, Mat4, Vec3, Vec4}};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ubo {
+    pub projection: Mat4,
+    pub model: Mat4,
+    pub view: Mat4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec4,
+    in_color: Vec3,
+    in_normal: Vec3,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &Ubo,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_normal: &mut Vec3,
+    out_color: &mut Vec3,
+    out_world_pos: &mut Vec3,
+    _out_tangent: &mut Vec3,
+) {
+    *out_position = ubo.projection * ubo.view * ubo.model * in_pos;
+    
+    // Vertex position in world space
+    let world_pos = (ubo.model * in_pos).truncate();
+    // GL to Vulkan coord space
+    *out_world_pos = Vec3::new(world_pos.x, -world_pos.y, world_pos.z);
+    
+    // Normal in world space
+    let m_normal = Mat3::from_mat4(ubo.model).transpose().inverse();
+    *out_normal = m_normal * in_normal.normalize();
+    
+    // Currently just vertex color
+    *out_color = in_color;
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    #[spirv(frag_coord)] frag_coord: Vec4,
+    in_normal: Vec3,
+    in_color: Vec3,
+    in_world_pos: Vec3,
+    #[spirv(spec_constant(id = 0))] near_plane_bits: u32,
+    #[spirv(spec_constant(id = 1))] far_plane_bits: u32,
+    out_color: &mut Vec4,
+    out_position: &mut Vec4,
+    out_normal: &mut Vec4,
+    out_albedo: &mut Vec4,
+) {
+    *out_position = Vec4::new(in_world_pos.x, in_world_pos.y, in_world_pos.z, 1.0);
+    
+    let mut n = in_normal.normalize();
+    n.y = -n.y;
+    *out_normal = Vec4::new(n.x, n.y, n.z, 1.0);
+    
+    out_albedo.x = in_color.x;
+    out_albedo.y = in_color.y;
+    out_albedo.z = in_color.z;
+    
+    // Store linearized depth in alpha component
+    let near_plane = f32::from_bits(near_plane_bits);
+    let far_plane = f32::from_bits(far_plane_bits);
+    let z = frag_coord.z * 2.0 - 1.0;
+    out_position.w = (2.0 * near_plane * far_plane) / (far_plane + near_plane - z * (far_plane - near_plane));
+    
+    // Write color attachments to avoid undefined behaviour (validation error)
+    *out_color = Vec4::ZERO;
+}