Upgrade numeric, geometric, and rendering dependencies.

This change upgrades `decorum`, `theon`, `num`, `wgpu`, and some other
dependencies that are primarily used for geometry and rendering. Some of
these dependencies are coupled. For example, this change also upgrades
dependencies on linear algebra crates to support a later version of
`theon`.

Author: olson-sean-k

examples/sphere/Cargo.toml

@@ -7,6 +7,8 @@ license = "MIT"
 publish = false
 
 [dependencies]
+nalgebra = "^0.33.0"
+theon = "^0.1.0"
 
 [dependencies.pictor]
 path = "../../pictor"

examples/sphere/src/main.rs

@@ -1,6 +1,3 @@
-use plexus::integration::nalgebra;
-use plexus::integration::theon;
-
 use nalgebra::Point3;
 use pictor::pipeline::{self, Vertex};
 use plexus::prelude::*;

examples/subdivide/Cargo.toml

@@ -7,7 +7,9 @@ license = "MIT"
 publish = false
 
 [dependencies]
+nalgebra = "^0.33.0"
 smallvec = "^1.0.0"
+theon = "^0.1.0"
 
 [dependencies.pictor]
 path = "../../pictor"

examples/subdivide/src/main.rs

@@ -1,8 +1,5 @@
 #![allow(clippy::iter_nth_zero)]
 
-use plexus::integration::nalgebra;
-use plexus::integration::theon;
-
 use nalgebra::Point3;
 use pictor::pipeline::{self, Vertex};
 use plexus::geometry::AsPositionMut;

examples/teapot/Cargo.toml

@@ -7,6 +7,8 @@ license = "MIT"
 publish = false
 
 [dependencies]
+nalgebra = "^0.33.0"
+theon = "^0.1.0"
 
 [dependencies.pictor]
 path = "../../pictor"

examples/teapot/src/main.rs

@@ -1,6 +1,3 @@
-use plexus::integration::nalgebra;
-use plexus::integration::theon;
-
 use nalgebra::Point3;
 use pictor::pipeline::{self, Vertex};
 use plexus::encoding::ply::{FromPly, PositionEncoding};

pictor/Cargo.toml

@@ -2,22 +2,24 @@
 name = "pictor"
 version = "0.0.0"
 edition = "2021"
-rust-version = "1.65.0"
+rust-version = "1.80.0"
 authors = ["Sean Olson <olson.sean.k@gmail.com>"]
 license = "MIT"
 description = "Renderer and support library for Plexus examples."
 publish = false
 
 [dependencies]
-bytemuck = "^1.4.0"
-decorum = "^0.3.1"
-lazy_static = "^1.4.0"
-num = "^0.3.0"
-rand = "^0.7.0"
-winit = "^0.24.0"
+bytemuck = "^1.13.0" # optional for winit, `1.21.0` latest.
+decorum = "^0.4.0"
+naga = "^23.0.0"
+nalgebra = "^0.33.0"
+num = "^0.4.3"
+rand = "^0.8.5"
+theon = "^0.1.0"
+winit = "^0.30.8"
 
 [dependencies.futures]
