SYNC POINT: merge

Author: ErichDonGubler

wgpu-core/src/device/queue.rs

@@ -650,6 +650,9 @@ impl Queue {
         buffer_offset: u64,
         buffer_size: wgt::BufferSize,
     ) -> Result<(), TransferError> {
+        if !matches!(&*buffer.map_state.lock(), BufferMapState::Idle) {
+            todo!();
+        }
         buffer.check_usage(wgt::BufferUsages::COPY_DST)?;
         if buffer_size.get() % wgt::COPY_BUFFER_ALIGNMENT != 0 {
             return Err(TransferError::UnalignedCopySize(buffer_size.get()));
@@ -692,27 +695,34 @@ impl Queue {
 
         self.validate_write_buffer_impl(&buffer, buffer_offset, staging_buffer.size)?;
 
-        let region = hal::BufferCopy {
-            src_offset: 0,
-            dst_offset: buffer_offset,
-            size: staging_buffer.size,
-        };
-        let barriers = iter::once(hal::BufferBarrier {
-            buffer: staging_buffer.raw(),
-            usage: hal::StateTransition {
-                from: wgt::BufferUses::MAP_WRITE,
-                to: wgt::BufferUses::COPY_SRC,
-            },
-        })
-        .chain(transition.map(|pending| pending.into_hal(&buffer, snatch_guard)))
-        .collect::<Vec<_>>();
-        let encoder = pending_writes.activate();
-        unsafe {
-            encoder.transition_buffers(&barriers);
-            encoder.copy_buffer_to_buffer(staging_buffer.raw(), dst_raw, &[region]);
-        }
+        if buffer
+            .usage
+            .intersects(wgt::BufferUsages::MAP_READ | wgt::BufferUsages::MAP_WRITE)
+        {
+            let asdf = buffer.raw(&self.device.snatchable_lock.read()).unwrap();
+        } else {
+            let region = hal::BufferCopy {
+                src_offset: 0,
+                dst_offset: buffer_offset,
+                size: staging_buffer.size,
+            };
+            let barriers = iter::once(hal::BufferBarrier {
+                buffer: staging_buffer.raw(),
+                usage: hal::StateTransition {
+                    from: wgt::BufferUses::MAP_WRITE,
+                    to: wgt::BufferUses::COPY_SRC,
+                },
+            })
+            .chain(transition.map(|pending| pending.into_hal(&buffer, snatch_guard)))
+            .collect::<Vec<_>>();
+            let encoder = pending_writes.activate();
+            unsafe {
+                encoder.transition_buffers(&barriers);
+                encoder.copy_buffer_to_buffer(staging_buffer.raw(), dst_raw, &[region]);
+            }
 
-        pending_writes.insert_buffer(&buffer);
+            pending_writes.insert_buffer(&buffer);
+        }
 
         // Ensure the overwritten bytes are marked as initialized so
         // they don't need to be nulled prior to mapping or binding.

wgpu-core/src/device/resource.rs

@@ -990,7 +990,10 @@ impl Device {
 
         let buffer_use = if !desc.mapped_at_creation {
             wgt::BufferUses::empty()
-        } else if desc.usage.contains(wgt::BufferUsages::MAP_WRITE) {
+        } else if desc
+            .usage
+            .intersects(wgt::BufferUsages::MAP_WRITE | wgt::BufferUsages::MAP_READ)
+        {
             // buffer is mappable, so we are just doing that at start
             let map_size = buffer.size;
             let mapping = if map_size == 0 {

wgpu-core/src/resource.rs

@@ -816,7 +816,7 @@ impl Buffer {
                 range,
                 host,
             } => {
-                #[allow(clippy::collapsible_if)]
+                #[cfg_attr(not(feature = "trace"), expect(clippy::collapsible_if))]
                 if host == HostMap::Write {
                     #[cfg(feature = "trace")]
                     if let Some(ref mut trace) = *device.trace.lock() {