Merge #77

77: Storage indexing, framebuffer tracking, and a bunch of validation fixes r=grovesNL a=kvark

Closes #73
Closes #75
Closes #79

Co-authored-by: Dzmitry Malyshau <kvarkus@gmail.com>
Co-authored-by: Dzmitry Malyshau <dmalyshau@mozilla.com>

Author: bors[bot]

Makefile

@@ -48,7 +48,7 @@ clear:
 	rm wgpu-bindings/wgpu.h
 
 lib-native: Cargo.lock wgpu-native/Cargo.toml $(wildcard wgpu-native/**/*.rs)
-	cargo build --manifest-path wgpu-native/Cargo.toml --features $(FEATURE_NATIVE)
+	cargo build --manifest-path wgpu-native/Cargo.toml --features "local,$(FEATURE_NATIVE)"
 
 lib-rust: Cargo.lock wgpu-rs/Cargo.toml $(wildcard wgpu-rs/**/*.rs)
 	cargo build --manifest-path wgpu-rs/Cargo.toml --features $(FEATURE_RUST)

examples/hello_triangle_rust/main.rs

@@ -40,7 +40,7 @@ fn main() {
             cull_mode: wgpu::CullMode::None,
             depth_bias: 0,
             depth_bias_slope_scale: 0.0,
-            depth_bias_clamp: wgpu::MAX_DEPTH_BIAS_CLAMP,
+            depth_bias_clamp: 0.0,
         },
         primitive_topology: wgpu::PrimitiveTopology::TriangleList,
         color_states: &[

gfx-examples/src/cube.rs

@@ -280,7 +280,7 @@ impl framework::Example for Example {
                 cull_mode: wgpu::CullMode::Back,
                 depth_bias: 0,
                 depth_bias_slope_scale: 0.0,
-                depth_bias_clamp: wgpu::MAX_DEPTH_BIAS_CLAMP,
+                depth_bias_clamp: 0.0,
             },
             primitive_topology: wgpu::PrimitiveTopology::TriangleList,
             color_states: &[

gfx-examples/src/shadow.rs

@@ -219,7 +219,7 @@ impl framework::Example for Example {
         });
 
         let local_bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
-            bindings: &[                     
+            bindings: &[
                 wgpu::BindGroupLayoutBinding {
                     binding: 0,
                     visibility: wgpu::ShaderStageFlags::VERTEX | wgpu::ShaderStageFlags::FRAGMENT,
@@ -380,7 +380,7 @@ impl framework::Example for Example {
         let light_uniform_size = (Self::MAX_LIGHTS * mem::size_of::<LightRaw>()) as u32;
         let light_uniform_buf = device.create_buffer(&wgpu::BufferDescriptor {
             size: light_uniform_size,
-            usage: wgpu::BufferUsageFlags::UNIFORM | wgpu::BufferUsageFlags::TRANSFER_DST,
+            usage: wgpu::BufferUsageFlags::UNIFORM | wgpu::BufferUsageFlags::TRANSFER_SRC | wgpu::BufferUsageFlags::TRANSFER_DST,
         });
 
         let vb_desc = wgpu::VertexBufferDescriptor {
@@ -459,7 +459,7 @@ impl framework::Example for Example {
                     cull_mode: wgpu::CullMode::Back,
                     depth_bias: 2, // corresponds to bilinear filtering
                     depth_bias_slope_scale: 2.0,
-                    depth_bias_clamp: wgpu::MAX_DEPTH_BIAS_CLAMP,
+                    depth_bias_clamp: 0.0,
                 },
                 primitive_topology: wgpu::PrimitiveTopology::TriangleList,
                 color_states: &[],
@@ -579,7 +579,7 @@ impl framework::Example for Example {
                     cull_mode: wgpu::CullMode::Back,
                     depth_bias: 0,
                     depth_bias_slope_scale: 0.0,
-                    depth_bias_clamp: wgpu::MAX_DEPTH_BIAS_CLAMP,
+                    depth_bias_clamp: 0.0,
                 },
                 primitive_topology: wgpu::PrimitiveTopology::TriangleList,
                 color_states: &[

wgpu-bindings/wgpu.h

@@ -5,8 +5,6 @@
 
 #define WGPUBITS_PER_BYTE 8
 
-#define WGPUMAX_DEPTH_BIAS_CLAMP 16
-
 typedef enum {
   WGPUAddressMode_ClampToEdge = 0,
   WGPUAddressMode_Repeat = 1,
@@ -169,6 +167,8 @@ typedef struct {
   WGPUExtensions extensions;
 } WGPUDeviceDescriptor;
 
+typedef WGPUId WGPUBindGroupId;
+
 typedef WGPUId WGPUBufferId;
 
 typedef void (*WGPUBufferMapReadCallback)(WGPUBufferMapAsyncStatus status, const uint8_t *data, uint8_t *userdata);
@@ -243,8 +243,6 @@ typedef struct {
   const WGPURenderPassDepthStencilAttachmentDescriptor_TextureViewId *depth_stencil_attachment;
 } WGPURenderPassDescriptor;
 
-typedef WGPUId WGPUBindGroupId;
-
 typedef WGPUId WGPUComputePipelineId;
 
 typedef WGPUId WGPUInstanceId;
@@ -557,6 +555,8 @@ typedef struct {
 
 WGPUDeviceId wgpu_adapter_create_device(WGPUAdapterId adapter_id, const WGPUDeviceDescriptor *desc);
 
+void wgpu_bind_group_destroy(WGPUBindGroupId bind_group_id);
+
 void wgpu_buffer_destroy(WGPUBufferId buffer_id);
 
 void wgpu_buffer_map_read_async(WGPUBufferId buffer_id,

wgpu-native/src/command/compute.rs

@@ -1,6 +1,6 @@
 use crate::command::bind::{Binder};
 use crate::hub::HUB;
-use crate::track::TrackerSet;
+use crate::track::{Stitch, TrackerSet};
 use crate::{
     Stored, CommandBuffer,
     BindGroupId, CommandBufferId, ComputePassId, ComputePipelineId,
@@ -38,8 +38,7 @@ pub extern "C" fn wgpu_compute_pass_end_pass(pass_id: ComputePassId) -> CommandB
 
     HUB.command_buffers
         .write()
-        .get_mut(pass.cmb_id.value)
-        .raw
+        [pass.cmb_id.value].raw
         .push(pass.raw);
     pass.cmb_id.value
 }
@@ -49,8 +48,7 @@ pub extern "C" fn wgpu_compute_pass_dispatch(pass_id: ComputePassId, x: u32, y:
     unsafe {
         HUB.compute_passes
             .write()
-            .get_mut(pass_id)
-            .raw
+            [pass_id].raw
             .dispatch([x, y, z]);
     }
 }
@@ -62,29 +60,27 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
     bind_group_id: BindGroupId,
 ) {
     let mut pass_guard = HUB.compute_passes.write();
-    let pass = pass_guard.get_mut(pass_id);
+    let pass = &mut pass_guard[pass_id];
     let bind_group_guard = HUB.bind_groups.read();
-    let bind_group = bind_group_guard.get(bind_group_id);
+    let bind_group = &bind_group_guard[bind_group_id];
 
     //Note: currently, WebGPU compute passes have synchronization defined
     // at a dispatch granularity, so we insert the necessary barriers here.
 
-    //TODO: have `TrackerSet::consume()` ?
     CommandBuffer::insert_barriers(
         &mut pass.raw,
-        pass.trackers.buffers.consume_by_replace(&bind_group.used.buffers),
-        pass.trackers.textures.consume_by_replace(&bind_group.used.textures),
+        &mut pass.trackers,
+        &bind_group.used,
+        Stitch::Last,
         &*HUB.buffers.read(),
         &*HUB.textures.read(),
     );
-    pass.trackers.views.consume(&bind_group.used.views);
 
     if let Some(pipeline_layout_id) = pass.binder.provide_entry(index as usize, bind_group_id, bind_group) {
         let pipeline_layout_guard = HUB.pipeline_layouts.read();
-        let pipeline_layout = pipeline_layout_guard.get(pipeline_layout_id);
         unsafe {
             pass.raw.bind_compute_descriptor_sets(
-                &pipeline_layout.raw,
+                &pipeline_layout_guard[pipeline_layout_id].raw,
                 index as usize,
                 iter::once(&bind_group.raw),
                 &[],
@@ -99,9 +95,9 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
     pipeline_id: ComputePipelineId,
 ) {
     let mut pass_guard = HUB.compute_passes.write();
-    let pass = pass_guard.get_mut(pass_id);
+    let pass = &mut pass_guard[pass_id];
     let pipeline_guard = HUB.compute_pipelines.read();
-    let pipeline = pipeline_guard.get(pipeline_id);
+    let pipeline = &pipeline_guard[pipeline_id];
 
     unsafe {
         pass.raw.bind_compute_pipeline(&pipeline.raw);
@@ -112,7 +108,7 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
     }
 
     let pipeline_layout_guard = HUB.pipeline_layouts.read();
-    let pipeline_layout = pipeline_layout_guard.get(pipeline.layout_id);
+    let pipeline_layout = &pipeline_layout_guard[pipeline.layout_id];
     let bing_group_guard = HUB.bind_groups.read();
 
     pass.binder.pipeline_layout_id = Some(pipeline.layout_id.clone());
@@ -124,12 +120,12 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
         .enumerate()
     {
         if let Some(bg_id) = entry.expect_layout(bgl_id) {
-            let bind_group = bing_group_guard.get(bg_id);
+            let desc_set = &bing_group_guard[bg_id].raw;
             unsafe {
                 pass.raw.bind_compute_descriptor_sets(
                     &pipeline_layout.raw,
                     index,
-                    iter::once(&bind_group.raw),
+                    iter::once(desc_set),
                     &[]
                 );
             }

wgpu-native/src/command/mod.rs

@@ -14,14 +14,15 @@ use crate::device::{
     all_buffer_stages, all_image_stages,
 };
 use crate::hub::{HUB, Storage};
+use crate::resource::TexturePlacement;
 use crate::swap_chain::{SwapChainLink, SwapImageEpoch};
-use crate::track::TrackerSet;
+use crate::track::{DummyUsage, Stitch, TrackerSet};
 use crate::conv;
 use crate::{
     BufferHandle, TextureHandle,
-    BufferId, CommandBufferId, CommandEncoderId, DeviceId,
-    TextureId, TextureViewId,
-    BufferUsageFlags, TextureUsageFlags, Color,
+    CommandBufferId, CommandEncoderId, DeviceId,
+    TextureViewId,
+    TextureUsageFlags, Color,
     LifeGuard, Stored,
     CommandBufferHandle,
 };
@@ -34,7 +35,6 @@ use hal::{Device as _Device};
 use log::trace;
 
 use std::collections::hash_map::Entry;
-use std::ops::Range;
 use std::{iter, slice};
 use std::thread::ThreadId;
 
@@ -90,39 +90,43 @@ pub struct CommandBuffer<B: hal::Backend> {
 }
 
 impl CommandBufferHandle {
-    pub(crate) fn insert_barriers<I, J>(
+    pub(crate) fn insert_barriers(
         raw: &mut <Backend as hal::Backend>::CommandBuffer,
-        buffer_iter: I,
-        texture_iter: J,
+        base: &mut TrackerSet,
+        head: &TrackerSet,
+        stitch: Stitch,
         buffer_guard: &Storage<BufferHandle>,
         texture_guard: &Storage<TextureHandle>,
-    ) where
-        I: Iterator<Item = (BufferId, Range<BufferUsageFlags>)>,
-        J: Iterator<Item = (TextureId, Range<TextureUsageFlags>)>,
-    {
-
-        let buffer_barriers = buffer_iter.map(|(id, transit)| {
-            let b = buffer_guard.get(id);
-            trace!("transit {:?} {:?}", id, transit);
-            hal::memory::Barrier::Buffer {
-                states: conv::map_buffer_state(transit.start) .. conv::map_buffer_state(transit.end),
-                target: &b.raw,
-                range: None .. None,
-                families: None,
-            }
-        });
-        let texture_barriers = texture_iter.map(|(id, transit)| {
-            let t = texture_guard.get(id);
-            trace!("transit {:?} {:?}", id, transit);
-            let aspects = t.full_range.aspects;
-            hal::memory::Barrier::Image {
-                states: conv::map_texture_state(transit.start, aspects)
-                    ..conv::map_texture_state(transit.end, aspects),
-                target: &t.raw,
-                range: t.full_range.clone(), //TODO?
-                families: None,
-            }
-        });
+    ) {
+        let buffer_barriers = base.buffers
+            .consume_by_replace(&head.buffers, stitch)
+            .map(|(id, transit)| {
+                let b = &buffer_guard[id];
+                trace!("transit buffer {:?} {:?}", id, transit);
+                hal::memory::Barrier::Buffer {
+                    states: conv::map_buffer_state(transit.start) .. conv::map_buffer_state(transit.end),
+                    target: &b.raw,
+                    range: None .. None,
+                    families: None,
+                }
+            });
+        let texture_barriers = base.textures
+            .consume_by_replace(&head.textures, stitch)
+            .map(|(id, transit)| {
+                let t = &texture_guard[id];
+                trace!("transit texture {:?} {:?}", id, transit);
+                let aspects = t.full_range.aspects;
+                hal::memory::Barrier::Image {
+                    states: conv::map_texture_state(transit.start, aspects)
+                        ..conv::map_texture_state(transit.end, aspects),
+                    target: &t.raw,
+                    range: t.full_range.clone(), //TODO?
+                    families: None,
+                }
+            });
+        base.views
+            .consume_by_extend(&head.views)
+            .unwrap();
 
         let stages = all_buffer_stages() | all_image_stages();
         unsafe {
@@ -148,7 +152,7 @@ pub extern "C" fn wgpu_command_encoder_finish(
 ) -> CommandBufferId {
     HUB.command_buffers
         .write()
-        .get_mut(command_encoder_id)
+        [command_encoder_id]
         .is_recording = false; //TODO: check for the old value
     command_encoder_id
 }
@@ -158,9 +162,9 @@ pub fn command_encoder_begin_render_pass(
     desc: RenderPassDescriptor,
 ) -> RenderPass<Backend> {
     let mut cmb_guard = HUB.command_buffers.write();
-    let cmb = cmb_guard.get_mut(command_encoder_id);
+    let cmb = &mut cmb_guard[command_encoder_id];
     let device_guard = HUB.devices.read();
-    let device = device_guard.get(cmb.device_id.value);
+    let device = &device_guard[cmb.device_id.value];
     let view_guard = HUB.texture_views.read();
 
     let mut current_comb = device.com_allocator.extend(cmb);
@@ -187,13 +191,13 @@ pub fn command_encoder_begin_render_pass(
         let swap_chain_links = &mut cmb.swap_chain_links;
 
         let depth_stencil_key = depth_stencil_attachment.map(|at| {
-            let view = view_guard.get(at.attachment);
+            let view = &view_guard[at.attachment];
             if let Some(ex) = extent {
                 assert_eq!(ex, view.extent);
             } else {
                 extent = Some(view.extent);
             }
-            trackers.views.query(at.attachment, &view.life_guard.ref_count);
+            trackers.views.query(at.attachment, &view.life_guard.ref_count, DummyUsage);
             let query = trackers.textures.query(
                 view.texture_id.value,
                 &view.texture_id.ref_count,
@@ -213,20 +217,20 @@ pub fn command_encoder_begin_render_pass(
         });
 
         let color_keys = color_attachments.iter().map(|at| {
-            let view = view_guard.get(at.attachment);
+            let view = &view_guard[at.attachment];
 
             if view.is_owned_by_swap_chain {
                 let link = match HUB.textures
                     .read()
-                    .get(view.texture_id.value)
-                    .swap_chain_link
+                    [view.texture_id.value].placement
                 {
-                    Some(ref link) => SwapChainLink {
+                    TexturePlacement::SwapChain(ref link) => SwapChainLink {
                         swap_chain_id: link.swap_chain_id.clone(),
                         epoch: *link.epoch.lock(),
                         image_index: link.image_index,
                     },
-                    None => unreachable!()
+                    TexturePlacement::Memory(_) |
+                    TexturePlacement::Void => unreachable!()
                 };
                 swap_chain_links.push(link);
             }
@@ -236,7 +240,7 @@ pub fn command_encoder_begin_render_pass(
             } else {
                 extent = Some(view.extent);
             }
-            trackers.views.query(at.attachment, &view.life_guard.ref_count);
+            trackers.views.query(at.attachment, &view.life_guard.ref_count, DummyUsage);
             let query = trackers.textures.query(
                 view.texture_id.value,
                 &view.texture_id.ref_count,
@@ -308,7 +312,7 @@ pub fn command_encoder_begin_render_pass(
                     .key()
                     .attachments
                     .iter()
-                    .map(|&id| &view_guard.get(id).raw);
+                    .map(|&id| &view_guard[id].raw);
 
                 unsafe {
                     device
@@ -381,7 +385,7 @@ pub fn command_encoder_begin_compute_pass(
     command_encoder_id: CommandEncoderId,
 ) -> ComputePass<Backend> {
     let mut cmb_guard = HUB.command_buffers.write();
-    let cmb = cmb_guard.get_mut(command_encoder_id);
+    let cmb = &mut cmb_guard[command_encoder_id];
 
     let raw = cmb.raw.pop().unwrap();
     let stored = Stored {