From ebefd025f7a0bd7cba2e2f8f3465a4a3736c83dd Mon Sep 17 00:00:00 2001 From: Raph Levien Date: Wed, 26 May 2021 19:08:56 -0700 Subject: [PATCH] Fix up merge Update signatures to match changes to backend trait, and add new types and stub methods to complete mux abstraction. --- piet-gpu-hal/src/macros.rs | 24 ++++++ piet-gpu-hal/src/metal.rs | 146 +++++++++++++++++++------------------ piet-gpu-hal/src/mux.rs | 129 ++++++++++++++++++++++++++++++++ 3 files changed, 230 insertions(+), 69 deletions(-) diff --git a/piet-gpu-hal/src/macros.rs b/piet-gpu-hal/src/macros.rs index f1d7019..98178e2 100644 --- a/piet-gpu-hal/src/macros.rs +++ b/piet-gpu-hal/src/macros.rs @@ -25,6 +25,10 @@ macro_rules! mux_cfg { ( #[cfg(dx12)] $($tokens:tt)* ) => { #[cfg(target_os="windows")] $( $tokens )* }; + + ( #[cfg(mtl)] $($tokens:tt)* ) => { + #[cfg(target_os="macos")] $( $tokens )* + }; } #[macro_export] @@ -32,12 +36,15 @@ macro_rules! mux_enum { ( $(#[$outer:meta])* $v:vis enum $name:ident { Vk($vk:ty), Dx12($dx12:ty), + Mtl($mtl:ty), } ) => { $(#[$outer])* $v enum $name { #[cfg(not(target_os="macos"))] Vk($vk), #[cfg(target_os="windows")] Dx12($dx12), + #[cfg(target_os="macos")] + Mtl($mtl), } impl $name { @@ -62,6 +69,17 @@ macro_rules! mux_enum { } } } + + $crate::mux_cfg! { + #[cfg(mtl)] + #[allow(unused)] + fn mtl(&self) -> &$mtl { + match self { + $name::Mtl(x) => x, + _ => panic!("downcast error") + } + } + } } }; } @@ -73,6 +91,7 @@ macro_rules! mux_device_enum { pub enum $assoc_type { Vk(<$crate::vulkan::VkDevice as $crate::Device>::$assoc_type), Dx12(<$crate::dx12::Dx12Device as $crate::Device>::$assoc_type), + Mtl(<$crate::metal::MtlDevice as $crate::Device>::$assoc_type), } } } @@ -83,22 +102,27 @@ macro_rules! mux_match { ( $e:expr ; $vkname:ident::Vk($vkvar:ident) => $vkblock: block $dx12name:ident::Dx12($dx12var:ident) => $dx12block: block + $mtlname:ident::Mtl($mtlvar:ident) => $mtlblock: block ) => { match $e { #[cfg(not(target_os="macos"))] $vkname::Vk($vkvar) => $vkblock #[cfg(target_os="windows")] $dx12name::Dx12($dx12var) => $dx12block + #[cfg(target_os="macos")] + $mtlname::Mtl($mtlvar) => $mtlblock } }; ( $e:expr ; $vkname:ident::Vk($vkvar:ident) => $vkblock: expr, $dx12name:ident::Dx12($dx12var:ident) => $dx12block: expr, + $mtlname:ident::Mtl($mtlvar:ident) => $mtlblock: expr, ) => { $crate::mux_match! { $e; $vkname::Vk($vkvar) => { $vkblock } $dx12name::Dx12($dx12var) => { $dx12block } + $mtlname::Mtl($mtlvar) => { $mtlblock } } }; } diff --git a/piet-gpu-hal/src/metal.rs b/piet-gpu-hal/src/metal.rs index e8e67bb..f9d67cc 100644 --- a/piet-gpu-hal/src/metal.rs +++ b/piet-gpu-hal/src/metal.rs @@ -14,17 +14,22 @@ // // Also licensed under MIT license, at your choice. -use crate::Error; +use crate::{BufferUsage, Error}; -use bitflags::bitflags; +pub struct MtlInstance; -pub struct MetalInstance; - -pub struct MetalDevice { +pub struct MtlDevice { device: metal::Device, } -pub struct Buffer(metal::Buffer); +pub struct MtlSurface; + +pub struct MtlSwapchain; + +pub struct Buffer { + buffer: metal::Buffer, + pub(crate) size: u64, +} pub struct Image; @@ -36,19 +41,6 @@ pub struct Fence; pub struct Semaphore; -// This is the new direction of how I want this to go, and will -// move it to crate level. It's very similar to wgpu's BufferUsage. -bitflags! { - pub struct MemFlags: u32 { - const MAP_READ = 1; - const MAP_WRITE = 2; - const COPY_SRC = 4; - const COPY_DST = 8; - const STORAGE = 128; - } -} - - pub struct CmdBuf; pub struct QueryPool; @@ -57,29 +49,39 @@ pub struct PipelineBuilder; pub struct DescriptorSetBuilder; -impl MetalInstance { - pub fn new() -> MetalInstance { - MetalInstance +impl MtlInstance { + pub fn new( + window_handle: Option<&dyn raw_window_handle::HasRawWindowHandle>, + ) -> Result<(MtlInstance, Option), Error> { + Ok((MtlInstance, None)) } // TODO might do some enumeration of devices - pub fn device(&self) -> Result { + pub fn device(&self, surface: Option<&MtlSurface>) -> Result { if let Some(device) = metal::Device::system_default() { - Ok(MetalDevice { device }) + Ok(MtlDevice { device }) } else { Err("can't create system default Metal device".into()) } } + + pub unsafe fn swapchain( + &self, + width: usize, + height: usize, + device: &MtlDevice, + surface: &MtlSurface, + ) -> Result { + todo!() + } } -impl crate::Device for MetalDevice { +impl crate::Device for MtlDevice { type Buffer = Buffer; type Image = Image; - type MemFlags = MemFlags; - type Pipeline = Pipeline; type DescriptorSet = DescriptorSet; @@ -98,20 +100,22 @@ impl crate::Device for MetalDevice { type Sampler = (); + type ShaderSource = str; + fn query_gpu_info(&self) -> crate::GpuInfo { todo!() } - fn create_buffer(&self, size: u64, mem_flags: Self::MemFlags) -> Result { - let options = if mem_flags.contains(MemFlags::MAP_READ) { + fn create_buffer(&self, size: u64, usage: BufferUsage) -> Result { + let options = if usage.contains(BufferUsage::MAP_READ) { metal::MTLResourceOptions::StorageModeShared | metal::MTLResourceOptions::CPUCacheModeDefaultCache - } else if mem_flags.contains(MemFlags::MAP_WRITE) { + } else if usage.contains(BufferUsage::MAP_WRITE) { metal::MTLResourceOptions::StorageModeShared | metal::MTLResourceOptions::CPUCacheModeWriteCombined } else { metal::MTLResourceOptions::StorageModePrivate }; let buffer = self.device.new_buffer(size, options); - Ok(Buffer(buffer)) + Ok(Buffer { buffer, size }) } unsafe fn destroy_buffer(&self, buffer: &Self::Buffer) -> Result<(), Error> { @@ -122,7 +126,6 @@ impl crate::Device for MetalDevice { &self, width: u32, height: u32, - mem_flags: Self::MemFlags, ) -> Result { todo!() } @@ -151,46 +154,43 @@ impl crate::Device for MetalDevice { todo!() } - unsafe fn run_cmd_buf( + unsafe fn run_cmd_bufs( &self, - cmd_buf: &Self::CmdBuf, - wait_semaphores: &[Self::Semaphore], - signal_semaphores: &[Self::Semaphore], + cmd_bufs: &[&Self::CmdBuf], + wait_semaphores: &[&Self::Semaphore], + signal_semaphores: &[&Self::Semaphore], fence: Option<&Self::Fence>, ) -> Result<(), Error> { todo!() } - unsafe fn read_buffer( + unsafe fn read_buffer( &self, buffer: &Self::Buffer, - result: &mut Vec, + dst: *mut u8, + offset: u64, + size: u64, ) -> Result<(), Error> { - let contents_ptr = buffer.0.contents(); + let contents_ptr = buffer.buffer.contents(); if contents_ptr.is_null() { return Err("probably trying to read from private buffer".into()); } - let len = buffer.0.length() as usize / std::mem::size_of::(); - if len > result.len() { - result.reserve(len - result.len()); - } - std::ptr::copy_nonoverlapping(contents_ptr as *const T, result.as_mut_ptr(), len); - result.set_len(len); + std::ptr::copy_nonoverlapping((contents_ptr as *const u8).add(offset as usize), dst, size as usize); Ok(()) } - unsafe fn write_buffer( + unsafe fn write_buffer( &self, - buffer: &Self::Buffer, - contents: &[T], + buffer: &Buffer, + contents: *const u8, + offset: u64, + size: u64, ) -> Result<(), Error> { - let contents_ptr = buffer.0.contents(); + let contents_ptr = buffer.buffer.contents(); if contents_ptr.is_null() { return Err("probably trying to write to private buffer".into()); } - let len = buffer.0.length() as usize / std::mem::size_of::(); - assert!(len >= contents.len()); - std::ptr::copy_nonoverlapping(contents.as_ptr(), contents_ptr as *mut T, len); + std::ptr::copy_nonoverlapping(contents, (contents_ptr as *mut u8).add(offset as usize), size as usize); Ok(()) } @@ -202,11 +202,11 @@ impl crate::Device for MetalDevice { todo!() } - unsafe fn wait_and_reset(&self, fences: &[Self::Fence]) -> Result<(), Error> { + unsafe fn wait_and_reset(&self, fences: &[&Self::Fence]) -> Result<(), Error> { todo!() } - unsafe fn get_fence_status(&self, fence: Self::Fence) -> Result { + unsafe fn get_fence_status(&self, fence: &Self::Fence) -> Result { todo!() } @@ -215,17 +215,7 @@ impl crate::Device for MetalDevice { } } -impl crate::MemFlags for MemFlags { - fn device_local() -> Self { - MemFlags::COPY_SRC | MemFlags::COPY_DST | MemFlags::STORAGE - } - - fn host_coherent() -> Self { - MemFlags::device_local() | MemFlags::MAP_READ | MemFlags::MAP_WRITE - } -} - -impl crate::CmdBuf for CmdBuf { +impl crate::CmdBuf for CmdBuf { unsafe fn begin(&mut self) { todo!() } @@ -289,7 +279,7 @@ impl crate::CmdBuf for CmdBuf { } } -impl crate::PipelineBuilder for PipelineBuilder { +impl crate::PipelineBuilder for PipelineBuilder { fn add_buffers(&mut self, n_buffers: u32) { todo!() } @@ -302,12 +292,12 @@ impl crate::PipelineBuilder for PipelineBuilder { todo!() } - unsafe fn create_compute_pipeline(self, device: &MetalDevice, code: &[u8]) -> Result { + unsafe fn create_compute_pipeline(self, device: &MtlDevice, code: &str) -> Result { todo!() } } -impl crate::DescriptorSetBuilder for DescriptorSetBuilder { +impl crate::DescriptorSetBuilder for DescriptorSetBuilder { fn add_buffers(&mut self, buffers: &[&Buffer]) { todo!() } @@ -320,7 +310,25 @@ impl crate::DescriptorSetBuilder for DescriptorSetBuilder { todo!() } - unsafe fn build(self, device: &MetalDevice, pipeline: &Pipeline) -> Result { + unsafe fn build(self, device: &MtlDevice, pipeline: &Pipeline) -> Result { todo!() } +} + +impl MtlSwapchain { + pub unsafe fn next(&mut self) -> Result<(usize, Semaphore), Error> { + todo!() + } + + pub unsafe fn image(&self, idx: usize) -> Image { + todo!() + } + + pub unsafe fn present( + &self, + image_idx: usize, + semaphores: &[&Semaphore], + ) -> Result { + todo!() + } } \ No newline at end of file diff --git a/piet-gpu-hal/src/mux.rs b/piet-gpu-hal/src/mux.rs index 0971416..9e13a87 100644 --- a/piet-gpu-hal/src/mux.rs +++ b/piet-gpu-hal/src/mux.rs @@ -26,6 +26,10 @@ mux_cfg! { #[cfg(dx12)] use crate::dx12; } +mux_cfg! { + #[cfg(mtl)] + use crate::metal; +} use crate::CmdBuf as CmdBufTrait; use crate::DescriptorSetBuilder as DescriptorSetBuilderTrait; use crate::Device as DeviceTrait; @@ -37,6 +41,7 @@ mux_enum! { pub enum Instance { Vk(vulkan::VkInstance), Dx12(dx12::Dx12Instance), + Mtl(metal::MtlInstance), } } @@ -45,6 +50,7 @@ mux_enum! { pub enum Device { Vk(vulkan::VkDevice), Dx12(dx12::Dx12Device), + Mtl(metal::MtlDevice), } } @@ -53,6 +59,7 @@ mux_enum! { pub enum Surface { Vk(vulkan::VkSurface), Dx12(dx12::Dx12Surface), + Mtl(metal::MtlSurface), } } @@ -61,6 +68,7 @@ mux_enum! { pub enum Swapchain { Vk(vulkan::VkSwapchain), Dx12(dx12::Dx12Swapchain), + Mtl(metal::MtlSwapchain), } } @@ -78,8 +86,12 @@ mux_device_enum! { Sampler } /// The code for a shader, either as source or intermediate representation. pub enum ShaderCode<'a> { + /// SPIR-V (binary intermediate representation) Spv(&'a [u8]), + /// HLSL (source) Hlsl(&'a str), + /// Metal Shading Language (source) + Msl(&'a str), } impl Instance { @@ -111,6 +123,15 @@ impl Instance { } } } + mux_cfg! { + #[cfg(mtl)] + { + let result = metal::MtlInstance::new(window_handle); + if let Ok((instance, surface)) = result { + return Ok((Instance::Mtl(instance), surface.map(Surface::Mtl))); + } + } + } // TODO plumb creation errors through. Err("No suitable instances found".into()) } @@ -124,6 +145,7 @@ impl Instance { mux_match! { self; Instance::Vk(i) => i.device(surface.map(Surface::vk)).map(Device::Vk), Instance::Dx12(i) => i.device(surface.map(Surface::dx12)).map(Device::Dx12), + Instance::Mtl(i) => i.device(surface.map(Surface::mtl)).map(Device::Mtl), } } @@ -147,6 +169,9 @@ impl Instance { Instance::Dx12(i) => i .swapchain(width, height, device.dx12(), surface.dx12()) .map(Swapchain::Dx12), + Instance::Mtl(i) => i + .swapchain(width, height, device.mtl(), surface.mtl()) + .map(Swapchain::Mtl), } } } @@ -159,6 +184,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.query_gpu_info(), Device::Dx12(d) => d.query_gpu_info(), + Device::Mtl(d) => d.query_gpu_info(), } } @@ -166,6 +192,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_buffer(size, usage).map(Buffer::Vk), Device::Dx12(d) => d.create_buffer(size, usage).map(Buffer::Dx12), + Device::Mtl(d) => d.create_buffer(size, usage).map(Buffer::Mtl), } } @@ -173,6 +200,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.destroy_buffer(buffer.vk()), Device::Dx12(d) => d.destroy_buffer(buffer.dx12()), + Device::Mtl(d) => d.destroy_buffer(buffer.mtl()), } } @@ -180,6 +208,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_image2d(width, height).map(Image::Vk), Device::Dx12(d) => d.create_image2d(width, height).map(Image::Dx12), + Device::Mtl(d) => d.create_image2d(width, height).map(Image::Mtl), } } @@ -187,6 +216,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.destroy_image(image.vk()), Device::Dx12(d) => d.destroy_image(image.dx12()), + Device::Mtl(d) => d.destroy_image(image.mtl()), } } @@ -194,6 +224,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_fence(signaled).map(Fence::Vk), Device::Dx12(d) => d.create_fence(signaled).map(Fence::Dx12), + Device::Mtl(d) => d.create_fence(signaled).map(Fence::Mtl), } } @@ -215,6 +246,14 @@ impl Device { .collect::>(); d.wait_and_reset(&*fences) } + Device::Mtl(d) => { + let fences = fences + .iter() + .copied() + .map(Fence::mtl) + .collect::>(); + d.wait_and_reset(&*fences) + } } } @@ -222,6 +261,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.get_fence_status(fence.vk()), Device::Dx12(d) => d.get_fence_status(fence.dx12()), + Device::Mtl(d) => d.get_fence_status(fence.mtl()), } } @@ -229,6 +269,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_semaphore().map(Semaphore::Vk), Device::Dx12(d) => d.create_semaphore().map(Semaphore::Dx12), + Device::Mtl(d) => d.create_semaphore().map(Semaphore::Mtl), } } @@ -236,6 +277,7 @@ impl Device { mux_match! { self; Device::Vk(d) => PipelineBuilder::Vk(d.pipeline_builder()), Device::Dx12(d) => PipelineBuilder::Dx12(d.pipeline_builder()), + Device::Mtl(d) => PipelineBuilder::Mtl(d.pipeline_builder()), } } @@ -243,6 +285,7 @@ impl Device { mux_match! { self; Device::Vk(d) => DescriptorSetBuilder::Vk(d.descriptor_set_builder()), Device::Dx12(d) => DescriptorSetBuilder::Dx12(d.descriptor_set_builder()), + Device::Mtl(d) => DescriptorSetBuilder::Mtl(d.descriptor_set_builder()), } } @@ -250,6 +293,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_cmd_buf().map(CmdBuf::Vk), Device::Dx12(d) => d.create_cmd_buf().map(CmdBuf::Dx12), + Device::Mtl(d) => d.create_cmd_buf().map(CmdBuf::Mtl), } } @@ -257,6 +301,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.create_query_pool(n_queries).map(QueryPool::Vk), Device::Dx12(d) => d.create_query_pool(n_queries).map(QueryPool::Dx12), + Device::Mtl(d) => d.create_query_pool(n_queries).map(QueryPool::Mtl), } } @@ -264,6 +309,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.fetch_query_pool(pool.vk()), Device::Dx12(d) => d.fetch_query_pool(pool.dx12()), + Device::Mtl(d) => d.fetch_query_pool(pool.mtl()), } } @@ -309,6 +355,23 @@ impl Device { .collect::>(), fence.map(Fence::dx12), ), + Device::Mtl(d) => d.run_cmd_bufs( + &cmd_bufs + .iter() + .map(|c| c.mtl()) + .collect::>(), + &wait_semaphores + .iter() + .copied() + .map(Semaphore::mtl) + .collect::>(), + &signal_semaphores + .iter() + .copied() + .map(Semaphore::mtl) + .collect::>(), + fence.map(Fence::mtl), + ), } } @@ -322,6 +385,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.read_buffer(buffer.vk(), dst, offset, size), Device::Dx12(d) => d.read_buffer(buffer.dx12(), dst, offset, size), + Device::Mtl(d) => d.read_buffer(buffer.mtl(), dst, offset, size), } } @@ -335,6 +399,7 @@ impl Device { mux_match! { self; Device::Vk(d) => d.write_buffer(buffer.vk(), contents, offset, size), Device::Dx12(d) => d.write_buffer(buffer.dx12(), contents, offset, size), + Device::Mtl(d) => d.write_buffer(buffer.mtl(), contents, offset, size), } } } @@ -344,6 +409,7 @@ impl PipelineBuilder { mux_match! { self; PipelineBuilder::Vk(x) => x.add_buffers(n_buffers), PipelineBuilder::Dx12(x) => x.add_buffers(n_buffers), + PipelineBuilder::Mtl(x) => x.add_buffers(n_buffers), } } @@ -351,6 +417,7 @@ impl PipelineBuilder { mux_match! { self; PipelineBuilder::Vk(x) => x.add_images(n_buffers), PipelineBuilder::Dx12(x) => x.add_images(n_buffers), + PipelineBuilder::Mtl(x) => x.add_images(n_buffers), } } @@ -358,6 +425,7 @@ impl PipelineBuilder { mux_match! { self; PipelineBuilder::Vk(x) => x.add_textures(n_buffers), PipelineBuilder::Dx12(x) => x.add_textures(n_buffers), + PipelineBuilder::Mtl(x) => x.add_textures(n_buffers), } } @@ -385,6 +453,15 @@ impl PipelineBuilder { x.create_compute_pipeline(device.dx12(), shader_code) .map(Pipeline::Dx12) } + PipelineBuilder::Mtl(x) => { + let shader_code = match code { + ShaderCode::Msl(msl) => msl, + // Panic or return "incompatible shader" error here? + _ => panic!("Metal backend requires shader code in MSL format"), + }; + x.create_compute_pipeline(device.mtl(), shader_code) + .map(Pipeline::Mtl) + } } } } @@ -406,6 +483,13 @@ impl DescriptorSetBuilder { .map(Buffer::dx12) .collect::>(), ), + DescriptorSetBuilder::Mtl(x) => x.add_buffers( + &buffers + .iter() + .copied() + .map(Buffer::mtl) + .collect::>(), + ), } } @@ -425,6 +509,13 @@ impl DescriptorSetBuilder { .map(Image::dx12) .collect::>(), ), + DescriptorSetBuilder::Mtl(x) => x.add_images( + &images + .iter() + .copied() + .map(Image::mtl) + .collect::>(), + ), } } @@ -444,6 +535,13 @@ impl DescriptorSetBuilder { .map(Image::dx12) .collect::>(), ), + DescriptorSetBuilder::Mtl(x) => x.add_textures( + &images + .iter() + .copied() + .map(Image::mtl) + .collect::>(), + ), } } @@ -458,6 +556,9 @@ impl DescriptorSetBuilder { DescriptorSetBuilder::Dx12(x) => x .build(device.dx12(), pipeline.dx12()) .map(DescriptorSet::Dx12), + DescriptorSetBuilder::Mtl(x) => x + .build(device.mtl(), pipeline.mtl()) + .map(DescriptorSet::Mtl), } } } @@ -467,6 +568,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.begin(), CmdBuf::Dx12(c) => c.begin(), + CmdBuf::Mtl(c) => c.begin(), } } @@ -474,6 +576,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.finish(), CmdBuf::Dx12(c) => c.finish(), + CmdBuf::Mtl(c) => c.finish(), } } @@ -486,6 +589,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.dispatch(pipeline.vk(), descriptor_set.vk(), size), CmdBuf::Dx12(c) => c.dispatch(pipeline.dx12(), descriptor_set.dx12(), size), + CmdBuf::Mtl(c) => c.dispatch(pipeline.mtl(), descriptor_set.mtl(), size), } } @@ -493,6 +597,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.memory_barrier(), CmdBuf::Dx12(c) => c.memory_barrier(), + CmdBuf::Mtl(c) => c.memory_barrier(), } } @@ -500,6 +605,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.host_barrier(), CmdBuf::Dx12(c) => c.host_barrier(), + CmdBuf::Mtl(c) => c.host_barrier(), } } @@ -512,6 +618,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.image_barrier(image.vk(), src_layout, dst_layout), CmdBuf::Dx12(c) => c.image_barrier(image.dx12(), src_layout, dst_layout), + CmdBuf::Mtl(c) => c.image_barrier(image.mtl(), src_layout, dst_layout), } } @@ -519,6 +626,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.clear_buffer(buffer.vk(), size), CmdBuf::Dx12(c) => c.clear_buffer(buffer.dx12(), size), + CmdBuf::Mtl(c) => c.clear_buffer(buffer.mtl(), size), } } @@ -526,6 +634,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.copy_buffer(src.vk(), dst.vk()), CmdBuf::Dx12(c) => c.copy_buffer(src.dx12(), dst.dx12()), + CmdBuf::Mtl(c) => c.copy_buffer(src.mtl(), dst.mtl()), } } @@ -533,6 +642,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.copy_image_to_buffer(src.vk(), dst.vk()), CmdBuf::Dx12(c) => c.copy_image_to_buffer(src.dx12(), dst.dx12()), + CmdBuf::Mtl(c) => c.copy_image_to_buffer(src.mtl(), dst.mtl()), } } @@ -540,6 +650,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.copy_buffer_to_image(src.vk(), dst.vk()), CmdBuf::Dx12(c) => c.copy_buffer_to_image(src.dx12(), dst.dx12()), + CmdBuf::Mtl(c) => c.copy_buffer_to_image(src.mtl(), dst.mtl()), } } @@ -547,6 +658,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.blit_image(src.vk(), dst.vk()), CmdBuf::Dx12(c) => c.blit_image(src.dx12(), dst.dx12()), + CmdBuf::Mtl(c) => c.blit_image(src.mtl(), dst.mtl()), } } @@ -554,6 +666,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.reset_query_pool(pool.vk()), CmdBuf::Dx12(c) => c.reset_query_pool(pool.dx12()), + CmdBuf::Mtl(c) => c.reset_query_pool(pool.mtl()), } } @@ -561,6 +674,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.write_timestamp(pool.vk(), query), CmdBuf::Dx12(c) => c.write_timestamp(pool.dx12(), query), + CmdBuf::Mtl(c) => c.write_timestamp(pool.mtl(), query), } } @@ -568,6 +682,7 @@ impl CmdBuf { mux_match! { self; CmdBuf::Vk(c) => c.finish_timestamps(pool.vk()), CmdBuf::Dx12(c) => c.finish_timestamps(pool.dx12()), + CmdBuf::Mtl(c) => c.finish_timestamps(pool.mtl()), } } } @@ -577,6 +692,7 @@ impl Buffer { mux_match! { self; Buffer::Vk(b) => b.size, Buffer::Dx12(b) => b.size, + Buffer::Mtl(b) => b.size, } } } @@ -592,6 +708,10 @@ impl Swapchain { let (idx, sem) = s.next()?; Ok((idx, Semaphore::Dx12(sem))) } + Swapchain::Mtl(s) => { + let (idx, sem) = s.next()?; + Ok((idx, Semaphore::Mtl(sem))) + } } } @@ -599,6 +719,7 @@ impl Swapchain { mux_match! { self; Swapchain::Vk(s) => Image::Vk(s.image(idx)), Swapchain::Dx12(s) => Image::Dx12(s.image(idx)), + Swapchain::Mtl(s) => Image::Mtl(s.image(idx)), } } @@ -624,6 +745,14 @@ impl Swapchain { .map(Semaphore::dx12) .collect::>(), ), + Swapchain::Mtl(s) => s.present( + image_idx, + &semaphores + .iter() + .copied() + .map(Semaphore::mtl) + .collect::>(), + ), } } }