More as_hal() methods

Cargo.toml

@@ -50,8 +50,8 @@ path = "./wgpu-hal"
 version = "0.17"
 
 [workspace.dependencies.naga]
-git = "https://github.com/gfx-rs/naga"
-rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
+# git = "https://github.com/gfx-rs/naga"
+# rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
 version = "0.13.0"
 
 [workspace.dependencies]

wgpu-core/Cargo.toml

@@ -71,8 +71,8 @@ smallvec = "1"
 thiserror = "1"
 
 [dependencies.naga]
-git = "https://github.com/gfx-rs/naga"
-rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
+# git = "https://github.com/gfx-rs/naga"
+# rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
 version = "0.13.0"
 features = ["clone", "span", "validate"]
 

wgpu-core/src/command/mod.rs

@@ -46,7 +46,7 @@ enum CommandEncoderStatus {
     Error,
 }
 
-struct CommandEncoder<A: hal::Api> {
+pub struct CommandEncoder<A: hal::Api> {
     raw: A::CommandEncoder,
     list: Vec<A::CommandBuffer>,
     is_open: bool,
@@ -79,7 +79,7 @@ impl<A: hal::Api> CommandEncoder<A> {
         }
     }
 
-    fn open(&mut self) -> &mut A::CommandEncoder {
+    pub fn open(&mut self) -> &mut A::CommandEncoder {
         if !self.is_open {
             self.is_open = true;
             let label = self.label.as_deref();
@@ -106,7 +106,7 @@ pub(crate) struct DestroyedBufferError(pub id::BufferId);
 pub(crate) struct DestroyedTextureError(pub id::TextureId);
 
 pub struct CommandBuffer<A: HalApi> {
-    encoder: CommandEncoder<A>,
+    pub(crate) encoder: CommandEncoder<A>,
     status: CommandEncoderStatus,
     pub(crate) device_id: Stored<id::DeviceId>,
     pub(crate) trackers: Tracker<A>,

wgpu-core/src/hub.rs

@@ -155,11 +155,11 @@ flagged as errors as well.
 [`IdentityHandlerFactory<I>`]: crate::identity::IdentityHandlerFactory
 */
 
+pub use crate::hal_api::HalApi;
 use crate::{
     binding_model::{BindGroup, BindGroupLayout, PipelineLayout},
     command::{CommandBuffer, RenderBundle},
     device::Device,
-    hal_api::HalApi,
     id,
     identity::GlobalIdentityHandlerFactory,
     instance::{Adapter, HalSurface, Instance, Surface},

wgpu-core/src/resource.rs

@@ -3,7 +3,7 @@ use crate::{
     global::Global,
     hal_api::HalApi,
     hub::Token,
-    id::{AdapterId, DeviceId, SurfaceId, TextureId, Valid},
+    id::{AdapterId, CommandEncoderId, DeviceId, SurfaceId, TextureId, TextureViewId, Valid},
     identity::GlobalIdentityHandlerFactory,
     init_tracker::{BufferInitTracker, TextureInitTracker},
     track::TextureSelector,
@@ -426,11 +426,11 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
     /// # Safety
     ///
     /// - The raw texture handle must not be manually destroyed
-    pub unsafe fn texture_as_hal<A: HalApi, F: FnOnce(Option<&A::Texture>)>(
+    pub unsafe fn texture_as_hal<A: HalApi, F: FnOnce(Option<&A::Texture>) -> R, R>(
         &self,
         id: TextureId,
         hal_texture_callback: F,
-    ) {
+    ) -> R {
         profiling::scope!("Texture::as_hal");
 
         let hub = A::hub(self);
@@ -439,7 +439,26 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let texture = guard.try_get(id).ok().flatten();
         let hal_texture = texture.and_then(|tex| tex.inner.as_raw());
 
-        hal_texture_callback(hal_texture);
+        hal_texture_callback(hal_texture)
+    }
+
+    /// # Safety
+    ///
+    /// - The raw texture view handle must not be manually destroyed
+    pub unsafe fn texture_view_as_hal<A: HalApi, F: FnOnce(Option<&A::TextureView>) -> R, R>(
+        &self,
+        id: TextureViewId,
+        hal_texture_view_callback: F,
+    ) -> R {
+        profiling::scope!("TextureView::as_hal");
+
+        let hub = A::hub(self);
+        let mut token = Token::root();
+        let (guard, _) = hub.texture_views.read(&mut token);
+        let texture_view = guard.try_get(id).ok().flatten();
+        let hal_texture_view = texture_view.map(|tex| &tex.raw);
+
+        hal_texture_view_callback(hal_texture_view)
     }
 
     /// # Safety
@@ -462,6 +481,26 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         hal_adapter_callback(hal_adapter)
     }
 
+    #[cfg(any(not(target_arch = "wasm32"), feature = "emscripten"))]
+    pub fn texture_format_as_hal<A: HalApi>(
+        &self,
+        adapter: AdapterId,
+        texture_format: wgt::TextureFormat,
+    ) -> Option<A::TextureFormat> {
+        use hal::Adapter;
+
+        profiling::scope!("TextureFormat::as_hal");
+
+        let hub = A::hub(self);
+        let mut token = Token::root();
+
+        let (guard, _) = hub.adapters.read(&mut token);
+        let adapter = guard.try_get(adapter).ok().flatten();
+        let hal_adapter = adapter.map(|adapter| &adapter.raw.adapter);
+
+        hal_adapter.map(|hal_adapter| hal_adapter.texture_format_as_hal(texture_format))
+    }
+
     /// # Safety
     ///
     /// - The raw device handle must not be manually destroyed
@@ -499,6 +538,28 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
 
         hal_surface_callback(hal_surface)
     }
+
+    /// # Safety
+    /// - The raw command encoder handle must not be manually destroyed
+    pub unsafe fn command_encoder_as_hal_mut<
+        A: HalApi,
+        F: FnOnce(Option<&mut A::CommandEncoder>) -> R,
+        R,
+    >(
+        &self,
+        id: CommandEncoderId,
+        hal_command_encoder_callback: F,
+    ) -> R {
+        profiling::scope!("CommandEncoder::as_hal_mut");
+
+        let hub = A::hub(self);
+        let mut token = Token::root();
+        let (mut guard, _) = hub.command_buffers.write(&mut token);
+        let command_encoder = guard.get_mut(id).ok();
+        let hal_command_encoder = command_encoder.map(|encoder| encoder.encoder.open());
+
+        hal_command_encoder_callback(hal_command_encoder)
+    }
 }
 
 #[derive(Clone, Copy, Debug)]

wgpu-core/src/track/mod.rs

@@ -112,9 +112,8 @@ use thiserror::Error;
 pub(crate) use buffer::{BufferBindGroupState, BufferTracker, BufferUsageScope};
 use metadata::{ResourceMetadata, ResourceMetadataProvider};
 pub(crate) use stateless::{StatelessBindGroupSate, StatelessTracker};
-pub(crate) use texture::{
-    TextureBindGroupState, TextureSelector, TextureTracker, TextureUsageScope,
-};
+pub use texture::TextureSelector;
+pub(crate) use texture::{TextureBindGroupState, TextureTracker, TextureUsageScope};
 use wgt::strict_assert_ne;
 
 /// A structure containing all the information about a particular resource

wgpu-hal/Cargo.toml

@@ -119,15 +119,15 @@ libc = "0.2"
 android_system_properties = "0.1.1"
 
 [dependencies.naga]
-git = "https://github.com/gfx-rs/naga"
-rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
+# git = "https://github.com/gfx-rs/naga"
+# rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
 version = "0.13.0"
 features = ["clone"]
 
 # DEV dependencies
 [dev-dependencies.naga]
-git = "https://github.com/gfx-rs/naga"
-rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
+# git = "https://github.com/gfx-rs/naga"
+# rev = "bac2d82a430fbfcf100ee22b7c3bc12f3d593079"
 version = "0.13.0"
 features = ["wgsl-in"]
 

wgpu-hal/src/dx11/adapter.rs

@@ -28,6 +28,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
         todo!()
     }
+
+    fn texture_format_as_hal(
+        &self,
+        texture_format: wgt::TextureFormat,
+    ) -> <crate::dx11::Api as crate::Api>::TextureFormat {
+        todo!()
+    }
 }
 
 impl super::Adapter {

wgpu-hal/src/dx11/mod.rs

@@ -36,6 +36,8 @@ impl crate::Api for Api {
     type ShaderModule = ShaderModule;
     type RenderPipeline = RenderPipeline;
     type ComputePipeline = ComputePipeline;
+
+    type TextureFormat = ();
 }
 
 pub struct Instance {

wgpu-hal/src/dx12/adapter.rs

@@ -1,5 +1,5 @@
 use crate::{
-    auxil::{self, dxgi::result::HResult as _},
+    auxil::{self, dxgi::conv::map_texture_format, dxgi::result::HResult as _},
     dx12::SurfaceTarget,
 };
 use std::{mem, ptr, sync::Arc, thread};
@@ -613,4 +613,11 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
         wgt::PresentationTimestamp(self.presentation_timer.get_timestamp_ns())
     }
+
+    fn texture_format_as_hal(
+        &self,
+        texture_format: wgt::TextureFormat,
+    ) -> <crate::dx12::Api as crate::Api>::TextureFormat {
+        map_texture_format(texture_format)
+    }
 }

wgpu-hal/src/dx12/mod.rs

@@ -50,7 +50,7 @@ use arrayvec::ArrayVec;
 use parking_lot::Mutex;
 use std::{ffi, fmt, mem, num::NonZeroU32, sync::Arc};
 use winapi::{
-    shared::{dxgi, dxgi1_4, dxgitype, windef, winerror},
+    shared::{dxgi, dxgi1_4, dxgiformat, dxgitype, windef, winerror},
     um::{d3d12 as d3d12_ty, dcomp, synchapi, winbase, winnt},
     Interface as _,
 };
@@ -82,6 +82,8 @@ impl crate::Api for Api {
     type ShaderModule = ShaderModule;
     type RenderPipeline = RenderPipeline;
     type ComputePipeline = ComputePipeline;
+
+    type TextureFormat = dxgiformat::DXGI_FORMAT;
 }
 
 // Limited by D3D12's root signature size of 64. Each element takes 1 or 2 entries.

wgpu-hal/src/empty.rs

@@ -36,6 +36,8 @@ impl crate::Api for Api {
     type ShaderModule = Resource;
     type RenderPipeline = Resource;
     type ComputePipeline = Resource;
+
+    type TextureFormat = Resource;
 }
 
 impl crate::Instance<Api> for Context {
@@ -97,6 +99,13 @@ impl crate::Adapter<Api> for Context {
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
         wgt::PresentationTimestamp::INVALID_TIMESTAMP
     }
+
+    fn texture_format_as_hal(
+        &self,
+        texture_format: wgt::TextureFormat,
+    ) -> <Api as crate::Api>::TextureFormat {
+        Resource
+    }
 }
 
 impl crate::Queue<Api> for Context {

wgpu-hal/src/gles/adapter.rs

@@ -927,6 +927,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp {
         wgt::PresentationTimestamp::INVALID_TIMESTAMP
     }
+
+    fn texture_format_as_hal(
+        &self,
+        _texture_format: wgt::TextureFormat,
+    ) -> <super::Api as crate::Api>::TextureFormat {
+        todo!()
+    }
 }
 
 impl super::AdapterShared {

wgpu-hal/src/gles/mod.rs

@@ -126,6 +126,8 @@ impl crate::Api for Api {
     type ShaderModule = ShaderModule;
     type RenderPipeline = RenderPipeline;
     type ComputePipeline = ComputePipeline;
+
+    type TextureFormat = ();
 }
 
 bitflags::bitflags! {

wgpu-hal/src/lib.rs

@@ -178,6 +178,8 @@ pub trait Api: Clone + Sized {
     type ShaderModule: fmt::Debug + WasmNotSend + WasmNotSync;
     type RenderPipeline: WasmNotSend + WasmNotSync;
     type ComputePipeline: WasmNotSend + WasmNotSync;
+
+    type TextureFormat;
 }
 
 pub trait Instance<A: Api>: Sized + WasmNotSend + WasmNotSync {
@@ -239,6 +241,9 @@ pub trait Adapter<A: Api>: WasmNotSend + WasmNotSync {
     ///
     /// [`PresentationTimestamp`]: wgt::PresentationTimestamp
     unsafe fn get_presentation_timestamp(&self) -> wgt::PresentationTimestamp;
+
+    // Returns the hal texture format.
+    fn texture_format_as_hal(&self, texture_format: wgt::TextureFormat) -> A::TextureFormat;
 }
 
 pub trait Device<A: Api>: WasmNotSend + WasmNotSync {

wgpu-hal/src/metal/adapter.rs

@@ -321,6 +321,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
 
         wgt::PresentationTimestamp(timestamp)
     }
+
+    fn texture_format_as_hal(
+        &self,
+        texture_format: wgt::TextureFormat,
+    ) -> <crate::metal::Api as crate::Api>::TextureFormat {
+        self.shared.private_caps.map_format(texture_format)
+    }
 }
 
 const RESOURCE_HEAP_SUPPORT: &[MTLFeatureSet] = &[

wgpu-hal/src/metal/mod.rs

@@ -65,6 +65,8 @@ impl crate::Api for Api {
     type ShaderModule = ShaderModule;
     type RenderPipeline = RenderPipeline;
     type ComputePipeline = ComputePipeline;
+
+    type TextureFormat = metal::MTLPixelFormat;
 }
 
 pub struct Instance {

wgpu-hal/src/vulkan/adapter.rs

@@ -1686,6 +1686,13 @@ impl crate::Adapter<super::Api> for super::Adapter {
             wgt::PresentationTimestamp::INVALID_TIMESTAMP
         }
     }
+
+    fn texture_format_as_hal(
+        &self,
+        texture_format: wgt::TextureFormat,
+    ) -> <super::Api as crate::Api>::TextureFormat {
+        self.private_caps.map_texture_format(texture_format)
+    }
 }
 
 fn is_format_16bit_norm_supported(instance: &ash::Instance, phd: vk::PhysicalDevice) -> bool {