Port to wgpu-0.17

kvark · kvark · commit 2edeb85709c7 · 2023-07-25T21:22:54.000-07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -55,26 +55,27 @@ log = "0.4"
 progress = "0.2"
 rand = "0.8"
 rayon = "1"
-ron = "0.6"
-rust-ini = "0.17"
+ron = "0.8"
+rust-ini = "0.19"
 serde = "1.0"
 serde_derive = "1.0"
 serde_scan = "0.4"
 # keep in sync with `lib/ffi/Cargo.toml`
-wgpu = { version = "0.13", features = [] }
+wgpu = { version = "0.17", features = [] }
 # binaries
-env_logger = "0.9"
+env_logger = "0.10"
 getopts = "0.2"
 obj = "0.10"
-png = "0.16"
-winit = "0.27"
+png = "0.17"
+winit = "0.28"
 # gui
-egui = "0.19"
-egui_winit_platform = "0.16"
-egui_wgpu_backend = "0.19"
+egui = "0.22"
+egui_winit_platform = "0.19"
+#egui_wgpu_backend = "0.24"
+egui_wgpu_backend = { git = "https://github.com/kvark/egui_wgpu_backend", branch = "wgpu-0.17" }
 
 [dev-dependencies]
-naga = { version = "0.9", features = ["wgsl-in", "validate"] }
+naga = { version = "0.13", features = ["wgsl-in", "validate"] }
 
 [dependencies.profiling]
 version = "1.0.1"
diff --git a/bin/boilerplate.rs b/bin/boilerplate.rs
@@ -59,15 +59,19 @@ impl Harness {
         };
 
         info!("Initializing the window");
-        let instance = wgpu::Instance::new(settings.backend.to_wgpu());
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+            backends: settings.backend.to_wgpu(),
+            ..Default::default()
+        });
         let event_loop = EventLoop::new();
         let window = WindowBuilder::new()
             .with_title(options.title)
             .with_inner_size(winit::dpi::PhysicalSize::new(extent.width, extent.height))
             .with_resizable(true)
             .build(&event_loop)
             .unwrap();
-        let surface = unsafe { instance.create_surface(&window) };
+        let surface =
+            unsafe { instance.create_surface(&window) }.expect("Unable to create surface.");
 
         info!("Initializing the device");
         let adapter = task_pool
@@ -124,9 +128,11 @@ impl Harness {
             ))
             .unwrap();
 
-        let surface_formats = surface.get_supported_formats(&adapter);
-        let surface_modes = surface.get_supported_modes(&adapter);
-        let present_mode = if surface_modes.contains(&wgpu::PresentMode::Mailbox) {
+        let surface_caps = surface.get_capabilities(&adapter);
+        let present_mode = if surface_caps
+            .present_modes
+            .contains(&wgpu::PresentMode::Mailbox)
+        {
             wgpu::PresentMode::Mailbox
         } else {
             log::warn!("Mailbox present is not supported");
@@ -138,10 +144,12 @@ impl Harness {
         };
         let config = wgpu::SurfaceConfiguration {
             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
-            format: surface_formats[0],
+            format: surface_caps.formats[0],
             width: extent.width,
             height: extent.height,
             present_mode,
+            alpha_mode: wgpu::CompositeAlphaMode::Auto,
+            view_formats: Vec::new(),
         };
         surface.configure(&device, &config);
 
@@ -163,6 +171,7 @@ impl Harness {
                 dimension: wgpu::TextureDimension::D2,
                 format: DEPTH_FORMAT,
                 usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                view_formats: &[],
             })
             .create_view(&wgpu::TextureViewDescriptor::default());
 
@@ -230,6 +239,8 @@ impl Harness {
                         width: size.width,
                         height: size.height,
                         present_mode: win.present_mode,
+                        alpha_mode: wgpu::CompositeAlphaMode::Auto,
+                        view_formats: Vec::new(),
                     };
                     win.surface.configure(&gfx.device, &config);
                     win.depth_target = gfx
@@ -242,6 +253,7 @@ impl Harness {
                             dimension: wgpu::TextureDimension::D2,
                             format: DEPTH_FORMAT,
                             usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+                            view_formats: &[],
                         })
                         .create_view(&wgpu::TextureViewDescriptor::default());
                     app.resize(&gfx.device, gfx.screen_size);
