Update after merge

gfx-rs · cwfitzgerald · Jul 7, 2023 · Jan 6, 2023 · May 14, 2023 · Jul 5, 2023
commit 5ead857a847eb345bd4e544fadadaec1cb9e154b
@@ -684,6 +684,63 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         (id, Some(error))
     }
 
+    /// # Safety
+    ///
+    /// - `hal_buffer` must be created from `device_id` corresponding raw handle.
+    /// - `hal_buffer` must be created respecting `desc`
+    /// - `hal_buffer` must be initialized
+    pub unsafe fn create_buffer_from_hal<A: HalApi>(
+        &self,
+        hal_buffer: A::Buffer,
+        device_id: id::DeviceId,
+        desc: &resource::BufferDescriptor,
+        id_in: Input<G, id::BufferId>,
+    ) -> (id::BufferId, Option<resource::CreateBufferError>) {
+        profiling::scope!("Device::create_buffer");
+
+        let hub = A::hub(self);
+        let mut token = Token::root();
+        let fid = hub.buffers.prepare(id_in);
+
+        let (device_guard, mut token) = hub.devices.read(&mut token);
+        let error = loop {
+            let device = match device_guard.get(device_id) {
+                Ok(device) => device,
+                Err(_) => break DeviceError::Invalid.into(),
+            };
+
+            // NB: Any change done through the raw buffer handle will not be
+            // recorded in the replay
+            #[cfg(feature = "trace")]
+            if let Some(ref trace) = device.trace {
+                trace
+                    .lock()
+                    .add(trace::Action::CreateBuffer(fid.id(), desc.clone()));
+            }
+
+            let mut buffer = device.create_buffer_from_hal(hal_buffer, device_id, desc);
+
+            // Assume external buffers are initialized
+            buffer.initialization_status = BufferInitTracker::new(0);
+
+            let ref_count = buffer.life_guard.add_ref();
+
+            let id = fid.assign(buffer, &mut token);
+            log::info!("Created buffer {:?} with {:?}", id, desc);
+
+            device
+                .trackers
+                .lock()
+                .buffers
+                .insert_single(id, ref_count, hal::BufferUses::empty());
+
+            return (id.0, None);
+        };
+
+        let id = fid.assign_error(desc.label.borrow_or_default(), &mut token);
+        (id, Some(error))
+    }
+
     pub fn texture_label<A: HalApi>(&self, id: id::TextureId) -> String {
         A::hub(self).textures.label_for_resource(id)
     }

@@ -501,6 +501,29 @@ impl<A: HalApi> Device<A> {
         }
     }
 
+    fn create_buffer_from_hal(
+        &self,
+        hal_buffer: A::Buffer,
+        self_id: id::DeviceId,
+        desc: &resource::BufferDescriptor,
+    ) -> resource::Buffer<A> {
+        debug_assert_eq!(self_id.backend(), A::VARIANT);
+
+        resource::Buffer {
+            raw: Some(hal_buffer),
+            device_id: Stored {
+                value: id::Valid(self_id),
+                ref_count: self.life_guard.add_ref(),
+            },
+            usage: desc.usage,
+            size: desc.size,
+            initialization_status: BufferInitTracker::new(0),
+            sync_mapped_writes: None,
+            map_state: resource::BufferMapState::Idle,
+            life_guard: LifeGuard::new(desc.label.borrow_or_default()),
+        }
+    }
+
     pub(super) fn create_texture(
         &self,
         self_id: id::DeviceId,