Revert "fixup! fix(core): use BufferMapState::Active for any BufferUsages::MAP_* flags"

This reverts commit 1c0837b.

Author: ErichDonGubler

wgpu-core/src/device/global.rs

@@ -2346,6 +2346,18 @@ impl Global {
         }
         let map_state = &*buffer.map_state.lock();
         match *map_state {
+            resource::BufferMapState::Init { ref staging_buffer } => {
+                // offset (u64) can not be < 0, so no need to validate the lower bound
+                if offset + range_size > buffer.size {
+                    return Err(BufferAccessError::OutOfBoundsOverrun {
+                        index: offset + range_size - 1,
+                        max: buffer.size,
+                    });
+                }
+                let ptr = unsafe { staging_buffer.ptr() };
+                let ptr = unsafe { NonNull::new_unchecked(ptr.as_ptr().offset(offset as isize)) };
+                Ok((ptr, range_size))
+            }
             resource::BufferMapState::Active {
                 ref mapping,
                 ref range,

wgpu-core/src/device/resource.rs

@@ -988,7 +988,12 @@ impl Device {
 
         let buffer = Arc::new(buffer);
 
-        let buffer_use = if desc.mapped_at_creation {
+        let buffer_use = if !desc.mapped_at_creation {
+            wgt::BufferUses::empty()
+        } 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 {
@@ -1007,7 +1012,16 @@ impl Device {
             };
             wgt::BufferUses::MAP_WRITE
         } else {
-            wgt::BufferUses::empty()
+            let mut staging_buffer =
+                StagingBuffer::new(self, wgt::BufferSize::new(aligned_size).unwrap())?;
+
+            // Zero initialize memory and then mark the buffer as initialized
+            // (it's guaranteed that this is the case by the time the buffer is usable)
+            staging_buffer.write_zeros();
+            buffer.initialization_status.write().drain(0..aligned_size);
+
+            *buffer.map_state.lock() = resource::BufferMapState::Init { staging_buffer };
+            wgt::BufferUses::COPY_DST
         };
 
         self.trackers

wgpu-core/src/resource.rs

@@ -216,6 +216,8 @@ macro_rules! impl_trackable {
 
 #[derive(Debug)]
 pub(crate) enum BufferMapState {
+    /// Mapped at creation.
+    Init { staging_buffer: StagingBuffer },
     /// Waiting for GPU to be done before mapping
     Waiting(BufferPendingMapping),
     /// Mapped
@@ -639,7 +641,7 @@ impl Buffer {
         {
             let map_state = &mut *self.map_state.lock();
             *map_state = match *map_state {
-                BufferMapState::Active { .. } => {
+                BufferMapState::Init { .. } | BufferMapState::Active { .. } => {
                     return Err((op, BufferAccessError::AlreadyMapped));
                 }
                 BufferMapState::Waiting(_) => {
@@ -692,6 +694,7 @@ impl Buffer {
                 *self.map_state.lock() = mapping;
                 return None;
             }
+            _ => panic!("No pending mapping."),
         };
         let status = if pending_mapping.range.start != pending_mapping.range.end {
             let host = pending_mapping.op.host;
@@ -752,6 +755,56 @@ impl Buffer {
         let snatch_guard = device.snatchable_lock.read();
         let raw_buf = self.try_raw(&snatch_guard)?;
         match mem::replace(&mut *self.map_state.lock(), BufferMapState::Idle) {
+            BufferMapState::Init { staging_buffer } => {
+                #[cfg(feature = "trace")]
+                if let Some(ref mut trace) = *device.trace.lock() {
+                    let data = trace.make_binary("bin", staging_buffer.get_data());
+                    trace.add(trace::Action::WriteBuffer {
+                        id: buffer_id,
+                        data,
+                        range: 0..self.size,
+                        queued: true,
+                    });
+                }
+
+                let staging_buffer = staging_buffer.flush();
+
+                if let Some(queue) = device.get_queue() {
+                    let region = wgt::BufferSize::new(self.size).map(|size| hal::BufferCopy {
+                        src_offset: 0,
+                        dst_offset: 0,
+                        size,
+                    });
+                    let transition_src = hal::BufferBarrier {
+                        buffer: staging_buffer.raw(),
+                        usage: hal::StateTransition {
+                            from: wgt::BufferUses::MAP_WRITE,
+                            to: wgt::BufferUses::COPY_SRC,
+                        },
+                    };
+                    let transition_dst = hal::BufferBarrier::<dyn hal::DynBuffer> {
+                        buffer: raw_buf,
+                        usage: hal::StateTransition {
+                            from: wgt::BufferUses::empty(),
+                            to: wgt::BufferUses::COPY_DST,
+                        },
+                    };
+                    let mut pending_writes = queue.pending_writes.lock();
+                    let encoder = pending_writes.activate();
+                    unsafe {
+                        encoder.transition_buffers(&[transition_src, transition_dst]);
+                        if self.size > 0 {
+                            encoder.copy_buffer_to_buffer(
+                                staging_buffer.raw(),
+                                raw_buf,
+                                region.as_slice(),
+                            );
+                        }
+                    }
+                    pending_writes.consume(staging_buffer);
+                    pending_writes.insert_buffer(self);
+                }
+            }
             BufferMapState::Idle => {
                 return Err(BufferAccessError::NotMapped);
             }
@@ -996,6 +1049,15 @@ impl StagingBuffer {
         self.ptr
     }
 
+    #[cfg(feature = "trace")]
+    pub(crate) fn get_data(&self) -> &[u8] {
+        unsafe { core::slice::from_raw_parts(self.ptr.as_ptr(), self.size.get() as usize) }
+    }
+
+    pub(crate) fn write_zeros(&mut self) {
+        unsafe { core::ptr::write_bytes(self.ptr.as_ptr(), 0, self.size.get() as usize) };
+    }
+
     pub(crate) fn write(&mut self, data: &[u8]) {
         assert!(data.len() >= self.size.get() as usize);
         // SAFETY: With the assert above, all of `copy_nonoverlapping`'s