-version = "=0.3"
+version = "^0.3.31"
 default-features = false
 features = [
     "std",
@@ -29,8 +31,6 @@ path = "../plexus"
 default-features = false
 features = ["geometry-nalgebra"]
 
-# TODO: Migrate to a published release of `wgpu`.
 [dependencies.wgpu]
-#version = "^0.6.0"
-git = "https://github.com/gfx-rs/wgpu-rs.git"
-rev = "e798278"
+version = "^23.0.1"
+features = ["glsl"]

pictor/src/camera.rs

@@ -1,18 +1,16 @@
-use plexus::integration::nalgebra;
-
-use lazy_static::lazy_static;
 use nalgebra::{Isometry3, Matrix4, Orthographic3, Perspective3, Point3, Vector3};
-use wgpu::SwapChainDescriptor;
+use std::sync::LazyLock;
+use wgpu::SurfaceConfiguration;
 
-lazy_static! {
-    #[rustfmt::skip]
-    static ref OPENGL_TO_WGPU_TRANSFORM: Matrix4<f32> = Matrix4::new(
+#[rustfmt::skip]
+static OPENGL_TO_WGPU_TRANSFORM: LazyLock<Matrix4<f32>> = LazyLock::new(|| {
+    Matrix4::new(
         1.0, 0.0, 0.0, 0.0,
         0.0, 1.0, 0.0, 0.0,
         0.0, 0.0, 0.5, 0.0,
         0.0, 0.0, 0.5, 1.0,
-    );
-}
+    )
+});
 
 pub enum Projection {
     Perspective(Perspective3<f32>),
@@ -48,13 +46,13 @@ impl Camera {
         self.view = Isometry3::look_at_rh(from, to, &Vector3::y());
     }
 
-    pub fn reproject(&mut self, descriptor: &SwapChainDescriptor) {
+    pub fn reproject(&mut self, surface: &SurfaceConfiguration) {
         match self.projection {
             Projection::Perspective(ref mut perspective) => {
-                perspective.set_aspect(descriptor.width as f32 / descriptor.height as f32);
+                perspective.set_aspect(surface.width as f32 / surface.height as f32);
             }
             Projection::Orthographic(ref mut orthographic) => {
-                let inverse = descriptor.height as f32 / descriptor.width as f32;
+                let inverse = surface.height as f32 / surface.width as f32;
                 let radius = (orthographic.right() - orthographic.left()) * inverse * 0.5;
                 orthographic.set_bottom_and_top(-radius, radius);
             }

pictor/src/harness.rs

@@ -2,16 +2,13 @@ use futures::executor::{self, LocalPool, LocalSpawner};
 use futures::task::LocalSpawn;
 use std::cmp;
 use std::fmt::Debug;
-use wgpu::{Device, Queue, SwapChainDescriptor, SwapChainTexture};
-use winit::event::{Event, WindowEvent};
-use winit::event_loop::{ControlFlow, EventLoop};
-use winit::window::Window;
+use winit::application::ApplicationHandler;
+use winit::event::WindowEvent;
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::window::{Window, WindowId};
 
 use crate::renderer::Renderer;
 
-use ControlFlow::Exit;
-use ControlFlow::Poll;
-
 struct Executor {
     pool: LocalPool,
     spawner: LocalSpawner,
@@ -41,17 +38,17 @@ pub enum Reaction {
 }
 
 pub trait ConfigureStage {
-    fn device(&self) -> &Device;
+    fn device(&self) -> &wgpu::Device;
 
-    fn queue(&self) -> &Queue;
+    fn queue(&self) -> &wgpu::Queue;
 
-    fn swap_chain_descriptor(&self) -> &SwapChainDescriptor;
+    fn surface_configuration(&self) -> &wgpu::SurfaceConfiguration;
 }
 
 pub trait RenderStage {
-    fn device(&self) -> &Device;
+    fn device(&self) -> &wgpu::Device;
 
-    fn queue(&self) -> &Queue;
+    fn queue(&self) -> &wgpu::Queue;
 }
 
 pub trait Application: 'static + Sized {
@@ -73,7 +70,7 @@ pub trait Application: 'static + Sized {
     fn render(
         &mut self,
         stage: &impl RenderStage,
-        frame: &SwapChainTexture,
+        view: &wgpu::TextureView,
         spawn: &impl LocalSpawn,
     );
 }
@@ -83,48 +80,65 @@ where
     T: Application,
     F: FnOnce(&EventLoop<()>) -> Window,
 {
-    let mut executor = Executor::new();
-    let reactor = EventLoop::new();
-    let mut renderer = executor::block_on(Renderer::try_from_window(f(&reactor))).unwrap();
-    let mut application = T::configure(configuration, &renderer).unwrap();
-    reactor.run(move |event, _, reaction| {
-        *reaction = Poll;
-        match event {
-            Event::MainEventsCleared => {
-                executor.flush();
-            }
-            Event::RedrawRequested(_) => {
-                let swap_chain = &mut renderer.swap_chain;
-                let frame = match swap_chain.get_current_frame() {
-                    Ok(frame) => frame,
-                    Err(_) => {
-                        *swap_chain = renderer
-                            .device
-                            .create_swap_chain(&renderer.surface, &renderer.swap_chain_descriptor);
-                        swap_chain.get_current_frame().unwrap()
-                    }
-                };
-                application.render(&renderer, &frame.output, executor.spawner());
-            }
-            Event::WindowEvent { event, .. } => match event {
+    struct Run<'window, T> {
+        executor: Executor,
+        application: T,
+        window: &'window Window,
+        renderer: Renderer<'window>,
+    }
+
+    impl<'window, T> ApplicationHandler<()> for Run<'window, T>
+    where
+        T: Application,
+    {
+        fn resumed(&mut self, _reactor: &ActiveEventLoop) {}
+
+        fn window_event(&mut self, reactor: &ActiveEventLoop, _: WindowId, event: WindowEvent) {
+            match event {
+                WindowEvent::RedrawRequested => {
+                    let frame = self.renderer.surface.get_current_texture().unwrap();
+                    let view = frame
+                        .texture
+                        .create_view(&wgpu::TextureViewDescriptor::default());
+                    self.application
+                        .render(&self.renderer, &view, self.executor.spawner());
+                    frame.present();
+                }
                 WindowEvent::CloseRequested => {
-                    *reaction = Exit;
+                    reactor.exit();
                 }
                 WindowEvent::Resized(dimensions) => {
-                    renderer.swap_chain_descriptor.width = cmp::max(1, dimensions.width);
-                    renderer.swap_chain_descriptor.height = cmp::max(1, dimensions.height);
-                    application.resize(&renderer);
-                    renderer.swap_chain = renderer
-                        .device
-                        .create_swap_chain(&renderer.surface, &renderer.swap_chain_descriptor);
+                    self.renderer.surface_configuration.width = cmp::max(1, dimensions.width);
+                    self.renderer.surface_configuration.height = cmp::max(1, dimensions.height);
+                    self.application.resize(&self.renderer);
+                    self.renderer
+                        .surface
+                        .configure(&self.renderer.device, &self.renderer.surface_configuration);
+                    self.window.request_redraw();
                 }
                 _ => {
-                    if let Reaction::Abort = application.react(event) {
-                        *reaction = Exit;
+                    if let Reaction::Abort = self.application.react(event) {
+                        reactor.exit();
                     }
                 }
-            },
-            _ => {}
+            }
+            // TODO: This should probably be done in reaction to much more specific events.
+            self.executor.flush();
         }
-    });
+    }
+
+    let executor = Executor::new();
+    let reactor = EventLoop::new().unwrap();
+    reactor.set_control_flow(ControlFlow::Poll);
+    let window = f(&reactor);
+    let renderer = executor::block_on(Renderer::try_from_window(&window)).unwrap();
+    let application = T::configure(configuration, &renderer).unwrap();
+    reactor
+        .run_app(&mut Run {
+            executor,
+            application,
+            window: &window,
+            renderer,
+        })
+        .unwrap();
 }

pictor/src/lib.rs

@@ -5,3 +5,5 @@ mod renderer;
 
 pub use crate::camera::*;
 pub use crate::harness::*;
+
+// TODO: Compile shaders from source code rather than statically loading binary SpirV.