port frag to wgsl

shader/default.wgsl

@@ -0,0 +1,42 @@
+// fragment shader
+
+struct Time {
+    t: f32;
+};
+struct Resolution {
+    r: vec2<f32>;
+};
+
+
+[[group(0), binding(0)]]
+var<uniform> time: Time;
+
+[[group(1), binding(0)]]
+var<uniform> resolution: Resolution;
+
+fn mod(d: f32, m: f32) -> f32 {
+    return d - floor(d/m);
+}
+
+fn hsv(h: f32, s: f32, v: f32) -> vec3<f32> {
+    let t = vec4<f32>(1.0, 2.0/ 3.0, 1.0 / 3.0, 3.0);
+    let p = abs(fract(vec3<f32>(h) + t.xyz) * 6.0 - vec3<f32>(t.w));
+    return v * mix(vec3<f32>(t.x), clamp(p - vec3<f32>(t.x), vec3<f32>(0.0), vec3<f32>(1.0)), s);
+}
+
+[[stage(fragment)]]
+fn main([[builtin(position)]] FragCoord : vec4<f32>) -> [[location(0)]] vec4<f32> {
+    let r = resolution.r;
+    let p = (FragCoord.xy * 2.0 - r) / min(r.x, r.y);
+    var j = 0;
+    let x = vec2<f32>(-0.345, 0.654);
+    let y = vec2<f32>(time.t * 0.005, 0.0);
+    var z = p;
+    for(var i: i32 = 0; i < 360; i = i + 1) {
+        j = j + 1;
+        if(length(z) > 2.0){break;}
+        z = vec2<f32>(z.x * z.x - z.y * z.y, 2.0 * z.x * z.y) + x + y;
+    }
+    let h = abs(mod(time.t * 15.0 - f32(j), 360.0) / 360.0);
+    return vec4<f32>(hsv(h, 1.0, 1.0), 1.0);
+}

src/main.rs

@@ -1,4 +1,4 @@
-use std::{mem, time::Instant};
+use std::{env, fs, mem, time::Instant};
 
 use naga::{FastHashMap, ShaderStage};
 use wgpu::{
@@ -64,6 +64,23 @@ impl ResolutionUniform {
 
 fn main() {
     env_logger::init();
+    let shader_source = env::args().nth(1).unwrap();
+
+    let shader = if shader_source.ends_with(".frag") {
+        let source = fs::read_to_string(shader_source).unwrap();
+        wgpu::ShaderSource::Glsl {
+            shader: source.into(),
+            stage: ShaderStage::Fragment,
+            /// Defines to unlock configured shader features
+            defines: FastHashMap::default(),
+        }
+    } else if shader_source.ends_with(".wgsl") {
+        let source = fs::read_to_string(shader_source).unwrap();
+        wgpu::ShaderSource::Wgsl(source.into())
+    } else {
+        panic!("unknown shader type {}", shader_source)
+    };
+
     let event_loop = EventLoop::new();
     let window = WindowBuilder::new()
         .with_inner_size(PhysicalSize::new(512, 512))
@@ -110,12 +127,7 @@ fn main() {
 
     let f_shader = device.create_shader_module(&wgpu::ShaderModuleDescriptor {
         label: Some("Fragment Shader"),
-        source: wgpu::ShaderSource::Glsl {
-            shader: include_str!("shader.frag").into(),
-            stage: ShaderStage::Fragment,
-            /// Defines to unlock configured shader features
-            defines: FastHashMap::default(),
-        },
+        source: shader,
     });
 
     let t = TimeUniform { t: 0.0 };