flux: implement multi-view rendering

Cargo.toml

@@ -1,12 +1,12 @@
 [workspace]
 resolver = "2"
 members = [
-  "flux",
-  "flux-desktop",
-  "flux-wasm",
-  "flux-gl/flux",
-  "flux-gl/flux-desktop",
-  "flux-gl/flux-wasm",
+    "flux",
+    "flux-desktop",
+    "flux-wasm",
+    "flux-gl/flux",
+    "flux-gl/flux-desktop",
+    "flux-gl/flux-wasm",
 ]
 
 [workspace.package]
@@ -27,11 +27,13 @@ features = ["jpeg", "png"]
 version = "0.25"
 
 [workspace.dependencies]
+approx = "0.5.1"
 env_logger = "0.10"
 bytemuck = { version = "1.4", features = ["derive"] }
 flux = { path = "./flux" }
 futures = "0.3"
 getrandom = { version = "0.2", features = ["js"] }
+glam = "0.29.2"
 half = { version = "2", features = ["bytemuck"] }
 log = "0.4"
 pollster = "0.3"
@@ -66,7 +68,6 @@ opt-level = 3
 
 [profile.release]
 codegen-units = 1 # Allow further optimisations by disabling parallel compilation
-lto = true # Enable link-time optimisations
-opt-level = "s" # Optimise for size
-panic = "abort" # Strip expensive panic unwinding code
-
+lto = true        # Enable link-time optimisations
+opt-level = "s"   # Optimise for size
+panic = "abort"   # Strip expensive panic unwinding code

flux-desktop/src/main.rs

@@ -244,6 +244,7 @@ async fn run(
                         &command_queue,
                         &mut encoder,
                         &view,
+                        None,
                         start.elapsed().as_secs_f64() * 1000.0,
                     );
 

flux-wasm/src/wasm_wrapper.rs

@@ -1,7 +1,5 @@
 use flux::{self, settings};
 use gloo_utils::format::JsValueSerdeExt;
-use serde::Serialize;
-use std::rc::Rc;
 use std::sync::Arc;
 
 use wasm_bindgen::prelude::*;
