More as_hal() methods

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,
@@ -438,11 +438,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);
@@ -451,7 +451,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
@@ -474,6 +493,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
@@ -511,6 +550,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

@@ -114,9 +114,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/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};
@@ -622,4 +622,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

@@ -933,6 +933,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

@@ -213,6 +213,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 {
@@ -290,6 +292,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

@@ -351,6 +351,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

@@ -66,6 +66,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

@@ -1694,6 +1694,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 {

wgpu-hal/src/vulkan/mod.rs

@@ -27,7 +27,7 @@ Otherwise, we manage a pool of `VkFence` objects behind each `hal::Fence`.
 
 mod adapter;
 mod command;
-mod conv;
+pub mod conv;
 mod device;
 mod instance;
 
@@ -70,6 +70,8 @@ impl crate::Api for Api {
     type ShaderModule = ShaderModule;
     type RenderPipeline = RenderPipeline;
     type ComputePipeline = ComputePipeline;
+
+    type TextureFormat = vk::Format;
 }
 
 struct DebugUtils {
@@ -364,6 +366,19 @@ pub struct TextureView {
     attachment: FramebufferAttachment,
 }
 
+impl TextureView {
+    /// # Safety
+    ///
+    /// - The image view handle must not be manually destroyed
+    pub unsafe fn raw_handle(&self) -> vk::ImageView {
+        self.raw
+    }
+
+    pub fn aspects(&self) -> crate::FormatAspects {
+        self.attachment.view_format.into()
+    }
+}
+
 #[derive(Debug)]
 pub struct Sampler {
     raw: vk::Sampler,
@@ -432,6 +447,15 @@ pub struct CommandEncoder {
     end_of_pass_timer_query: Option<(vk::QueryPool, u32)>,
 }
 
+impl CommandEncoder {
+    /// # Safety
+    ///
+    /// - The commmand buffer handle must not be manually destroyed
+    pub unsafe fn raw_handle(&self) -> vk::CommandBuffer {
+        self.active
+    }
+}
+
 impl fmt::Debug for CommandEncoder {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("CommandEncoder")