[metal] Import prefixed metal items

A lot of Metal types are prefixed with MTL, which makes it quite clear
where they're coming from. This means that we don't loose any clarity if
we import them instead of having them prefixed with `metal::`.

This will make it easier to migrate to `objc2-metal` since that crate is
named differently from the `metal` crate.

Author: madsmtm

wgpu-hal/src/metal/adapter.rs

@@ -1,4 +1,7 @@
-use metal::{MTLFeatureSet, MTLGPUFamily, MTLLanguageVersion, MTLReadWriteTextureTier};
+use metal::{
+    MTLArgumentBuffersTier, MTLCounterSamplingPoint, MTLFeatureSet, MTLGPUFamily,
+    MTLLanguageVersion, MTLPixelFormat, MTLReadWriteTextureTier, NSInteger,
+};
 use objc::{class, msg_send, sel, sel_impl};
 use parking_lot::Mutex;
 use wgt::{AstcBlock, AstcChannel};
@@ -575,19 +578,18 @@ impl super::PrivateCapabilities {
 
         let mut timestamp_query_support = TimestampQuerySupport::empty();
         if version.at_least((11, 0), (14, 0), os_is_mac)
-            && device.supports_counter_sampling(metal::MTLCounterSamplingPoint::AtStageBoundary)
+            && device.supports_counter_sampling(MTLCounterSamplingPoint::AtStageBoundary)
         {
             // If we don't support at stage boundary, don't support anything else.
             timestamp_query_support.insert(TimestampQuerySupport::STAGE_BOUNDARIES);
 
-            if device.supports_counter_sampling(metal::MTLCounterSamplingPoint::AtDrawBoundary) {
+            if device.supports_counter_sampling(MTLCounterSamplingPoint::AtDrawBoundary) {
                 timestamp_query_support.insert(TimestampQuerySupport::ON_RENDER_ENCODER);
             }
-            if device.supports_counter_sampling(metal::MTLCounterSamplingPoint::AtDispatchBoundary)
-            {
+            if device.supports_counter_sampling(MTLCounterSamplingPoint::AtDispatchBoundary) {
                 timestamp_query_support.insert(TimestampQuerySupport::ON_COMPUTE_ENCODER);
             }
-            if device.supports_counter_sampling(metal::MTLCounterSamplingPoint::AtBlitBoundary) {
+            if device.supports_counter_sampling(MTLCounterSamplingPoint::AtBlitBoundary) {
                 timestamp_query_support.insert(TimestampQuerySupport::ON_BLIT_ENCODER);
             }
             // `TimestampQuerySupport::INSIDE_WGPU_PASSES` emerges from the other flags.
@@ -728,8 +730,7 @@ impl super::PrivateCapabilities {
                 31
             },
             max_samplers_per_stage: 16,
-            max_binding_array_elements: if argument_buffers == metal::MTLArgumentBuffersTier::Tier2
-            {
+            max_binding_array_elements: if argument_buffers == MTLArgumentBuffersTier::Tier2 {
                 1_000_000
             } else if family_check && device.supports_family(MTLGPUFamily::Apple4) {
                 96
@@ -753,8 +754,7 @@ impl super::PrivateCapabilities {
             buffer_alignment: if os_is_mac || os_is_xr { 256 } else { 64 },
             max_buffer_size: if version.at_least((10, 14), (12, 0), os_is_mac) {
                 // maxBufferLength available on macOS 10.14+ and iOS 12.0+
-                let buffer_size: metal::NSInteger =
-                    unsafe { msg_send![device.as_ref(), maxBufferLength] };
+                let buffer_size: NSInteger = unsafe { msg_send![device.as_ref(), maxBufferLength] };
                 buffer_size as _
             } else if os_is_mac {
                 1 << 30 // 1GB on macOS 10.11 and up
@@ -955,7 +955,7 @@ impl super::PrivateCapabilities {
                 | F::PARTIALLY_BOUND_BINDING_ARRAY,
             self.msl_version >= MTLLanguageVersion::V3_0
                 && self.supports_arrays_of_textures
-                && self.argument_buffers as u64 >= metal::MTLArgumentBuffersTier::Tier2 as u64,
+                && self.argument_buffers as u64 >= MTLArgumentBuffersTier::Tier2 as u64,
         );
         features.set(
             F::SHADER_INT64,
@@ -1080,9 +1080,9 @@ impl super::PrivateCapabilities {
         }
     }
 
-    pub fn map_format(&self, format: wgt::TextureFormat) -> metal::MTLPixelFormat {
-        use metal::MTLPixelFormat::*;
+    pub fn map_format(&self, format: wgt::TextureFormat) -> MTLPixelFormat {
         use wgt::TextureFormat as Tf;
+        use MTLPixelFormat::*;
         match format {
             Tf::R8Unorm => R8Unorm,
             Tf::R8Snorm => R8Snorm,
@@ -1229,10 +1229,10 @@ impl super::PrivateCapabilities {
         &self,
         format: wgt::TextureFormat,
         aspects: crate::FormatAspects,
-    ) -> metal::MTLPixelFormat {
+    ) -> MTLPixelFormat {
         use crate::FormatAspects as Fa;
-        use metal::MTLPixelFormat::*;
         use wgt::TextureFormat as Tf;
+        use MTLPixelFormat::*;
         match (format, aspects) {
             // map combined depth-stencil format to their stencil-only format
             // see https://developer.apple.com/library/archive/documentation/Miscellaneous/Conceptual/MetalProgrammingGuide/WhatsNewiniOS10tvOS10andOSX1012/WhatsNewiniOS10tvOS10andOSX1012.html#//apple_ref/doc/uid/TP40014221-CH14-DontLinkElementID_77

wgpu-hal/src/metal/command.rs

@@ -5,6 +5,10 @@ use alloc::{
     vec::Vec,
 };
 use core::ops::Range;
+use metal::{
+    MTLIndexType, MTLLoadAction, MTLPrimitiveType, MTLScissorRect, MTLSize, MTLStoreAction,
+    MTLViewport, MTLVisibilityResultMode, NSRange,
+};
 
 // has to match `Temp::binding_sizes`
 const WORD_SIZE: usize = 4;
@@ -15,9 +19,9 @@ impl Default for super::CommandState {
             blit: None,
             render: None,
             compute: None,
-            raw_primitive_type: metal::MTLPrimitiveType::Point,
+            raw_primitive_type: MTLPrimitiveType::Point,
             index: None,
-            raw_wg_size: metal::MTLSize::new(0, 0, 0),
+            raw_wg_size: MTLSize::new(0, 0, 0),
             stage_infos: Default::default(),
             storage_buffer_length_map: Default::default(),
             vertex_buffer_size_map: Default::default(),
@@ -81,7 +85,7 @@ impl super::CommandEncoder {
                     // As explained above, we need to do some write:
                     // Conveniently, we have a buffer with every query set, that we can use for this for a dummy write,
                     // since we know that it is going to be overwritten again on timer resolve and HAL doesn't define its state before that.
-                    let raw_range = metal::NSRange {
+                    let raw_range = NSRange {
                         location: last_query.as_ref().unwrap().1 as u64 * crate::QUERY_SIZE,
                         length: 1,
                     };
@@ -413,7 +417,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
                     .as_ref()
                     .unwrap()
                     .set_visibility_result_mode(
-                        metal::MTLVisibilityResultMode::Boolean,
+                        MTLVisibilityResultMode::Boolean,
                         index as u64 * crate::QUERY_SIZE,
                     );
             }
@@ -427,7 +431,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
                     .render
                     .as_ref()
                     .unwrap()
-                    .set_visibility_result_mode(metal::MTLVisibilityResultMode::Disabled, 0);
+                    .set_visibility_result_mode(MTLVisibilityResultMode::Disabled, 0);
             }
             _ => {}
         }
@@ -473,7 +477,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
 
     unsafe fn reset_queries(&mut self, set: &super::QuerySet, range: Range<u32>) {
         let encoder = self.enter_blit();
-        let raw_range = metal::NSRange {
+        let raw_range = NSRange {
             location: range.start as u64 * crate::QUERY_SIZE,
             length: (range.end - range.start) as u64 * crate::QUERY_SIZE,
         };
@@ -503,7 +507,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
             wgt::QueryType::Timestamp => {
                 encoder.resolve_counters(
                     set.counter_sample_buffer.as_ref().unwrap(),
-                    metal::NSRange::new(range.start as u64, (range.end - range.start) as u64),
+                    NSRange::new(range.start as u64, (range.end - range.start) as u64),
                     &buffer.raw,
                     offset,
                 );
@@ -540,10 +544,10 @@ impl crate::CommandEncoder for super::CommandEncoder {
                         at_descriptor.set_resolve_texture(Some(&resolve.view.raw));
                     }
                     let load_action = if at.ops.contains(crate::AttachmentOps::LOAD) {
-                        metal::MTLLoadAction::Load
+                        MTLLoadAction::Load
                     } else {
                         at_descriptor.set_clear_color(conv::map_clear_color(&at.clear_value));
-                        metal::MTLLoadAction::Clear
+                        MTLLoadAction::Clear
                     };
                     let store_action = conv::map_store_action(
                         at.ops.contains(crate::AttachmentOps::STORE),
@@ -560,15 +564,15 @@ impl crate::CommandEncoder for super::CommandEncoder {
                     at_descriptor.set_texture(Some(&at.target.view.raw));
 
                     let load_action = if at.depth_ops.contains(crate::AttachmentOps::LOAD) {
-                        metal::MTLLoadAction::Load
+                        MTLLoadAction::Load
                     } else {
                         at_descriptor.set_clear_depth(at.clear_value.0 as f64);
-                        metal::MTLLoadAction::Clear
+                        MTLLoadAction::Clear
                     };
                     let store_action = if at.depth_ops.contains(crate::AttachmentOps::STORE) {
-                        metal::MTLStoreAction::Store
+                        MTLStoreAction::Store
                     } else {
-                        metal::MTLStoreAction::DontCare
+                        MTLStoreAction::DontCare
                     };
                     at_descriptor.set_load_action(load_action);
                     at_descriptor.set_store_action(store_action);
@@ -583,15 +587,15 @@ impl crate::CommandEncoder for super::CommandEncoder {
                     at_descriptor.set_texture(Some(&at.target.view.raw));
 
                     let load_action = if at.stencil_ops.contains(crate::AttachmentOps::LOAD) {
-                        metal::MTLLoadAction::Load
+                        MTLLoadAction::Load
                     } else {
                         at_descriptor.set_clear_stencil(at.clear_value.1);
-                        metal::MTLLoadAction::Clear
+                        MTLLoadAction::Clear
                     };
                     let store_action = if at.stencil_ops.contains(crate::AttachmentOps::STORE) {
-                        metal::MTLStoreAction::Store
+                        MTLStoreAction::Store
                     } else {
-                        metal::MTLStoreAction::DontCare
+                        MTLStoreAction::DontCare
                     };
                     at_descriptor.set_load_action(load_action);
                     at_descriptor.set_store_action(store_action);
@@ -953,8 +957,8 @@ impl crate::CommandEncoder for super::CommandEncoder {
         format: wgt::IndexFormat,
     ) {
         let (stride, raw_type) = match format {
-            wgt::IndexFormat::Uint16 => (2, metal::MTLIndexType::UInt16),
-            wgt::IndexFormat::Uint32 => (4, metal::MTLIndexType::UInt32),
+            wgt::IndexFormat::Uint16 => (2, MTLIndexType::UInt16),
+            wgt::IndexFormat::Uint32 => (4, MTLIndexType::UInt32),
         };
         self.state.index = Some(super::IndexState {
             buffer_ptr: AsNative::from(binding.buffer.raw.as_ref()),
@@ -1002,7 +1006,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
             depth_range.end
         };
         let encoder = self.state.render.as_ref().unwrap();
-        encoder.set_viewport(metal::MTLViewport {
+        encoder.set_viewport(MTLViewport {
             originX: rect.x as _,
             originY: rect.y as _,
             width: rect.w as _,
@@ -1013,7 +1017,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
     }
     unsafe fn set_scissor_rect(&mut self, rect: &crate::Rect<u32>) {
         //TODO: support empty scissors by modifying the viewport
-        let scissor = metal::MTLScissorRect {
+        let scissor = MTLScissorRect {
             x: rect.x as _,
             y: rect.y as _,
             width: rect.w as _,
@@ -1301,7 +1305,7 @@ impl crate::CommandEncoder for super::CommandEncoder {
     unsafe fn dispatch(&mut self, count: [u32; 3]) {
         if count[0] > 0 && count[1] > 0 && count[2] > 0 {
             let encoder = self.state.compute.as_ref().unwrap();
-            let raw_count = metal::MTLSize {
+            let raw_count = MTLSize {
                 width: count[0] as u64,
                 height: count[1] as u64,
                 depth: count[2] as u64,