chore: wgpu 0.14

AlecGoncharow · AlecGoncharow · commit 945728e1e5bd · 2023-01-22T16:10:55.000-06:00
Signed-off-by: Alec Goncharow &lt;alec@goncharow.dev&gt;
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -6,6 +6,7 @@ members = [
     "game-client",
     "atlas",
     "server",
+    "mostly-harmless",
 ]
 
 [profile.release]
diff --git a/atlas/Cargo.toml b/atlas/Cargo.toml
@@ -16,5 +16,5 @@ bitflags = "1.3"
 static_assertions = "1.1.0"
 
 [dependencies.wgpu]
-version = "0.12"
+version = "0.14"
 features = ["spirv"]
diff --git a/game-client/assets/shaders/shaded.vert b/game-client/assets/shaders/shaded.vert
@@ -39,13 +39,21 @@ layout(location=3) out vec4 v_camera_space;
 layout(location=4) out vec3 v_cascade_blend;
 layout(location=5) out vec4 v_cascade_coord_0;
 
+
+// out gl_PerVertex {
+  //vec4 gl_Position;
+  //float gl_PointSize;
+  //float gl_ClipDistance[1];
+//};
+
 const float min_bias = 0.005;
 
 void main() {
     vec4 world_pos = entity.model * vec4(a_position, 1.0);
     // this is used so reflection passes only draw above water and 
     // refraction passes only draw below the water
-    gl_ClipDistance[0] = dot(world_pos, clip.plane);
+    // gl_ClipDistance[0] = dot(world_pos, clip.plane);
+
 
     //
     // compute Lambertian diffuse term
diff --git a/game-client/src/main.rs b/game-client/src/main.rs
@@ -42,7 +42,7 @@ use hermes::tokio;
 
 use pantheon::wgpu;
 
-const PRESENT_MODE: wgpu::PresentMode = wgpu::PresentMode::Immediate;
+const PRESENT_MODE: wgpu::PresentMode = wgpu::PresentMode::AutoNoVsync;
 
 // tracing
 use std::fs::File;
diff --git a/pantheon/Cargo.toml b/pantheon/Cargo.toml
@@ -13,7 +13,7 @@ resolver = "2"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-winit = "0.26"
+winit = "0.27"
 futures = "0.3"
 bytemuck = "1.4"
 image = "0.23"
@@ -26,7 +26,7 @@ bitflags = "1.3"
 smallvec = "1.8"
 
 [dependencies.wgpu]
-version = "0.12"
+version = "0.14"
 features = ["spirv"]
 
 [dependencies.bumpalo]
diff --git a/pantheon/src/context.rs b/pantheon/src/context.rs
@@ -1,4 +1,5 @@
 use std::path::PathBuf;
+use std::error::Error;
 
 use crate::graphics;
 use crate::graphics::mode::PolygonMode;
@@ -53,8 +54,13 @@ impl<'a, 'winit> Context<'a> {
         }))
         .unwrap();
 
+
+        // @TODO lets write some checks here to validate the adapter supports the requested feature
+        // and limits, and if not, let's use those.
+
         println!("[adapter.backend] {:#?}", adapter.get_info().backend);
         println!("[adapter.features] {:#?}", adapter.features());
+        println!("[adapter.limits] {:#?}", adapter.limits());
 
         let mut features = wgpu::Features::empty();
         // @TODO need to wrap this so that non Vulkan/DX12 don't offer multiple pipelines
