Add offscreen rust shaders

Author: LegNeato

shaders/rust/Cargo.lock

@@ -81,6 +81,9 @@ members = [
     "textoverlay/text",
     "textoverlay/mesh",
     "shaderobjects/phong",
+    "offscreen/quad",
+    "offscreen/mirror",
+    "offscreen/phong",
 ]
 
 [workspace.dependencies]

shaders/rust/Cargo.toml

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

shaders/rust/offscreen/mirror.frag.spv

@@ -0,0 +1,59 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{vec2, vec4, Mat4, Vec3, Vec4}, Image};
+use spirv_std::image::SampledImage;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ubo {
+    pub projection: Mat4,
+    pub view: Mat4,
+    pub model: Mat4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec3,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &Ubo,
+    #[spirv(position)] out_position: &mut Vec4,
+    out_pos: &mut Vec4,
+) {
+    let pos = ubo.projection * ubo.view * ubo.model * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    *out_pos = pos;
+    *out_position = pos;
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_pos: Vec4,
+    #[spirv(front_facing)] front_facing: bool,
+    #[spirv(descriptor_set = 0, binding = 1)] sampler_color: &SampledImage<Image!(2D, type=f32, sampled)>,
+    out_frag_color: &mut Vec4,
+) {
+    let tmp = vec4(1.0 / in_pos.w, 1.0 / in_pos.w, 1.0 / in_pos.w, 1.0 / in_pos.w);
+    let proj_coord = in_pos * tmp;
+    
+    // Scale and bias
+    let proj_coord = proj_coord + vec4(1.0, 1.0, 1.0, 1.0);
+    let proj_coord = proj_coord * vec4(0.5, 0.5, 0.5, 0.5);
+    
+    // Slow single pass blur
+    // For demonstration purposes only
+    const BLUR_SIZE: f32 = 1.0 / 512.0;
+    
+    *out_frag_color = vec4(0.0, 0.0, 0.0, 1.0);
+    
+    if front_facing {
+        // Only render mirrored scene on front facing (upper) side of mirror surface
+        let mut reflection = vec4(0.0, 0.0, 0.0, 0.0);
+        for x in -3..=3 {
+            for y in -3..=3 {
+                let offset = vec2(x as f32 * BLUR_SIZE, y as f32 * BLUR_SIZE);
+                let uv = vec2(proj_coord.x + offset.x, proj_coord.y + offset.y);
+                reflection = reflection + sampler_color.sample(uv) / 49.0;
+            }
+        }
+        *out_frag_color = *out_frag_color + reflection;
+    }
+}

shaders/rust/offscreen/mirror.vert.spv

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

shaders/rust/offscreen/mirror/Cargo.toml

@@ -0,0 +1,62 @@
+#![cfg_attr(target_arch = "spirv", no_std)]
+#![allow(clippy::missing_safety_doc)]
+
+use spirv_std::{spirv, glam::{vec4, Mat4, Vec3, Vec4}, num_traits::Float};
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct Ubo {
+    pub projection: Mat4,
+    pub view: Mat4,
+    pub model: Mat4,
+    pub light_pos: Vec4,
+}
+
+#[spirv(vertex)]
+pub fn main_vs(
+    in_pos: Vec3,
+    in_color: Vec3,
+    in_normal: Vec3,
+    #[spirv(uniform, descriptor_set = 0, binding = 0)] ubo: &Ubo,
+    #[spirv(position)] out_position: &mut Vec4,
+    #[spirv(clip_distance)] clip_distance: &mut [f32; 1],
+    out_normal: &mut Vec3,
+    out_color: &mut Vec3,
+    out_eye_pos: &mut Vec3,
+    out_light_vec: &mut Vec3,
+) {
+    *out_normal = in_normal;
+    *out_color = in_color;
+    *out_position = ubo.projection * ubo.view * ubo.model * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    let eye_pos = ubo.view * ubo.model * vec4(in_pos.x, in_pos.y, in_pos.z, 1.0);
+    *out_eye_pos = eye_pos.truncate();
+    *out_light_vec = (ubo.light_pos.truncate() - *out_eye_pos).normalize();
+    
+    // Clip against reflection plane
+    let clip_plane = vec4(0.0, -1.0, 0.0, 0.0);
+    clip_distance[0] = vec4(in_pos.x, in_pos.y, in_pos.z, 1.0).dot(clip_plane);
+}
+
+#[spirv(fragment)]
+pub fn main_fs(
+    in_normal: Vec3,
+    in_color: Vec3,
+    in_eye_pos: Vec3,
+    in_light_vec: Vec3,
+    out_frag_color: &mut Vec4,
+) {
+    let eye = (-in_eye_pos).normalize();
+    let reflected = (-in_light_vec).reflect(in_normal).normalize();
+    
+    let i_ambient = vec4(0.1, 0.1, 0.1, 1.0);
+    let i_diffuse = vec4(in_normal.dot(in_light_vec).max(0.0), in_normal.dot(in_light_vec).max(0.0), in_normal.dot(in_light_vec).max(0.0), in_normal.dot(in_light_vec).max(0.0));
+    let specular = 0.75;
+    let mut i_specular = vec4(0.0, 0.0, 0.0, 0.0);
+    if in_eye_pos.dot(in_normal) < 0.0 {
+        let spec_factor = reflected.dot(eye).max(0.0).powf(16.0) * specular;
+        i_specular = vec4(0.5, 0.5, 0.5, 1.0) * spec_factor;
+    }
+    
+    let color_vec4 = vec4(in_color.x, in_color.y, in_color.z, 1.0);
+    *out_frag_color = (i_ambient + i_diffuse) * color_vec4 + i_specular;
+}