@@ -15,6 +13,7 @@ pub struct Flux {
     canvas: Canvas,
     device: wgpu::Device,
     queue: wgpu::Queue,
+    #[allow(dead_code)]
     window: Arc<winit::window::Window>,
     window_surface: wgpu::Surface<'static>,
     logical_width: u32,
@@ -140,7 +139,7 @@ impl Flux {
         log::debug!("{:?}\n{:?}", adapter.get_info(), adapter.features(),);
 
         // Make sure we use the texture resolution limits from the adapter, so we can support images the size of the swapchain.
-        let mut limits = wgpu::Limits::downlevel_defaults().using_resolution(adapter.limits());
+        let limits = wgpu::Limits::downlevel_defaults().using_resolution(adapter.limits());
 
         let features = wgpu::Features::TEXTURE_ADAPTER_SPECIFIC_FORMAT_FEATURES
             | wgpu::Features::FLOAT32_FILTERABLE;
@@ -214,8 +213,14 @@ impl Flux {
                 label: Some("flux:render"),
             });
 
-        self.instance
-            .animate(&self.device, &self.queue, &mut encoder, &view, timestamp);
+        self.instance.animate(
+            &self.device,
+            &self.queue,
+            &mut encoder,
+            &view,
+            None,
+            timestamp,
+        );
 
         self.queue.submit(Some(encoder.finish()));
         frame.present();

flux/Cargo.toml

@@ -9,8 +9,10 @@ edition.workspace = true
 publish = false
 
 [dependencies]
+approx.workspace = true
 bytemuck.workspace = true
 getrandom.workspace = true
+glam.workspace = true
 image.workspace = true
 log.workspace = true
 rand.workspace = true

flux/shader/endpoint.wgsl

@@ -14,6 +14,7 @@ struct LineUniforms {
 }
 
 @group(0) @binding(0) var<uniform> uniforms: LineUniforms;
+@group(1) @binding(0) var<uniform> view_matrix: mat4x4<f32>;
 
 struct VertexOutput {
   @builtin(position) f_position: vec4<f32>,
@@ -41,6 +42,8 @@ fn main_vs(
 
   point.x /= uniforms.aspect;
 
+  let transformed_point = view_matrix * vec4<f32>(point, 0.0, 1.0);
+
   // Rotate the endpoint vector 90°. We use this to detect which side of the
   // endpoint we’re on in the fragment.
   let midpoint_vector = vec2<f32>(endpoint.y, -endpoint.x);
@@ -67,7 +70,7 @@ fn main_vs(
   let bottom_color = vec4<f32>(color.rgb * endpoint_opacity - premultiplied_color, 1.0);
 
   return VertexOutput(
-    vec4<f32>(point, 0.0, 1.0),
+    transformed_point,
     vertex,
     midpoint_vector,
     top_color,

flux/shader/line.wgsl

@@ -14,6 +14,7 @@ struct LineUniforms {
 }
 
 @group(0) @binding(0) var<uniform> uniforms: LineUniforms;
+@group(1) @binding(0) var<uniform> view_matrix: mat4x4<f32>;
 
 struct VertexOutput {
   @builtin(position) position: vec4<f32>,
@@ -33,7 +34,7 @@ fn main_vs(
   @location(6) vertex: vec2<f32>, // 56
 ) -> VertexOutput { // 64
   var x_basis = vec2<f32>(-endpoint.y, endpoint.x);
-  x_basis /= length(x_basis) + 0.0001; // safely normalize
+  x_basis /= max(length(x_basis), 1e-10); // safely normalize
 
   var point = vec2<f32>(uniforms.aspect, 1.0) * uniforms.zoom * (basepoint * 2.0 - 1.0)
     + endpoint * vertex.y
@@ -44,8 +45,10 @@ fn main_vs(
   let short_line_boost = 1.0 + ((uniforms.line_width * width) / length(endpoint));
   let line_offset = uniforms.line_begin_offset / short_line_boost;
 
+  let transformed_point = view_matrix * vec4<f32>(point, 0.0, 1.0);
+
   return VertexOutput(
-    vec4<f32>(point, 0.0, 1.0),
+    transformed_point,
     vertex,
     color,
     line_offset,

flux/src/flux.rs

@@ -10,7 +10,8 @@ const MAX_FRAME_TIME: f32 = 1.0 / 10.0;
 
 pub struct Flux {
     settings: Arc<Settings>,
-    screen_size: wgpu::Extent3d,
+    logical_size: wgpu::Extent3d,
+    physical_size: wgpu::Extent3d,
 
     grid: grid::Grid,
     fluid: render::fluid::Context,
@@ -36,7 +37,7 @@ impl Flux {
             .update(device, queue, self.grid.scaling_ratio, &self.settings);
         self.noise_generator.update(&self.settings);
         self.lines
-            .update(device, queue, self.screen_size, &self.grid, &self.settings);
+            .update(device, queue, self.logical_size, &self.grid, &self.settings);
     }
 
     pub fn sample_colors_from_image(
@@ -73,12 +74,16 @@ impl Flux {
 
         rng::init_from_seed(&settings.seed);
 
-        // Logical size
-        let screen_size = wgpu::Extent3d {
+        let logical_size = wgpu::Extent3d {
             width: logical_width,
             height: logical_height,
             depth_or_array_layers: 1,
         };
+        let physical_size = wgpu::Extent3d {
+            width: physical_width,
+            height: physical_height,
+            depth_or_array_layers: 1,
+        };
 
         log::info!("📐 Logical size: {}x{}", logical_width, logical_height);
         log::info!("📏 Physical size: {}x{}", physical_width, physical_height);
@@ -91,7 +96,7 @@ impl Flux {
             device,
             queue,
             swapchain_format,
-            screen_size,
+            logical_size,
             &grid,
             settings,
         );
@@ -119,7 +124,8 @@ impl Flux {
 
         Ok(Flux {
             settings: Arc::clone(settings),
-            screen_size,
+            logical_size,
+            physical_size,
 
             fluid,
             grid,
@@ -147,17 +153,23 @@ impl Flux {
         let grid = grid::Grid::new(logical_width, logical_height, self.settings.grid_spacing);
 
         // TODO: fetch line state from GPU and resample for new grid
-        let screen_size = wgpu::Extent3d {
+        let logical_size = wgpu::Extent3d {
             width: logical_width,
             height: logical_height,
             depth_or_array_layers: 1,
         };
+        let physical_size = wgpu::Extent3d {
+            width: physical_width,
+            height: physical_height,
+            depth_or_array_layers: 1,
+        };
 
         self.lines
-            .resize(device, queue, screen_size, &grid, &self.settings);
+            .resize(device, queue, logical_size, &grid, &self.settings);
 
         self.grid = grid;
-        self.screen_size = screen_size;
+        self.logical_size = logical_size;
+        self.physical_size = physical_size;
 
         // self.fluid.resize(device, self.grid.scaling_ratio);
         self.noise_generator.resize(
@@ -173,10 +185,11 @@ impl Flux {
         queue: &wgpu::Queue,
         encoder: &mut wgpu::CommandEncoder,
         view: &wgpu::TextureView,
+        screen_viewport: Option<render::ScreenViewport>,
         timestamp: f64,
     ) {
         self.compute(device, queue, encoder, timestamp);
-        self.render(device, queue, encoder, view);
+        self.render(device, queue, encoder, view, screen_viewport);
     }
 
     pub fn compute(
@@ -252,6 +265,7 @@ impl Flux {
         queue: &wgpu::Queue,
         encoder: &mut wgpu::CommandEncoder,
         view: &wgpu::TextureView,
+        screen_viewport: Option<render::ScreenViewport>,
     ) {
         encoder.push_debug_group("render lines");
 
@@ -274,6 +288,12 @@ impl Flux {
             use settings::Mode::*;
             match &self.settings.mode {
                 Normal => {
+                    let view_transform = screen_viewport
+                        .map(|ref sv| {
+                            render::ViewTransform::from_screen_viewport(&self.physical_size, sv)
+                        })
+                        .unwrap_or_default();
+                    self.lines.set_view_transform(queue, view_transform);
                     self.lines.draw_lines(&mut rpass);
                     self.lines.draw_endpoints(&mut rpass);
                 }