@@ -72,15 +78,16 @@ impl<'a, 'winit> Context<'a> {
                 features,
                 limits: wgpu::Limits {
                     /// AMD pls https://www.khronos.org/registry/vulkan/specs/1.1/html/vkspec.html#limits-minmax
-                    max_push_constant_size: 256,
+                    max_push_constant_size: 128,
                     ..wgpu::Limits::default()
                 },
             },
             None, // Trace path
         )) {
             Ok(stuff) => stuff,
             Err(e) => {
-                eprintln!("[request_device] {:#?}", e);
+                eprintln!("[request_device_error] requesting fallback device");
+                eprintln!("[request_device_error] WARNING: running with no additional features");
                 block_on(adapter.request_device(
                     &wgpu::DeviceDescriptor {
                         label: Some("Fallback Device"),
@@ -96,7 +103,8 @@ impl<'a, 'winit> Context<'a> {
 
         let surface_config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: surface.get_preferred_format(&adapter).unwrap(),
+            format: surface.get_supported_formats(&adapter)[0],
+            alpha_mode: surface.get_supported_alpha_modes(&adapter)[0],
             width: size.width,
             height: size.height,
             present_mode,
@@ -198,7 +206,8 @@ impl<'a, 'winit> Context<'a> {
         let size = self.window.inner_size();
         self.surface_config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: self.surface.get_preferred_format(&self.adapter).unwrap(),
+            format: self.surface.get_supported_formats(&self.adapter)[0],
+            alpha_mode: self.surface.get_supported_alpha_modes(&self.adapter)[0],
             width: size.width,
             height: size.height,
             present_mode: self.surface_config.present_mode,
diff --git a/pantheon/src/event.rs b/pantheon/src/event.rs
@@ -106,11 +106,11 @@ where
     #[cfg(target_os = "macos")]
     let mut wait = false;
 
+    println!("[pantheon] entering main event loop");
     events_loop.run(move |event, _, control_flow| {
         let _event_span = span!(Level::DEBUG, "event").entered();
         *control_flow = ControlFlow::Poll;
         ctx.process_event(&event);
-
         match event {
             Event::WindowEvent { event, .. } => match event {
                 WindowEvent::Resized(logical_size) => {
diff --git a/pantheon/src/graphics/pipeline.rs b/pantheon/src/graphics/pipeline.rs
@@ -36,7 +36,7 @@ impl<'a> PipelineContext<'a> {
         shader_ctx: &ShaderContext,
         layouts: &[&wgpu::BindGroupLayout],
         device: &wgpu::Device,
-        targets: Option<&Vec<wgpu::ColorTargetState>>,
+        targets: &[Option<wgpu::ColorTargetState>],
     ) -> [wgpu::RenderPipeline; 15] {
         let mut pipelines: [MaybeUninit<wgpu::RenderPipeline>; MAX_PIPELINES] =
             unsafe { MaybeUninit::uninit().assume_init() };
@@ -68,7 +68,7 @@ impl<'a> PipelineContext<'a> {
                         // 2.
                         module: &fs_module,
                         entry_point: "main",
-                        targets: &targets.expect("nice one"),
+                        targets,
                     })
                 } else {
                     None
diff --git a/pantheon/src/graphics/renderer.rs b/pantheon/src/graphics/renderer.rs
@@ -56,19 +56,20 @@ impl GraphicsContext {
             encoder.push_debug_group(pass.label);
 
             let attachment;
-            let color_attachments: &[wgpu::RenderPassColorAttachment] =
+
+            let color_attachments: &[Option<wgpu::RenderPassColorAttachment>] =
                 if let Some(ops) = pass.color_attachment_ops {
                     let attach_view = if let Some(handle) = &pass.color_attachment_view_handle {
                         // @TODO @FIXME this should be it's own view, no fetching should be needed
                         &wrangler.get_texture(handle).view
                     } else {
                         view
                     };
-                    attachment = [wgpu::RenderPassColorAttachment {
+                    attachment = [Some(wgpu::RenderPassColorAttachment {
                         view: attach_view,
                         resolve_target: None,
                         ops,
-                    }];
+                    })];
                     &attachment
                 } else {
                     &[]
diff --git a/pantheon/src/graphics/wrangler.rs b/pantheon/src/graphics/wrangler.rs
@@ -711,7 +711,7 @@ impl<'a> RenderWrangler<'a> {
         let handle = self.handle_to_bind_group_layout(PASS_PADDING).unwrap();
         let padding_bgl = &bind_group_layouts[handle.idx].entry;
         let textures = &self.textures;
-        let mut targets = None;
+        let mut targets = vec![];
 
         self.passes.iter_mut().for_each(|pass| {
             let mut layouts = Vec::with_capacity(3);
@@ -745,11 +745,10 @@ impl<'a> RenderWrangler<'a> {
                 layouts.push(&draw_layout.entry);
             }
 
-            if let Some(fragment_targets) = &pipeline_ctx.fragment_targets {
-                targets = Some(
+            targets = if let Some(fragment_targets) = &pipeline_ctx.fragment_targets {
                     fragment_targets
                         .iter()
-                        .map(|target| wgpu::ColorTargetState {
+                        .map(|target| Some(wgpu::ColorTargetState {
                             format: if let Some(handle) = target.format_handle {
                                 let texture = &textures[handle.idx];
                                 #[cfg(debug_assertions)]
@@ -760,10 +759,11 @@ impl<'a> RenderWrangler<'a> {
                             },
                             blend: target.blend,
                             write_mask: target.write_mask,
-                        })
-                        .collect(),
-                );
-            }
+                        }))
+                        .collect()
+            } else {
+                vec![]
+            };
 
             pass.pipelines =
                 pipeline_ctx.create_pipelines(shader_context, &layouts, device, targets.as_ref());
@@ -783,7 +783,6 @@ impl<'a> RenderWrangler<'a> {
         let handle = self.handle_to_bind_group_layout(PASS_PADDING).unwrap();
         let padding_bgl = &bind_group_layouts[handle.idx].entry;
         let textures = &self.textures;
-        let mut targets = None;
 
         let mut layouts = Vec::with_capacity(3);
 
@@ -815,25 +814,28 @@ impl<'a> RenderWrangler<'a> {
             layouts.push(&draw_layout.entry);
         }
 
-        if let Some(fragment_targets) = &pipeline_ctx.fragment_targets {
-            targets = Some(
-                fragment_targets
-                    .iter()
-                    .map(|target| wgpu::ColorTargetState {
-                        format: if let Some(handle) = target.format_handle {
-                            let texture = &textures[handle.idx];
-                            #[cfg(debug_assertions)]
-                            assert_eq!(handle.label, texture.label);
-                            texture.entry.format.clone()
-                        } else {
-                            surface_config.format
-                        },
-                        blend: target.blend,
-                        write_mask: target.write_mask,
-                    })
-                    .collect(),
-            );
-        }
+            
+        let targets = if let Some(fragment_targets) = &pipeline_ctx.fragment_targets {
+                    fragment_targets
+                        .iter()
+                        .map(|target| Some(wgpu::ColorTargetState {
+                            format: if let Some(handle) = target.format_handle {
+                                let texture = &textures[handle.idx];
+                                #[cfg(debug_assertions)]
+                                assert_eq!(handle.label, texture.label);
+                                texture.entry.format.clone()
+                            } else {
+                                surface_config.format
+                            },
+                            blend: target.blend,
+                            write_mask: target.write_mask,
+                        }))
+                        .collect()
+            } else {
+                vec![]
+            };
+
+
 
         pipeline_ctx.create_pipelines(shader_context, &layouts, device, targets.as_ref())
     }
diff --git a/pantheon/src/math/mod.rs b/pantheon/src/math/mod.rs
@@ -94,11 +94,13 @@ pub trait Vector:
 macro_rules! simd_vector {
     ($vec:ty, $simd:ty) => {
         use std::simd::Simd;
+        use std::simd::SimdFloat;
+
         impl Vector for $vec {
             #[inline]
             fn dot(&self, other: &Self) -> f32 {
                 let (s, o): ($simd, $simd) = unsafe { std::mem::transmute((*self, *other)) };
-                (s * o).horizontal_sum()
+                (s * o).reduce_sum()
             }
             #[inline]
             fn make_comp_mul(&self, other: &Self) -> Self {
@@ -138,7 +140,7 @@ macro_rules! simd_vector {
                 unsafe {
                     let s: $simd = std::mem::transmute(*self);
 
-                    std::mem::transmute(s.clamp(Simd::splat(min), Simd::splat(max)))
+                    std::mem::transmute(s.simd_clamp(Simd::splat(min), Simd::splat(max)))
                 }
             }
         }
diff --git a/pantheon/src/shader.rs b/pantheon/src/shader.rs
@@ -56,7 +56,7 @@ impl ShaderContext {
     pub fn make_module(&self, device: &wgpu::Device, path: &str) -> wgpu::ShaderModule {
         let fq_path = self.shader_spirv_path.join(path);
         let spirv_source = std::fs::read(fq_path).unwrap();
-        device.create_shader_module(&wgpu::ShaderModuleDescriptor {
+        device.create_shader_module(wgpu::ShaderModuleDescriptor {
             label: Some(&path),
             source: wgpu::util::make_spirv(&spirv_source),
         })

Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ members = [`
`6`	`6`	`"game-client",`
`7`	`7`	`"atlas",`
`8`	`8`	`"server",`
	`9`	`+ "mostly-harmless",`
`9`	`10`	`]`
`10`	`11`
`11`	`12`	`[profile.release]`