Add particlesystem rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -65,6 +65,8 @@ members = [
     "offscreen/phong",
     "offscreen/quad",
     "parallaxmapping/parallax",
+    "particlesystem/particle",
+    "particlesystem/normalmap",
     "pbrbasic/pbr",
     "pbribl/filtercube",
     "pbribl/genbrdflut",

shaders/rust/Cargo.toml

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

shaders/rust/particlesystem/normalmap.frag.spv

@@ -0,0 +1,102 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{mat3, vec3, vec4, Mat4, Vec2, Vec3, Vec4}, num_traits::Float};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ubo {
+    pub projection: Mat4,
+    pub model: Mat4,
+    pub normal: Mat4,
+    pub light_pos: Vec4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec3,
+    in_uv: Vec2,
+    in_normal: Vec3,
+    in_tangent: Vec4,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &Ubo,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_uv: &mut Vec2,
+    out_light_vec: &mut Vec3,
+    out_light_vec_b: &mut Vec3,
+    out_light_dir: &mut Vec3,
+    out_view_vec: &mut Vec3,
+) {
+    let vertex_position = (ubo.model * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0)).truncate();
+    *out_light_dir = (ubo.light_pos.truncate() - vertex_position).normalize();
+    
+    let bi_tangent = in_normal.cross(in_tangent.truncate());
+    
+    // Setup (t)angent-(b)inormal-(n)ormal matrix for converting
+    // object coordinates into tangent space
+    let normal_mat3 = mat3(
+        ubo.normal.x_axis.truncate(),
+        ubo.normal.y_axis.truncate(),
+        ubo.normal.z_axis.truncate(),
+    );
+    let tbn_matrix = mat3(
+        normal_mat3 * in_tangent.truncate(),
+        normal_mat3 * bi_tangent,
+        normal_mat3 * in_normal
+    );
+    
+    *out_light_vec = tbn_matrix.transpose() * (ubo.light_pos.truncate() - vertex_position);
+    
+    let light_dist = ubo.light_pos.truncate() - in_pos;
+    *out_light_vec_b = vec3(
+        in_tangent.truncate().dot(light_dist),
+        bi_tangent.dot(light_dist),
+        in_normal.dot(light_dist)
+    );
+    
+    *out_view_vec = vec3(
+        in_tangent.truncate().dot(in_pos),
+        bi_tangent.dot(in_pos),
+        in_normal.dot(in_pos)
+    );
+    
+    *out_uv = in_uv;
+    
+    *out_position = ubo.projection * ubo.model * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+}
+
+const LIGHT_RADIUS: f32 = 45.0;
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_uv: Vec2,
+    in_light_vec: Vec3,
+    in_light_vec_b: Vec3,
+    _in_light_dir: Vec3,
+    in_view_vec: Vec3,
+    #[spirv(descriptor_set = 0, binding = 1)] s_color_map: &spirv_std::image::SampledImage<spirv_std::Image!(2D, type=f32, sampled)>,
+    #[spirv(descriptor_set = 0, binding = 2)] s_normal_height_map: &spirv_std::image::SampledImage<spirv_std::Image!(2D, type=f32, sampled)>,
+    out_frag_color: &mut Vec4,
+) {
+    let specular_color = vec3(0.85, 0.5, 0.0);
+    
+    let inv_radius = 1.0 / LIGHT_RADIUS;
+    let ambient = 0.25;
+    
+    let rgb = s_color_map.sample(in_uv).truncate();
+    let normal = ((s_normal_height_map.sample(in_uv).truncate() - 0.5) * 2.0).normalize();
+    
+    let dist_sqr = in_light_vec_b.dot(in_light_vec_b);
+    let l_vec = in_light_vec_b * (1.0 / dist_sqr.sqrt());
+    
+    let atten = (1.0 - inv_radius * dist_sqr.sqrt()).clamp(0.0, 1.0).max(ambient);
+    let diffuse = l_vec.dot(normal).clamp(0.0, 1.0);
+    
+    let light = (-in_light_vec).normalize();
+    let view = in_view_vec.normalize();
+    let reflect_dir = (-light).reflect(normal);
+    
+    let specular = view.dot(reflect_dir).max(0.0).powf(4.0);
+    
+    let final_color = (rgb * atten + (diffuse * rgb + 0.5 * specular * specular_color)) * atten;
+    *out_frag_color = vec4(final_color.x, final_color.y, final_color.z, 1.0);
+}

shaders/rust/particlesystem/normalmap.vert.spv

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

shaders/rust/particlesystem/normalmap/Cargo.toml

@@ -0,0 +1,87 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{vec4, Mat4, Vec2, Vec4}, num_traits::Float};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ubo {
+    pub projection: Mat4,
+    pub modelview: Mat4,
+    pub viewport_dim: Vec2,
+    pub point_size: f32,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec4,
+    in_color: Vec4,
+    in_alpha: f32,
+    in_size: f32,
+    in_rotation: f32,
+    in_type: i32,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &Ubo,
+    #[spirv(position)] out_position: &mut Vec4,
+    #[spirv(point_size)] out_point_size: &mut f32,
+    out_color: &mut Vec4,
+    out_alpha: &mut f32,
+    #[spirv(flat)] out_type: &mut i32,
+    out_rotation: &mut f32,
+) {
+    *out_color = in_color;
+    *out_alpha = in_alpha;
+    *out_type = in_type;
+    *out_rotation = in_rotation;
+    
+    *out_position = ubo.projection * ubo.modelview * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    
+    // Base size of the point sprites
+    let sprite_size = 8.0 * in_size;
+    
+    // Scale particle size depending on camera projection
+    let eye_pos = ubo.modelview * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    let projected_corner = ubo.projection * vec4(0.5 * sprite_size, 0.5 * sprite_size, eye_pos.z, eye_pos.w);
+    *out_point_size = ubo.viewport_dim.x * projected_corner.x / projected_corner.w;
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    #[spirv(point_coord)] point_coord: Vec2,
+    in_color: Vec4,
+    in_alpha: f32,
+    #[spirv(flat)] in_type: i32,
+    in_rotation: f32,
+    #[spirv(descriptor_set = 0, binding = 1)] sampler_smoke: &spirv_std::image::SampledImage<spirv_std::Image!(2D, type=f32, sampled)>,
+    #[spirv(descriptor_set = 0, binding = 2)] sampler_fire: &spirv_std::image::SampledImage<spirv_std::Image!(2D, type=f32, sampled)>,
+    out_frag_color: &mut Vec4,
+) {
+    let alpha = if in_alpha <= 1.0 { in_alpha } else { 2.0 - in_alpha };
+    
+    // Rotate texture coordinates
+    let rot_center = 0.5;
+    let rot_cos = in_rotation.cos();
+    let rot_sin = in_rotation.sin();
+    let rot_uv = Vec2::new(
+        rot_cos * (point_coord.x - rot_center) + rot_sin * (point_coord.y - rot_center) + rot_center,
+        rot_cos * (point_coord.y - rot_center) - rot_sin * (point_coord.x - rot_center) + rot_center
+    );
+    
+    let color = if in_type == 0 {
+        // Flame
+        let c = sampler_fire.sample(rot_uv);
+        out_frag_color.w = 0.0;
+        c
+    } else {
+        // Smoke
+        let c = sampler_smoke.sample(rot_uv);
+        out_frag_color.w = c.w * alpha;
+        c
+    };
+    
+    *out_frag_color = vec4(
+        color.x * in_color.x * alpha,
+        color.y * in_color.y * alpha,
+        color.z * in_color.z * alpha,
+        out_frag_color.w
+    );
+}