diff --git a/bin/convert/level_png.rs b/bin/convert/level_png.rs
@@ -32,7 +32,7 @@ pub fn save(path: &Path, layers: LevelLayers, palette: &[u8]) {
         println!("\t\t{}...", mp.height);
         let file = File::create(path.with_file_name(mp.height)).unwrap();
         let mut encoder = png::Encoder::new(file, layers.size.0 as u32, layers.size.1 as u32);
-        encoder.set_color(png::ColorType::RGB);
+        encoder.set_color(png::ColorType::Rgb);
         data.clear();
         for ((&h0, &h1), &delta) in layers.het0.iter().zip(&layers.het1).zip(&layers.delta) {
             data.extend_from_slice(&[h0, h1, delta]);
@@ -79,16 +79,17 @@ pub fn load(path: &Path) -> LevelLayers {
         println!("\t\t{}...", mp.height);
         let file = File::open(path.with_file_name(mp.height)).unwrap();
         let decoder = png::Decoder::new(file);
-        let (info, mut reader) = decoder.read_info().unwrap();
+        let mut reader = decoder.read_info().unwrap();
+        let info = reader.info();
         assert_eq!((info.width, info.height), mp.size);
         let stride = match info.color_type {
-            png::ColorType::RGB => 3,
-            png::ColorType::RGBA => 4,
+            png::ColorType::Rgb => 3,
+            png::ColorType::Rgba => 4,
             _ => panic!("non-RGB image provided"),
         };
         let mut data = vec![0u8; stride * (layers.size.0 as usize) * (layers.size.1 as usize)];
         assert_eq!(info.bit_depth, png::BitDepth::Eight);
-        assert_eq!(info.buffer_size(), data.len());
+        assert_eq!(reader.output_buffer_size(), data.len());
         reader.next_frame(&mut data).unwrap();
         for chunk in data.chunks(stride) {
             layers.het0.push(chunk[0]);
@@ -101,27 +102,29 @@ pub fn load(path: &Path) -> LevelLayers {
         let file = File::open(path.with_file_name(mp.material_lo)).unwrap();
         let mut decoder = png::Decoder::new(file);
         decoder.set_transformations(png::Transformations::empty());
-        let (info, mut reader) = decoder.read_info().unwrap();
+        let mut reader = decoder.read_info().unwrap();
+        let info = reader.info();
         assert_eq!((info.width, info.height), mp.size);
         assert_eq!(info.bit_depth, png::BitDepth::Four);
         layers
             .mat0
             .resize(info.width as usize * info.height as usize / 2, 0);
-        assert_eq!(info.buffer_size(), layers.mat0.len());
+        assert_eq!(reader.output_buffer_size(), layers.mat0.len());
         reader.next_frame(&mut layers.mat0).unwrap();
     }
     {
         println!("\t\t{}...", mp.material_hi);
         let file = File::open(path.with_file_name(mp.material_hi)).unwrap();
         let mut decoder = png::Decoder::new(file);
         decoder.set_transformations(png::Transformations::empty());
-        let (info, mut reader) = decoder.read_info().unwrap();
+        let mut reader = decoder.read_info().unwrap();
+        let info = reader.info();
         assert_eq!((info.width, info.height), mp.size);
         assert_eq!(info.bit_depth, png::BitDepth::Four);
         layers
             .mat1
             .resize(info.width as usize * info.height as usize / 2, 0);
-        assert_eq!(info.buffer_size(), layers.mat1.len());
+        assert_eq!(reader.output_buffer_size(), layers.mat1.len());
         reader.next_frame(&mut layers.mat1).unwrap();
     }
 
diff --git a/bin/convert/main.rs b/bin/convert/main.rs
@@ -186,7 +186,7 @@ fn main() {
             let data = fs_read(&src_path).unwrap();
             let file = File::create(&dst_path).unwrap();
             let mut encoder = png::Encoder::new(file, 0x100, 1);
-            encoder.set_color(png::ColorType::RGB);
+            encoder.set_color(png::ColorType::Rgb);
             encoder
                 .write_header()
                 .unwrap()
@@ -197,16 +197,17 @@ fn main() {
             println!("Converting PNG to palette...");
             let file = File::open(&src_path).unwrap();
             let decoder = png::Decoder::new(file);
-            let (info, mut reader) = decoder.read_info().unwrap();
+            let mut reader = decoder.read_info().unwrap();
+            let info = reader.info();
             assert_eq!((info.width, info.height), (0x100, 1));
             let stride = match info.color_type {
-                png::ColorType::RGB => 3,
-                png::ColorType::RGBA => 4,
+                png::ColorType::Rgb => 3,
+                png::ColorType::Rgba => 4,
                 _ => panic!("non-RGB image provided"),
             };
             let mut data = vec![0u8; stride * 0x100];
             assert_eq!(info.bit_depth, png::BitDepth::Eight);
-            assert_eq!(info.buffer_size(), data.len());
+            assert_eq!(reader.output_buffer_size(), data.len());
             reader.next_frame(&mut data).unwrap();
             let mut output = File::create(&dst_path).unwrap();
             for chunk in data.chunks(stride) {
diff --git a/lib/ffi/Cargo.toml b/lib/ffi/Cargo.toml
@@ -16,12 +16,12 @@ log = "0.4"
 env_logger = { version = "0.9", optional = true }
 futures = "0.3"
 cgmath = "0.18"
-ron = "0.6"
+ron = "0.8"
 slotmap = "1"
-wgpu = { version = "0.13", features = ["angle"] }
-hal = { package = "wgpu-hal", version = "0.13", features = ["gles"] }
+wgpu = { version = "0.17", features = ["angle"] }
+hal = { package = "wgpu-hal", version = "0.17", features = ["gles"] }
 
 [target.'cfg(target_os = "android")'.dependencies]
-android_logger = { version = "0.11", optional = true }
+android_logger = { version = "0.13", optional = true }
 log = "0.4"
 log-panics = { version = "2" }
diff --git a/lib/ffi/src/lib.rs b/lib/ffi/src/lib.rs
@@ -176,6 +176,7 @@ fn crate_main_views(
         dimension: wgpu::TextureDimension::D2,
         format: wgpu::TextureFormat::R8Uint, //dummy
         usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+        view_formats: &[],
     };
     let color_view = {
         let hal_texture_color =
@@ -224,7 +225,10 @@ pub extern "C" fn rv_init(desc: InitDescriptor) -> Option<ptr::NonNull<Context>>
     }
     .expect("GL adapter can't be initialized");
 
-    let instance = wgpu::Instance::new(wgpu::Backends::empty());
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+        backends: wgpu::Backends::empty(),
+        ..Default::default()
+    });
     let adapter = unsafe { instance.create_adapter_from_hal(exposed) };
     let adapter_limits = adapter.limits();
 
diff --git a/lib/m3d/Cargo.toml b/lib/m3d/Cargo.toml
@@ -9,6 +9,6 @@ publish = false
 [dependencies]
 byteorder = "1.0"
 log = "0.4"
-ron = "0.6"
+ron = "0.8"
 profiling = "1.0"
 serde = { version = "1.0", features = ["serde_derive"] }
diff --git a/res/shader/object.wgsl b/res/shader/object.wgsl
@@ -1,6 +1,6 @@
 //!include body.inc globals.inc quat.inc shadow.inc
 
-let c_BodyColorId: u32 = 1u;
+const c_BodyColorId: u32 = 1u;
 
 struct Storage {
     bodies: array<Body>,
diff --git a/res/shader/shadow.inc.wgsl b/res/shader/shadow.inc.wgsl
@@ -3,7 +3,7 @@
 @group(0) @binding(3) var t_Shadow: texture_depth_2d;
 @group(0) @binding(4) var s_Shadow: sampler_comparison;
 
-let c_Ambient: f32 = 0.25;
+const c_Ambient: f32 = 0.25;
 
 fn fetch_shadow(pos: vec3<f32>) -> f32 {
     let flip_correction = vec2<f32>(1.0, -1.0);
diff --git a/res/shader/surface.inc.wgsl b/res/shader/surface.inc.wgsl
@@ -12,10 +12,10 @@ struct TerrainData {
 @group(1) @binding(0) var<uniform> u_Surface: SurfaceConstants;
 @group(1) @binding(2) var<storage, read> b_Terrain: TerrainData;
 
-let c_DoubleLevelMask: u32 = 64u;
-let c_ShadowMask: u32 = 128u;
-let c_DeltaShift: u32 = 0u;
-let c_DeltaBits: u32 = 2u;
+const c_DoubleLevelMask: u32 = 64u;
+const c_ShadowMask: u32 = 128u;
+const c_DeltaShift: u32 = 0u;
+const c_DeltaBits: u32 = 2u;
 
 struct Surface {
     low_alt: f32,
diff --git a/res/shader/terrain/color.inc.wgsl b/res/shader/terrain/color.inc.wgsl
@@ -7,9 +7,9 @@
 
 @group(0) @binding(1) var s_Palette: sampler;
 
-let c_HorFactor: f32 = 0.5; //H_CORRECTION
-let c_DiffuseScale: f32 = 8.0;
-let c_ShadowDepthScale: f32 = 0.6; //~ 2.0 / 3.0;
+const c_HorFactor: f32 = 0.5; //H_CORRECTION
+const c_DiffuseScale: f32 = 8.0;
+const c_ShadowDepthScale: f32 = 0.6; //~ 2.0 / 3.0;
 
 // see `RenderPrepare` in `land.cpp` for the original game logic
 
diff --git a/res/shader/terrain/locals.inc.wgsl b/res/shader/terrain/locals.inc.wgsl
@@ -1,4 +1,4 @@
-let c_DepthBias: f32 = 0.01;
+const c_DepthBias: f32 = 0.01;
 
 struct Locals {
     screen_rect: vec4<u32>,      // XY = offset, ZW = size
diff --git a/res/shader/terrain/voxel-draw.wgsl b/res/shader/terrain/voxel-draw.wgsl
@@ -26,8 +26,8 @@ fn check_occupancy(coordinates: vec3<i32>, lod: u32) -> bool {
     return (b_VoxelGrid.occupancy[addr.offset] & addr.mask) != 0u;
 }
 
-let enable_unzoom = true;
-let step_scale = 1.0;
+const enable_unzoom = true;
+const step_scale = 1.0;
 
 var<private> debug_color: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);
 
@@ -41,7 +41,7 @@ fn main(@builtin(vertex_index) index: u32) -> @builtin(position) vec4<f32> {
     );
 }
 
-let TYPE_MISS: u32 = 0xFFu;
+const TYPE_MISS: u32 = 0xFFu;
 
 struct CastPoint {
     pos: vec3<f32>,
diff --git a/res/shader/water.wgsl b/res/shader/water.wgsl
@@ -4,8 +4,8 @@
 @group(1) @binding(4) var t_Flood: texture_1d<f32>;
 @group(1) @binding(8) var s_Flood: sampler;
 
-let c_TerrainWater = 0u;
-let c_WaterColor = vec3<f32>(0.0, 0.1, 0.4);
+const c_TerrainWater = 0u;
+const c_WaterColor = vec3<f32>(0.0, 0.1, 0.4);
 
 struct Varyings {
     @builtin(position) clip_pos: vec4<f32>,
diff --git a/src/render/global.rs b/src/render/global.rs
@@ -127,6 +127,7 @@ impl Context {
                 sample_count: 1,
                 dimension: wgpu::TextureDimension::D2,
                 format: wgpu::TextureFormat::Depth32Float,
+                view_formats: &[],
                 usage: wgpu::TextureUsages::TEXTURE_BINDING
                     | wgpu::TextureUsages::RENDER_ATTACHMENT,
             });
diff --git a/src/render/mod.rs b/src/render/mod.rs
@@ -168,6 +168,7 @@ impl Palette {
             sample_count: 1,
             dimension: wgpu::TextureDimension::D1,
             format: wgpu::TextureFormat::Rgba8Unorm,
+            view_formats: &[],
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
         });
 
diff --git a/src/render/object.rs b/src/render/object.rs
@@ -8,7 +8,7 @@ use crate::{
 use bytemuck::{Pod, Zeroable};
 use m3d::NUM_COLOR_IDS;
 
-use std::{mem, num::NonZeroU32, slice};
+use std::{mem, slice};
 
 const COLOR_TABLE: [[u8; 2]; NUM_COLOR_IDS as usize] = [
     [0, 0],   // reserved
@@ -216,6 +216,7 @@ impl Context {
             sample_count: 1,
             dimension: wgpu::TextureDimension::D1,
             format: wgpu::TextureFormat::Rg8Uint,
+            view_formats: &[],
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,
         });
 
@@ -224,7 +225,7 @@ impl Context {
             unsafe { slice::from_raw_parts(COLOR_TABLE[0].as_ptr(), NUM_COLOR_IDS as usize * 2) },
             wgpu::ImageDataLayout {
                 offset: 0,
-                bytes_per_row: NonZeroU32::new(NUM_COLOR_IDS * 2),
+                bytes_per_row: Some(NUM_COLOR_IDS * 2),
                 rows_per_image: None,
             },
             extent,
diff --git a/src/render/shadow.rs b/src/render/shadow.rs
@@ -27,6 +27,7 @@ impl Shadow {
             sample_count: 1,
             dimension: wgpu::TextureDimension::D2,
             format: FORMAT,
+            view_formats: &[],
             usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::RENDER_ATTACHMENT,
         });
 
diff --git a/src/render/terrain.rs b/src/render/terrain.rs
diff --git a/tests/shaders.rs b/tests/shaders.rs
