From 943f2a726e210bbeab3ea6fd4bc821f407c4917d Mon Sep 17 00:00:00 2001 From: Mads Marquart Date: Wed, 22 May 2024 00:14:21 +0200 Subject: [PATCH] Use normal objc2 naming scheme --- Cargo.lock | 21 ++- Cargo.toml | 7 - wgpu-hal/src/metal/adapter.rs | 83 ++++++----- wgpu-hal/src/metal/command.rs | 264 +++++++++++++++++----------------- wgpu-hal/src/metal/device.rs | 199 +++++++++++++------------ wgpu-hal/src/metal/mod.rs | 14 +- wgpu-hal/src/metal/surface.rs | 26 ++-- 7 files changed, 303 insertions(+), 311 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 1c87b39c45..5c04d38052 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -365,7 +365,8 @@ dependencies = [ [[package]] name = "block2" version = "0.5.1" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f" dependencies = [ "objc2 0.5.2", ] @@ -2480,7 +2481,8 @@ dependencies = [ [[package]] name = "objc-sys" version = "0.3.5" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310" [[package]] name = "objc2" @@ -2495,7 +2497,8 @@ dependencies = [ [[package]] name = "objc2" version = "0.5.2" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804" dependencies = [ "objc-sys", "objc2-encode 4.0.3", @@ -2510,12 +2513,14 @@ checksum = "d079845b37af429bfe5dfa76e6d087d788031045b25cfc6fd898486fd9847666" [[package]] name = "objc2-encode" version = "4.0.3" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7891e71393cd1f227313c9379a26a584ff3d7e6e7159e988851f0934c993f0f8" [[package]] name = "objc2-foundation" version = "0.2.2" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8" dependencies = [ "bitflags 2.5.0", "block2 0.5.1", @@ -2526,7 +2531,8 @@ dependencies = [ [[package]] name = "objc2-metal" version = "0.2.2" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6" dependencies = [ "bitflags 2.5.0", "block2 0.5.1", @@ -2537,7 +2543,8 @@ dependencies = [ [[package]] name = "objc2-quartz-core" version = "0.2.2" -source = "git+https://github.com/madsmtm/objc2?branch=metal-wgpu#ecdcf28682a5307412f33620874faa87199d662c" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a" dependencies = [ "bitflags 2.5.0", "block2 0.5.1", diff --git a/Cargo.toml b/Cargo.toml index 3a8814a699..7d142df640 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -192,13 +192,6 @@ termcolor = "1.4.1" #web-sys = { path = "../wasm-bindgen/crates/web-sys" } #js-sys = { path = "../wasm-bindgen/crates/js-sys" } #wasm-bindgen = { path = "../wasm-bindgen" } -block2 = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc2 = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc2-encode = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc-sys = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc2-foundation = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc2-quartz-core = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } -objc2-metal = { git = "https://github.com/madsmtm/objc2", branch = "metal-wgpu" } [profile.release] lto = "thin" diff --git a/wgpu-hal/src/metal/adapter.rs b/wgpu-hal/src/metal/adapter.rs index ce1b36214b..fc6af74db7 100644 --- a/wgpu-hal/src/metal/adapter.rs +++ b/wgpu-hal/src/metal/adapter.rs @@ -34,7 +34,7 @@ impl crate::Adapter for super::Adapter { .shared .device .lock() - .new_command_queue_with_max_command_buffer_count(MAX_COMMAND_BUFFERS) + .newCommandQueueWithMaxCommandBufferCount(MAX_COMMAND_BUFFERS) .unwrap(); // Acquiring the meaning of timestamp ticks is hard with Metal! @@ -489,7 +489,7 @@ impl super::PrivateCapabilities { features_sets .iter() .cloned() - .any(|x| raw.supports_feature_set(x)) + .any(|x| raw.supportsFeatureSet(x)) } pub fn new(device: &ProtocolObject) -> Self { @@ -523,27 +523,27 @@ impl super::PrivateCapabilities { let version = NSProcessInfo::processInfo().operatingSystemVersion(); - let os_is_mac = device.supports_feature_set(MTLFeatureSet::_macOS_GPUFamily1_v1); + let os_is_mac = device.supportsFeatureSet(MTLFeatureSet::_macOS_GPUFamily1_v1); // Metal was first introduced in OS X 10.11 and iOS 8. The current version number of visionOS is 1.0.0. Additionally, // on the Simulator, Apple only provides the Apple2 GPU capability, and the Apple2+ GPU capability covers the capabilities of Apple2. // Therefore, the following conditions can be used to determine if it is visionOS. // https://developer.apple.com/documentation/metal/developing_metal_apps_that_run_in_simulator - let os_is_xr = version.majorVersion < 8 && device.supports_family(MTLGPUFamily::Apple2); + let os_is_xr = version.majorVersion < 8 && device.supportsFamily(MTLGPUFamily::Apple2); let family_check = os_is_xr || version.at_least((10, 15), (13, 0), os_is_mac); let mut sample_count_mask = crate::TextureFormatCapabilities::MULTISAMPLE_X4; // 1 and 4 samples are supported on all devices - if device.supports_texture_sample_count(2) { + if device.supportsTextureSampleCount(2) { sample_count_mask |= crate::TextureFormatCapabilities::MULTISAMPLE_X2; } - if device.supports_texture_sample_count(8) { + if device.supportsTextureSampleCount(8) { sample_count_mask |= crate::TextureFormatCapabilities::MULTISAMPLE_X8; } - if device.supports_texture_sample_count(16) { + if device.supportsTextureSampleCount(16) { sample_count_mask |= crate::TextureFormatCapabilities::MULTISAMPLE_X16; } let rw_texture_tier = if version.at_least((10, 13), (11, 0), os_is_mac) { - device.read_write_texture_support() + device.readWriteTextureSupport() } else if version.at_least((10, 12), OS_NOT_SUPPORT, os_is_mac) { if Self::supports_any(device, &[MTLFeatureSet::_macOS_ReadWriteTextureTier2]) { MTLReadWriteTextureTier::MTLReadWriteTextureTier2 @@ -556,18 +556,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(MTLCounterSamplingPoint::AtStageBoundary) + && device.supportsCounterSampling(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(MTLCounterSamplingPoint::AtDrawBoundary) { + if device.supportsCounterSampling(MTLCounterSamplingPoint::AtDrawBoundary) { timestamp_query_support.insert(TimestampQuerySupport::ON_RENDER_ENCODER); } - if device.supports_counter_sampling(MTLCounterSamplingPoint::AtDispatchBoundary) { + if device.supportsCounterSampling(MTLCounterSamplingPoint::AtDispatchBoundary) { timestamp_query_support.insert(TimestampQuerySupport::ON_COMPUTE_ENCODER); } - if device.supports_counter_sampling(MTLCounterSamplingPoint::AtBlitBoundary) { + if device.supportsCounterSampling(MTLCounterSamplingPoint::AtBlitBoundary) { timestamp_query_support.insert(TimestampQuerySupport::ON_BLIT_ENCODER); } // `TimestampQuerySupport::INSIDE_WGPU_PASSES` emerges from the other flags. @@ -601,11 +601,11 @@ impl super::PrivateCapabilities { read_write_texture_tier: rw_texture_tier, msaa_desktop: os_is_mac, msaa_apple3: if family_check { - device.supports_family(MTLGPUFamily::Apple3) + device.supportsFamily(MTLGPUFamily::Apple3) } else { - device.supports_feature_set(MTLFeatureSet::_iOS_GPUFamily3_v4) + device.supportsFeatureSet(MTLFeatureSet::_iOS_GPUFamily3_v4) }, - msaa_apple7: family_check && device.supports_family(MTLGPUFamily::Apple7), + msaa_apple7: family_check && device.supportsFamily(MTLGPUFamily::Apple7), resource_heaps: Self::supports_any(device, RESOURCE_HEAP_SUPPORT), argument_buffers: Self::supports_any(device, ARGUMENT_BUFFER_SUPPORT), shared_textures: !os_is_mac, @@ -620,17 +620,16 @@ impl super::PrivateCapabilities { BASE_VERTEX_FIRST_INSTANCE_SUPPORT, ), dual_source_blending: Self::supports_any(device, DUAL_SOURCE_BLEND_SUPPORT), - low_power: !os_is_mac || device.is_low_power(), - headless: os_is_mac && device.is_headless(), + low_power: !os_is_mac || device.isLowPower(), + headless: os_is_mac && device.isHeadless(), layered_rendering: Self::supports_any(device, LAYERED_RENDERING_SUPPORT), function_specialization: Self::supports_any(device, FUNCTION_SPECIALIZATION_SUPPORT), depth_clip_mode: Self::supports_any(device, DEPTH_CLIP_MODE), texture_cube_array: Self::supports_any(device, TEXTURE_CUBE_ARRAY_SUPPORT), supports_float_filtering: os_is_mac || (version.at_least((11, 0), (14, 0), os_is_mac) - && device.supports32_bit_float_filtering()), - format_depth24_stencil8: os_is_mac - && device.is_depth24_stencil8_pixel_format_supported(), + && device.supports32BitFloatFiltering()), + format_depth24_stencil8: os_is_mac && device.isDepth24Stencil8PixelFormatSupported(), format_depth32_stencil8_filter: os_is_mac, format_depth32_stencil8_none: !os_is_mac, format_min_srgb_channels: if os_is_mac { 4 } else { 1 }, @@ -638,12 +637,12 @@ impl super::PrivateCapabilities { format_bc: os_is_mac, format_eac_etc: !os_is_mac // M1 in macOS supports EAC/ETC2 - || (family_check && device.supports_family(MTLGPUFamily::Apple7)), + || (family_check && device.supportsFamily(MTLGPUFamily::Apple7)), // A8(Apple2) and later always support ASTC pixel formats - format_astc: (family_check && device.supports_family(MTLGPUFamily::Apple2)) + format_astc: (family_check && device.supportsFamily(MTLGPUFamily::Apple2)) || Self::supports_any(device, ASTC_PIXEL_FORMAT_FEATURES), // A13(Apple6) M1(Apple7) and later always support HDR ASTC pixel formats - format_astc_hdr: family_check && device.supports_family(MTLGPUFamily::Apple6), + format_astc_hdr: family_check && device.supportsFamily(MTLGPUFamily::Apple6), format_any8_unorm_srgb_all: Self::supports_any(device, ANY8_UNORM_SRGB_ALL), format_any8_unorm_srgb_no_write: !Self::supports_any(device, ANY8_UNORM_SRGB_ALL) && !os_is_mac, @@ -698,10 +697,10 @@ impl super::PrivateCapabilities { max_buffers_per_stage: 31, max_vertex_buffers: 31.min(crate::MAX_VERTEX_BUFFERS as u32), max_textures_per_stage: if os_is_mac - || (family_check && device.supports_family(MTLGPUFamily::Apple6)) + || (family_check && device.supportsFamily(MTLGPUFamily::Apple6)) { 128 - } else if family_check && device.supports_family(MTLGPUFamily::Apple4) { + } else if family_check && device.supportsFamily(MTLGPUFamily::Apple4) { 96 } else { 31 @@ -710,7 +709,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+ - device.max_buffer_length() as u64 + device.maxBufferLength() as u64 } else if os_is_mac { 1 << 30 // 1GB on macOS 10.11 and up } else { @@ -731,7 +730,7 @@ impl super::PrivateCapabilities { max_texture_3d_size: 2048, max_texture_layers: 2048, max_fragment_input_components: if os_is_mac - || device.supports_feature_set(MTLFeatureSet::_iOS_GPUFamily4_v1) + || device.supportsFeatureSet(MTLFeatureSet::_iOS_GPUFamily4_v1) { 124 } else { @@ -750,13 +749,13 @@ impl super::PrivateCapabilities { 4 }, // Per https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf - max_color_attachment_bytes_per_sample: if device.supports_family(MTLGPUFamily::Apple4) { + max_color_attachment_bytes_per_sample: if device.supportsFamily(MTLGPUFamily::Apple4) { 64 } else { 32 }, max_varying_components: if device - .supports_feature_set(MTLFeatureSet::_macOS_GPUFamily1_v1) + .supportsFeatureSet(MTLFeatureSet::_macOS_GPUFamily1_v1) { 124 } else { @@ -794,8 +793,8 @@ impl super::PrivateCapabilities { ], ), supports_binary_archives: family_check - && (device.supports_family(MTLGPUFamily::Apple3) - || device.supports_family(MTLGPUFamily::Mac1)), + && (device.supportsFamily(MTLGPUFamily::Apple3) + || device.supportsFamily(MTLGPUFamily::Mac1)), supports_capture_manager: version.at_least((10, 13), (11, 0), os_is_mac), can_set_maximum_drawables_count: version.at_least((10, 14), (11, 2), os_is_mac), can_set_display_sync: version.at_least((10, 13), OS_NOT_SUPPORT, os_is_mac), @@ -809,30 +808,30 @@ impl super::PrivateCapabilities { ], ), supports_arrays_of_textures_write: family_check - && (device.supports_family(MTLGPUFamily::Apple6) - || device.supports_family(MTLGPUFamily::Mac1) - || device.supports_family(MTLGPUFamily::MacCatalyst1)), + && (device.supportsFamily(MTLGPUFamily::Apple6) + || device.supportsFamily(MTLGPUFamily::Mac1) + || device.supportsFamily(MTLGPUFamily::MacCatalyst1)), supports_mutability: version.at_least((10, 13), (11, 0), os_is_mac), //Depth clipping is supported on all macOS GPU families and iOS family 4 and later supports_depth_clip_control: os_is_mac - || device.supports_feature_set(MTLFeatureSet::_iOS_GPUFamily4_v1), + || device.supportsFeatureSet(MTLFeatureSet::_iOS_GPUFamily4_v1), supports_preserve_invariance: version.at_least((11, 0), (13, 0), os_is_mac), // Metal 2.2 on mac, 2.3 on iOS. supports_shader_primitive_index: version.at_least((10, 15), (14, 0), os_is_mac), has_unified_memory: if version.at_least((10, 15), (13, 0), os_is_mac) { - Some(device.has_unified_memory()) + Some(device.hasUnifiedMemory()) } else { None }, timestamp_query_support, supports_simd_scoped_operations: family_check - && (device.supports_family(MTLGPUFamily::Metal3) - || device.supports_family(MTLGPUFamily::Mac2) - || device.supports_family(MTLGPUFamily::Apple7)), + && (device.supportsFamily(MTLGPUFamily::Metal3) + || device.supportsFamily(MTLGPUFamily::Mac2) + || device.supportsFamily(MTLGPUFamily::Apple7)), // https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf#page=5 int64: family_check - && (device.supports_family(MTLGPUFamily::Apple3) - || device.supports_family(MTLGPUFamily::Metal3)), + && (device.supportsFamily(MTLGPUFamily::Apple3) + || device.supportsFamily(MTLGPUFamily::Metal3)), } } @@ -1177,7 +1176,7 @@ impl super::PrivateDisabilities { let is_intel = device.name().to_string().starts_with("Intel"); Self { broken_viewport_near_depth: is_intel - && !device.supports_feature_set(MTLFeatureSet::_macOS_GPUFamily1_v4), + && !device.supportsFeatureSet(MTLFeatureSet::_macOS_GPUFamily1_v4), broken_layered_clear_image: is_intel, } } diff --git a/wgpu-hal/src/metal/command.rs b/wgpu-hal/src/metal/command.rs index 8721048a12..7e0686909a 100644 --- a/wgpu-hal/src/metal/command.rs +++ b/wgpu-hal/src/metal/command.rs @@ -71,20 +71,20 @@ impl super::CommandEncoder { for (i, (set, index)) in self.state.pending_timer_queries.drain(..).enumerate() { let sba_descriptor = descriptor - .sample_buffer_attachments() - .object_at_indexed_subscript(i); + .sampleBufferAttachments() + .objectAtIndexedSubscript(i); sba_descriptor - .set_sample_buffer(Some(set.counter_sample_buffer.as_ref().unwrap())); + .setSampleBuffer(Some(set.counter_sample_buffer.as_ref().unwrap())); // Here be dragons: // As mentioned above, for some reasons using the start of the encoder won't yield any results sometimes! - sba_descriptor.set_start_of_encoder_sample_index(MTLCounterDontSample); - sba_descriptor.set_end_of_encoder_sample_index(index as _); + sba_descriptor.setStartOfEncoderSampleIndex(MTLCounterDontSample); + sba_descriptor.setEndOfEncoderSampleIndex(index as _); last_query = Some((set, index)); } let encoder = cmd_buf - .blit_command_encoder_with_descriptor(&descriptor) + .blitCommandEncoderWithDescriptor(&descriptor) .unwrap(); // As explained above, we need to do some write: @@ -95,18 +95,18 @@ impl super::CommandEncoder { * crate::QUERY_SIZE as usize, length: 1, }; - encoder.fill_buffer_range_value( + encoder.fillBuffer_range_value( &last_query.as_ref().unwrap().0.raw_buffer, raw_range, 255, // Don't write 0, so it's easier to identify if something went wrong. ); - encoder.end_encoding(); + encoder.endEncoding(); }); } objc2::rc::autoreleasepool(|_| { - self.state.blit = Some(cmd_buf.blit_command_encoder().unwrap()); + self.state.blit = Some(cmd_buf.blitCommandEncoder().unwrap()); }); let encoder = self.state.blit.as_ref().unwrap(); @@ -116,7 +116,7 @@ impl super::CommandEncoder { for (set, index) in self.state.pending_timer_queries.drain(..) { debug_assert!(supports_sample_counters_in_buffer); unsafe { - encoder.sample_counters_in_buffer_at_sample_index_with_barrier( + encoder.sampleCountersInBuffer_atSampleIndex_withBarrier( set.counter_sample_buffer.as_ref().unwrap(), index as _, true, @@ -129,7 +129,7 @@ impl super::CommandEncoder { pub(super) fn leave_blit(&mut self) { if let Some(encoder) = self.state.blit.take() { - encoder.end_encoding(); + encoder.endEncoding(); } } @@ -193,13 +193,13 @@ impl crate::CommandEncoder for super::CommandEncoder { let retain_references = self.shared.settings.retain_command_buffer_references; let raw = objc2::rc::autoreleasepool(move |_| { let cmd_buf_ref = if retain_references { - queue.command_buffer() + queue.commandBuffer() } else { - queue.command_buffer_with_unretained_references() + queue.commandBufferWithUnretainedReferences() } .unwrap(); if let Some(label) = label { - cmd_buf_ref.set_label(Some(&NSString::from_str(label))); + cmd_buf_ref.setLabel(Some(&NSString::from_str(label))); } cmd_buf_ref.to_owned() }); @@ -214,10 +214,10 @@ impl crate::CommandEncoder for super::CommandEncoder { // when discarding, we don't have a guarantee that // everything is in a good state, so check carefully if let Some(encoder) = self.state.render.take() { - encoder.end_encoding(); + encoder.endEncoding(); } if let Some(encoder) = self.state.compute.take() { - encoder.end_encoding(); + encoder.endEncoding(); } self.raw_cmd_buf = None; } @@ -260,7 +260,7 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn clear_buffer(&mut self, buffer: &super::Buffer, range: crate::MemoryRange) { let encoder = self.enter_blit(); - encoder.fill_buffer_range_value(&buffer.raw, conv::map_range(&range), 0); + encoder.fillBuffer_range_value(&buffer.raw, conv::map_range(&range), 0); } unsafe fn copy_buffer_to_buffer( @@ -273,7 +273,7 @@ impl crate::CommandEncoder for super::CommandEncoder { { let encoder = self.enter_blit(); for copy in regions { - encoder.copy_from_buffer_source_offset_to_buffer_destination_offset_size( + encoder.copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size( &src.raw, copy.src_offset as usize, &dst.raw, @@ -295,9 +295,7 @@ impl crate::CommandEncoder for super::CommandEncoder { let dst_texture = if src.format != dst.format { let raw_format = self.shared.private_caps.map_format(src.format); Cow::Owned(objc2::rc::autoreleasepool(|_| { - dst.raw - .new_texture_view_with_pixel_format(raw_format) - .unwrap() + dst.raw.newTextureViewWithPixelFormat(raw_format).unwrap() })) } else { Cow::Borrowed(&dst.raw) @@ -308,7 +306,7 @@ impl crate::CommandEncoder for super::CommandEncoder { let dst_origin = conv::map_origin(©.dst_base.origin); // no clamping is done: Metal expects physical sizes here let extent = conv::map_copy_extent(©.size); - encoder.copy_from_texture_source_slice_source_level_source_origin_source_size_to_texture_destination_slice_destination_level_destination_origin( + encoder.copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin( &src.raw, copy.src_base.array_layer as usize, copy.src_base.mip_level as usize, @@ -349,7 +347,7 @@ impl crate::CommandEncoder for super::CommandEncoder { // the amount of data to copy. 0 }; - encoder.copy_from_buffer_source_offset_source_bytes_per_row_source_bytes_per_image_source_size_to_texture_destination_slice_destination_level_destination_origin_options( + encoder.copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options( &src.raw, copy.buffer_layout.offset as usize, bytes_per_row as usize, @@ -386,7 +384,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .buffer_layout .rows_per_image .map_or(0, |v| v as u64 * bytes_per_row); - encoder.copy_from_texture_source_slice_source_level_source_origin_source_size_to_buffer_destination_offset_destination_bytes_per_row_destination_bytes_per_image_options( + encoder.copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options( &src.raw, copy.texture_base.array_layer as usize, copy.texture_base.mip_level as usize, @@ -408,7 +406,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .render .as_ref() .unwrap() - .set_visibility_result_mode_offset( + .setVisibilityResultMode_offset( MTLVisibilityResultMode::Boolean, index as usize * crate::QUERY_SIZE as usize, ); @@ -423,7 +421,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .render .as_ref() .unwrap() - .set_visibility_result_mode_offset(MTLVisibilityResultMode::Disabled, 0); + .setVisibilityResultMode_offset(MTLVisibilityResultMode::Disabled, 0); } _ => {} } @@ -443,7 +441,7 @@ impl crate::CommandEncoder for super::CommandEncoder { support.contains(TimestampQuerySupport::ON_BLIT_ENCODER), self.state.blit.as_ref(), ) { - encoder.sample_counters_in_buffer_at_sample_index_with_barrier( + encoder.sampleCountersInBuffer_atSampleIndex_withBarrier( sample_buffer, index as _, with_barrier, @@ -452,7 +450,7 @@ impl crate::CommandEncoder for super::CommandEncoder { support.contains(TimestampQuerySupport::ON_RENDER_ENCODER), self.state.render.as_ref(), ) { - encoder.sample_counters_in_buffer_at_sample_index_with_barrier( + encoder.sampleCountersInBuffer_atSampleIndex_withBarrier( sample_buffer, index as _, with_barrier, @@ -461,7 +459,7 @@ impl crate::CommandEncoder for super::CommandEncoder { support.contains(TimestampQuerySupport::ON_COMPUTE_ENCODER), self.state.compute.as_ref(), ) { - encoder.sample_counters_in_buffer_at_sample_index_with_barrier( + encoder.sampleCountersInBuffer_atSampleIndex_withBarrier( sample_buffer, index as _, with_barrier, @@ -485,7 +483,7 @@ impl crate::CommandEncoder for super::CommandEncoder { location: range.start as usize * crate::QUERY_SIZE as usize, length: (range.end - range.start) as usize * crate::QUERY_SIZE as usize, }; - encoder.fill_buffer_range_value(&set.raw_buffer, raw_range, 0); + encoder.fillBuffer_range_value(&set.raw_buffer, raw_range, 0); } unsafe fn copy_query_results( @@ -500,7 +498,7 @@ impl crate::CommandEncoder for super::CommandEncoder { match set.ty { wgt::QueryType::Occlusion => { let size = (range.end - range.start) as u64 * crate::QUERY_SIZE; - encoder.copy_from_buffer_source_offset_to_buffer_destination_offset_size( + encoder.copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size( &set.raw_buffer, range.start as usize * crate::QUERY_SIZE as usize, &buffer.raw, @@ -509,7 +507,7 @@ impl crate::CommandEncoder for super::CommandEncoder { ); } wgt::QueryType::Timestamp => { - encoder.resolve_counters_in_range_destination_buffer_destination_offset( + encoder.resolveCounters_inRange_destinationBuffer_destinationOffset( set.counter_sample_buffer.as_ref().unwrap(), NSRange::new(range.start as usize, range.end as usize), &buffer.raw, @@ -535,38 +533,36 @@ impl crate::CommandEncoder for super::CommandEncoder { for (i, at) in desc.color_attachments.iter().enumerate() { if let Some(at) = at.as_ref() { - let at_descriptor = descriptor - .color_attachments() - .object_at_indexed_subscript(i); - at_descriptor.set_texture(Some(&at.target.view.raw)); + let at_descriptor = descriptor.colorAttachments().objectAtIndexedSubscript(i); + at_descriptor.setTexture(Some(&at.target.view.raw)); if let Some(ref resolve) = at.resolve_target { //Note: the selection of levels and slices is already handled by `TextureView` - at_descriptor.set_resolve_texture(Some(&resolve.view.raw)); + at_descriptor.setResolveTexture(Some(&resolve.view.raw)); } let load_action = if at.ops.contains(crate::AttachmentOps::LOAD) { MTLLoadAction::Load } else { - at_descriptor.set_clear_color(conv::map_clear_color(&at.clear_value)); + at_descriptor.setClearColor(conv::map_clear_color(&at.clear_value)); MTLLoadAction::Clear }; let store_action = conv::map_store_action( at.ops.contains(crate::AttachmentOps::STORE), at.resolve_target.is_some(), ); - at_descriptor.set_load_action(load_action); - at_descriptor.set_store_action(store_action); + at_descriptor.setLoadAction(load_action); + at_descriptor.setStoreAction(store_action); } } if let Some(ref at) = desc.depth_stencil_attachment { if at.target.view.aspects.contains(crate::FormatAspects::DEPTH) { - let at_descriptor = descriptor.depth_attachment(); - at_descriptor.set_texture(Some(&at.target.view.raw)); + let at_descriptor = descriptor.depthAttachment(); + at_descriptor.setTexture(Some(&at.target.view.raw)); let load_action = if at.depth_ops.contains(crate::AttachmentOps::LOAD) { MTLLoadAction::Load } else { - at_descriptor.set_clear_depth(at.clear_value.0 as f64); + at_descriptor.setClearDepth(at.clear_value.0 as f64); MTLLoadAction::Clear }; let store_action = if at.depth_ops.contains(crate::AttachmentOps::STORE) { @@ -574,8 +570,8 @@ impl crate::CommandEncoder for super::CommandEncoder { } else { MTLStoreAction::DontCare }; - at_descriptor.set_load_action(load_action); - at_descriptor.set_store_action(store_action); + at_descriptor.setLoadAction(load_action); + at_descriptor.setStoreAction(store_action); } if at .target @@ -583,13 +579,13 @@ impl crate::CommandEncoder for super::CommandEncoder { .aspects .contains(crate::FormatAspects::STENCIL) { - let at_descriptor = descriptor.stencil_attachment(); - at_descriptor.set_texture(Some(&at.target.view.raw)); + let at_descriptor = descriptor.stencilAttachment(); + at_descriptor.setTexture(Some(&at.target.view.raw)); let load_action = if at.stencil_ops.contains(crate::AttachmentOps::LOAD) { MTLLoadAction::Load } else { - at_descriptor.set_clear_stencil(at.clear_value.1); + at_descriptor.setClearStencil(at.clear_value.1); MTLLoadAction::Clear }; let store_action = if at.stencil_ops.contains(crate::AttachmentOps::STORE) { @@ -597,19 +593,19 @@ impl crate::CommandEncoder for super::CommandEncoder { } else { MTLStoreAction::DontCare }; - at_descriptor.set_load_action(load_action); - at_descriptor.set_store_action(store_action); + at_descriptor.setLoadAction(load_action); + at_descriptor.setStoreAction(store_action); } } let mut sba_index = 0; let mut next_sba_descriptor = || { let sba_descriptor = descriptor - .sample_buffer_attachments() - .object_at_indexed_subscript(sba_index); + .sampleBufferAttachments() + .objectAtIndexedSubscript(sba_index); - sba_descriptor.set_end_of_vertex_sample_index(MTLCounterDontSample); - sba_descriptor.set_start_of_fragment_sample_index(MTLCounterDontSample); + sba_descriptor.setEndOfVertexSampleIndex(MTLCounterDontSample); + sba_descriptor.setStartOfFragmentSampleIndex(MTLCounterDontSample); sba_index += 1; sba_descriptor @@ -617,14 +613,14 @@ impl crate::CommandEncoder for super::CommandEncoder { for (set, index) in self.state.pending_timer_queries.drain(..) { let sba_descriptor = next_sba_descriptor(); - sba_descriptor.set_sample_buffer(Some(set.counter_sample_buffer.as_ref().unwrap())); - sba_descriptor.set_start_of_vertex_sample_index(index as _); - sba_descriptor.set_end_of_fragment_sample_index(MTLCounterDontSample); + sba_descriptor.setSampleBuffer(Some(set.counter_sample_buffer.as_ref().unwrap())); + sba_descriptor.setStartOfVertexSampleIndex(index as _); + sba_descriptor.setEndOfFragmentSampleIndex(MTLCounterDontSample); } if let Some(ref timestamp_writes) = desc.timestamp_writes { let sba_descriptor = next_sba_descriptor(); - sba_descriptor.set_sample_buffer(Some( + sba_descriptor.setSampleBuffer(Some( timestamp_writes .query_set .counter_sample_buffer @@ -632,12 +628,12 @@ impl crate::CommandEncoder for super::CommandEncoder { .unwrap(), )); - sba_descriptor.set_start_of_vertex_sample_index( + sba_descriptor.setStartOfVertexSampleIndex( timestamp_writes .beginning_of_pass_write_index .map_or(MTLCounterDontSample, |i| i as _), ); - sba_descriptor.set_end_of_fragment_sample_index( + sba_descriptor.setEndOfFragmentSampleIndex( timestamp_writes .end_of_pass_write_index .map_or(MTLCounterDontSample, |i| i as _), @@ -645,23 +641,20 @@ impl crate::CommandEncoder for super::CommandEncoder { } if let Some(occlusion_query_set) = desc.occlusion_query_set { - descriptor - .set_visibility_result_buffer(Some(occlusion_query_set.raw_buffer.as_ref())) + descriptor.setVisibilityResultBuffer(Some(occlusion_query_set.raw_buffer.as_ref())) } let raw = self.raw_cmd_buf.as_ref().unwrap(); - let encoder = raw - .render_command_encoder_with_descriptor(&descriptor) - .unwrap(); + let encoder = raw.renderCommandEncoderWithDescriptor(&descriptor).unwrap(); if let Some(label) = desc.label { - encoder.set_label(Some(&NSString::from_str(label))); + encoder.setLabel(Some(&NSString::from_str(label))); } self.state.render = Some(encoder); }); } unsafe fn end_render_pass(&mut self) { - self.state.render.take().unwrap().end_encoding(); + self.state.render.take().unwrap().endEncoding(); } unsafe fn set_bind_group( @@ -681,7 +674,7 @@ impl crate::CommandEncoder for super::CommandEncoder { if let Some(dyn_index) = buf.dynamic_index { offset += dynamic_offsets[dyn_index as usize] as wgt::BufferAddress; } - encoder.setVertexBuffer_offset_atIndex_( + encoder.setVertexBuffer_offset_atIndex( Some(buf.ptr.as_ref()), offset as usize, (bg_info.base_resource_indices.vs.buffers + index) as usize, @@ -700,7 +693,7 @@ impl crate::CommandEncoder for super::CommandEncoder { naga::ShaderStage::Vertex, &mut self.temp.binding_sizes, ) { - encoder.set_vertex_bytes_length_at_index( + encoder.setVertexBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -715,7 +708,7 @@ impl crate::CommandEncoder for super::CommandEncoder { if let Some(dyn_index) = buf.dynamic_index { offset += dynamic_offsets[dyn_index as usize] as wgt::BufferAddress; } - encoder.setFragmentBuffer_offset_atIndex_( + encoder.setFragmentBuffer_offset_atIndex( Some(buf.ptr.as_ref()), offset as usize, (bg_info.base_resource_indices.fs.buffers + index) as usize, @@ -734,7 +727,7 @@ impl crate::CommandEncoder for super::CommandEncoder { naga::ShaderStage::Fragment, &mut self.temp.binding_sizes, ) { - encoder.set_fragment_bytes_length_at_index( + encoder.setFragmentBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -744,14 +737,14 @@ impl crate::CommandEncoder for super::CommandEncoder { for index in 0..group.counters.vs.samplers { let res = group.samplers[index as usize]; - encoder.set_vertex_sampler_state_at_index( + encoder.setVertexSamplerState_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.vs.samplers + index) as usize, ); } for index in 0..group.counters.fs.samplers { let res = group.samplers[(group.counters.vs.samplers + index) as usize]; - encoder.set_fragment_sampler_state_at_index( + encoder.setFragmentSamplerState_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.fs.samplers + index) as usize, ); @@ -759,14 +752,14 @@ impl crate::CommandEncoder for super::CommandEncoder { for index in 0..group.counters.vs.textures { let res = group.textures[index as usize]; - encoder.set_vertex_texture_at_index( + encoder.setVertexTexture_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.vs.textures + index) as usize, ); } for index in 0..group.counters.fs.textures { let res = group.textures[(group.counters.vs.textures + index) as usize]; - encoder.set_fragment_texture_at_index( + encoder.setFragmentTexture_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.fs.textures + index) as usize, ); @@ -787,7 +780,7 @@ impl crate::CommandEncoder for super::CommandEncoder { if let Some(dyn_index) = buf.dynamic_index { offset += dynamic_offsets[dyn_index as usize] as wgt::BufferAddress; } - encoder.setBuffer_offset_atIndex_( + encoder.setBuffer_offset_atIndex( Some(buf.ptr.as_ref()), offset as usize, (bg_info.base_resource_indices.cs.buffers + index) as usize, @@ -806,7 +799,7 @@ impl crate::CommandEncoder for super::CommandEncoder { naga::ShaderStage::Compute, &mut self.temp.binding_sizes, ) { - encoder.set_bytes_length_at_index( + encoder.setBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -816,14 +809,14 @@ impl crate::CommandEncoder for super::CommandEncoder { for index in 0..group.counters.cs.samplers { let res = group.samplers[(index_base.samplers + index) as usize]; - encoder.set_sampler_state_at_index( + encoder.setSamplerState_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.cs.samplers + index) as usize, ); } for index in 0..group.counters.cs.textures { let res = group.textures[(index_base.textures + index) as usize]; - encoder.set_texture_at_index( + encoder.setTexture_atIndex( Some(res.as_ref()), (bg_info.base_resource_indices.cs.textures + index) as usize, ); @@ -853,7 +846,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .compute .as_ref() .unwrap() - .set_bytes_length_at_index( + .setBytes_length_atIndex( bytes, layout.total_push_constants as usize * WORD_SIZE, layout.push_constants_infos.cs.unwrap().buffer_index as _, @@ -864,7 +857,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .render .as_ref() .unwrap() - .set_vertex_bytes_length_at_index( + .setVertexBytes_length_atIndex( bytes, layout.total_push_constants as usize * WORD_SIZE, layout.push_constants_infos.vs.unwrap().buffer_index as _, @@ -875,7 +868,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .render .as_ref() .unwrap() - .set_fragment_bytes_length_at_index( + .setFragmentBytes_length_atIndex( bytes, layout.total_push_constants as usize * WORD_SIZE, layout.push_constants_infos.fs.unwrap().buffer_index as _, @@ -885,21 +878,21 @@ impl crate::CommandEncoder for super::CommandEncoder { unsafe fn insert_debug_marker(&mut self, label: &str) { if let Some(encoder) = self.active_encoder() { - encoder.insert_debug_signpost(&NSString::from_str(label)); + encoder.insertDebugSignpost(&NSString::from_str(label)); } } unsafe fn begin_debug_marker(&mut self, group_label: &str) { if let Some(encoder) = self.active_encoder() { - encoder.push_debug_group(&NSString::from_str(group_label)); + encoder.pushDebugGroup(&NSString::from_str(group_label)); } else if let Some(ref buf) = self.raw_cmd_buf { - buf.push_debug_group(&NSString::from_str(group_label)); + buf.pushDebugGroup(&NSString::from_str(group_label)); } } unsafe fn end_debug_marker(&mut self) { if let Some(encoder) = self.active_encoder() { - encoder.pop_debug_group(); + encoder.popDebugGroup(); } else if let Some(ref buf) = self.raw_cmd_buf { - buf.pop_debug_group(); + buf.popDebugGroup(); } } @@ -912,16 +905,16 @@ impl crate::CommandEncoder for super::CommandEncoder { } let encoder = self.state.render.as_ref().unwrap(); - encoder.set_render_pipeline_state(&pipeline.raw); - encoder.set_front_facing_winding(pipeline.raw_front_winding); - encoder.set_cull_mode(pipeline.raw_cull_mode); - encoder.set_triangle_fill_mode(pipeline.raw_triangle_fill_mode); + encoder.setRenderPipelineState(&pipeline.raw); + encoder.setFrontFacingWinding(pipeline.raw_front_winding); + encoder.setCullMode(pipeline.raw_cull_mode); + encoder.setTriangleFillMode(pipeline.raw_triangle_fill_mode); if let Some(depth_clip) = pipeline.raw_depth_clip_mode { - encoder.set_depth_clip_mode(depth_clip); + encoder.setDepthClipMode(depth_clip); } if let Some((ref state, bias)) = pipeline.depth_stencil { - encoder.set_depth_stencil_state(Some(state)); - encoder.set_depth_bias_slope_scale_clamp( + encoder.setDepthStencilState(Some(state)); + encoder.setDepthBias_slopeScale_clamp( bias.constant as f32, bias.slope_scale, bias.clamp, @@ -933,7 +926,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .state .make_sizes_buffer_update(naga::ShaderStage::Vertex, &mut self.temp.binding_sizes) { - encoder.set_vertex_bytes_length_at_index( + encoder.setVertexBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -945,7 +938,7 @@ impl crate::CommandEncoder for super::CommandEncoder { .state .make_sizes_buffer_update(naga::ShaderStage::Fragment, &mut self.temp.binding_sizes) { - encoder.set_fragment_bytes_length_at_index( + encoder.setFragmentBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -978,7 +971,7 @@ impl crate::CommandEncoder for super::CommandEncoder { ) { let buffer_index = self.shared.private_caps.max_vertex_buffers as u64 - 1 - index as u64; let encoder = self.state.render.as_ref().unwrap(); - encoder.setVertexBuffer_offset_atIndex_( + encoder.setVertexBuffer_offset_atIndex( Some(&binding.buffer.raw), binding.offset as usize, buffer_index as usize, @@ -992,7 +985,7 @@ impl crate::CommandEncoder for super::CommandEncoder { depth_range.end }; let encoder = self.state.render.as_ref().unwrap(); - encoder.set_viewport(MTLViewport { + encoder.setViewport(MTLViewport { originX: rect.x as _, originY: rect.y as _, width: rect.w as _, @@ -1010,15 +1003,15 @@ impl crate::CommandEncoder for super::CommandEncoder { height: rect.h as _, }; let encoder = self.state.render.as_ref().unwrap(); - encoder.set_scissor_rect(scissor); + encoder.setScissorRect(scissor); } unsafe fn set_stencil_reference(&mut self, value: u32) { let encoder = self.state.render.as_ref().unwrap(); - encoder.set_stencil_front_reference_value_back_reference_value(value, value); + encoder.setStencilFrontReferenceValue_backReferenceValue(value, value); } unsafe fn set_blend_constants(&mut self, color: &[f32; 4]) { let encoder = self.state.render.as_ref().unwrap(); - encoder.set_blend_color_red_green_blue_alpha(color[0], color[1], color[2], color[3]); + encoder.setBlendColorRed_green_blue_alpha(color[0], color[1], color[2], color[3]); } unsafe fn draw( @@ -1030,7 +1023,7 @@ impl crate::CommandEncoder for super::CommandEncoder { ) { let encoder = self.state.render.as_ref().unwrap(); if first_instance != 0 { - encoder.draw_primitives_vertex_start_vertex_count_instance_count_base_instance( + encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance( self.state.raw_primitive_type, first_vertex as _, vertex_count as _, @@ -1038,14 +1031,14 @@ impl crate::CommandEncoder for super::CommandEncoder { first_instance as _, ); } else if instance_count != 1 { - encoder.draw_primitives_vertex_start_vertex_count_instance_count( + encoder.drawPrimitives_vertexStart_vertexCount_instanceCount( self.state.raw_primitive_type, first_vertex as _, vertex_count as _, instance_count as _, ); } else { - encoder.draw_primitives_vertex_start_vertex_count( + encoder.drawPrimitives_vertexStart_vertexCount( self.state.raw_primitive_type, first_vertex as _, vertex_count as _, @@ -1065,7 +1058,7 @@ impl crate::CommandEncoder for super::CommandEncoder { let index = self.state.index.as_ref().unwrap(); let offset = (index.offset + index.stride * first_index as wgt::BufferAddress) as usize; if base_vertex != 0 || first_instance != 0 { - encoder.draw_indexed_primitives_index_count_index_type_index_buffer_index_buffer_offset_instance_count_base_vertex_base_instance( + encoder.drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance( self.state.raw_primitive_type, index_count as _, index.raw_type, @@ -1076,7 +1069,7 @@ impl crate::CommandEncoder for super::CommandEncoder { first_instance as _, ); } else if instance_count != 1 { - encoder.draw_indexed_primitives_index_count_index_type_index_buffer_index_buffer_offset_instance_count( + encoder.drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount( self.state.raw_primitive_type, index_count as _, index.raw_type, @@ -1085,14 +1078,13 @@ impl crate::CommandEncoder for super::CommandEncoder { instance_count as _, ); } else { - encoder - .draw_indexed_primitives_index_count_index_type_index_buffer_index_buffer_offset( - self.state.raw_primitive_type, - index_count as _, - index.raw_type, - index.buffer_ptr.as_ref(), - offset, - ); + encoder.drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset( + self.state.raw_primitive_type, + index_count as _, + index.raw_type, + index.buffer_ptr.as_ref(), + offset, + ); } } @@ -1104,7 +1096,7 @@ impl crate::CommandEncoder for super::CommandEncoder { ) { let encoder = self.state.render.as_ref().unwrap(); for _ in 0..draw_count { - encoder.draw_primitives_indirect_buffer_indirect_buffer_offset( + encoder.drawPrimitives_indirectBuffer_indirectBufferOffset( self.state.raw_primitive_type, &buffer.raw, offset as usize, @@ -1123,7 +1115,7 @@ impl crate::CommandEncoder for super::CommandEncoder { let index = self.state.index.as_ref().unwrap(); for _ in 0..draw_count { encoder - .draw_indexed_primitives_index_type_index_buffer_index_buffer_offset_indirect_buffer_indirect_buffer_offset( + .drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset( self.state.raw_primitive_type, index.raw_type, index.buffer_ptr.as_ref(), @@ -1171,15 +1163,15 @@ impl crate::CommandEncoder for super::CommandEncoder { // TimeStamp Queries and ComputePassDescriptor were both introduced in Metal 2.3 (macOS 11, iOS 14) // and we currently only need ComputePassDescriptor for timestamp queries let encoder = if self.shared.private_caps.timestamp_query_support.is_empty() { - raw.compute_command_encoder().unwrap() + raw.computeCommandEncoder().unwrap() } else { let descriptor = MTLComputePassDescriptor::new(); let mut sba_index = 0; let mut next_sba_descriptor = || { let sba_descriptor = descriptor - .sample_buffer_attachments() - .object_at_indexed_subscript(sba_index); + .sampleBufferAttachments() + .objectAtIndexedSubscript(sba_index); sba_index += 1; sba_descriptor }; @@ -1187,14 +1179,14 @@ impl crate::CommandEncoder for super::CommandEncoder { for (set, index) in self.state.pending_timer_queries.drain(..) { let sba_descriptor = next_sba_descriptor(); sba_descriptor - .set_sample_buffer(Some(set.counter_sample_buffer.as_ref().unwrap())); - sba_descriptor.set_start_of_encoder_sample_index(index as _); - sba_descriptor.set_end_of_encoder_sample_index(MTLCounterDontSample); + .setSampleBuffer(Some(set.counter_sample_buffer.as_ref().unwrap())); + sba_descriptor.setStartOfEncoderSampleIndex(index as _); + sba_descriptor.setEndOfEncoderSampleIndex(MTLCounterDontSample); } if let Some(timestamp_writes) = desc.timestamp_writes.as_ref() { let sba_descriptor = next_sba_descriptor(); - sba_descriptor.set_sample_buffer(Some( + sba_descriptor.setSampleBuffer(Some( timestamp_writes .query_set .counter_sample_buffer @@ -1202,31 +1194,31 @@ impl crate::CommandEncoder for super::CommandEncoder { .unwrap(), )); - sba_descriptor.set_start_of_encoder_sample_index( + sba_descriptor.setStartOfEncoderSampleIndex( timestamp_writes .beginning_of_pass_write_index .map_or(MTLCounterDontSample, |i| i as _), ); - sba_descriptor.set_end_of_encoder_sample_index( + sba_descriptor.setEndOfEncoderSampleIndex( timestamp_writes .end_of_pass_write_index .map_or(MTLCounterDontSample, |i| i as _), ); } - raw.compute_command_encoder_with_descriptor(&descriptor) + raw.computeCommandEncoderWithDescriptor(&descriptor) .unwrap() }; if let Some(label) = desc.label { - encoder.set_label(Some(&NSString::from_str(label))); + encoder.setLabel(Some(&NSString::from_str(label))); } self.state.compute = Some(encoder.to_owned()); }); } unsafe fn end_compute_pass(&mut self) { - self.state.compute.take().unwrap().end_encoding(); + self.state.compute.take().unwrap().endEncoding(); } unsafe fn set_compute_pipeline(&mut self, pipeline: &super::ComputePipeline) { @@ -1234,13 +1226,13 @@ impl crate::CommandEncoder for super::CommandEncoder { self.state.stage_infos.cs.assign_from(&pipeline.cs_info); let encoder = self.state.compute.as_ref().unwrap(); - encoder.set_compute_pipeline_state(&pipeline.raw); + encoder.setComputePipelineState(&pipeline.raw); if let Some((index, sizes)) = self .state .make_sizes_buffer_update(naga::ShaderStage::Compute, &mut self.temp.binding_sizes) { - encoder.set_bytes_length_at_index( + encoder.setBytes_length_atIndex( NonNull::new(sizes.as_ptr() as *mut c_void).unwrap(), sizes.len() * WORD_SIZE, index as _, @@ -1262,7 +1254,7 @@ impl crate::CommandEncoder for super::CommandEncoder { let size = ((*pipeline_size - 1) | ALIGN_MASK) + 1; if *cur_size != size { *cur_size = size; - encoder.set_threadgroup_memory_length_at_index(size as _, index); + encoder.setThreadgroupMemoryLength_atIndex(size as _, index); } } } @@ -1274,12 +1266,16 @@ impl crate::CommandEncoder for super::CommandEncoder { height: count[1] as usize, depth: count[2] as usize, }; - encoder.dispatch_threadgroups_threads_per_threadgroup(raw_count, self.state.raw_wg_size); + encoder.dispatchThreadgroups_threadsPerThreadgroup(raw_count, self.state.raw_wg_size); } unsafe fn dispatch_indirect(&mut self, buffer: &super::Buffer, offset: wgt::BufferAddress) { let encoder = self.state.compute.as_ref().unwrap(); - encoder.dispatch_threadgroups_with_indirect_buffer_indirect_buffer_offset_threads_per_threadgroup(&buffer.raw, offset as usize, self.state.raw_wg_size); + encoder.dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup( + &buffer.raw, + offset as usize, + self.state.raw_wg_size, + ); } unsafe fn build_acceleration_structures<'a, T>( @@ -1311,7 +1307,7 @@ impl Drop for super::CommandEncoder { // appears to be a requirement for all MTLCommandEncoder objects. Failing to call // endEncoding causes a crash with the message 'Command encoder released without // endEncoding'. To prevent this, we explicitiy call discard_encoding, which - // calls end_encoding on any still-held MTLCommandEncoders. + // calls endEncoding on any still-held MTLCommandEncoders. unsafe { self.discard_encoding(); } diff --git a/wgpu-hal/src/metal/device.rs b/wgpu-hal/src/metal/device.rs index d9366cd3b6..f08a6fced0 100644 --- a/wgpu-hal/src/metal/device.rs +++ b/wgpu-hal/src/metal/device.rs @@ -49,12 +49,12 @@ fn create_stencil_desc( write_mask: u32, ) -> Retained { let desc = unsafe { MTLStencilDescriptor::new() }; - desc.set_stencil_compare_function(conv::map_compare_function(face.compare)); - desc.set_read_mask(read_mask); - desc.set_write_mask(write_mask); - desc.set_stencil_failure_operation(conv::map_stencil_op(face.fail_op)); - desc.set_depth_failure_operation(conv::map_stencil_op(face.depth_fail_op)); - desc.set_depth_stencil_pass_operation(conv::map_stencil_op(face.pass_op)); + desc.setStencilCompareFunction(conv::map_compare_function(face.compare)); + desc.setReadMask(read_mask); + desc.setWriteMask(write_mask); + desc.setStencilFailureOperation(conv::map_stencil_op(face.fail_op)); + desc.setDepthFailureOperation(conv::map_stencil_op(face.depth_fail_op)); + desc.setDepthStencilPassOperation(conv::map_stencil_op(face.pass_op)); desc } @@ -62,14 +62,14 @@ fn create_depth_stencil_desc( state: &wgt::DepthStencilState, ) -> Retained { let desc = unsafe { MTLDepthStencilDescriptor::new() }; - desc.set_depth_compare_function(conv::map_compare_function(state.depth_compare)); - desc.set_depth_write_enabled(state.depth_write_enabled); + desc.setDepthCompareFunction(conv::map_compare_function(state.depth_compare)); + desc.setDepthWriteEnabled(state.depth_write_enabled); let s = &state.stencil; if s.is_enabled() { let front_desc = create_stencil_desc(&s.front, s.read_mask, s.write_mask); - desc.set_front_face_stencil(Some(&front_desc)); + desc.setFrontFaceStencil(Some(&front_desc)); let back_desc = create_stencil_desc(&s.back, s.read_mask, s.write_mask); - desc.set_back_face_stencil(Some(&back_desc)); + desc.setBackFaceStencil(Some(&back_desc)); } desc } @@ -152,17 +152,17 @@ impl super::Device { ); let options = MTLCompileOptions::new(); - options.set_language_version(self.shared.private_caps.msl_version); + options.setLanguageVersion(self.shared.private_caps.msl_version); if self.shared.private_caps.supports_preserve_invariance { - options.set_preserve_invariance(true); + options.setPreserveInvariance(true); } let library = self .shared .device .lock() - .new_library_with_source_options_error(&NSString::from_str(&source), Some(&options)) + .newLibraryWithSource_options_error(&NSString::from_str(&source), Some(&options)) .map_err(|err| { log::warn!("Naga generated shader:\n{}", source); crate::PipelineError::Linkage(stage_bit, format!("Metal: {}", err)) @@ -185,7 +185,7 @@ impl super::Device { }; let function = library - .new_function_with_name(&NSString::from_str(ep_name)) + .newFunctionWithName(&NSString::from_str(ep_name)) .ok_or_else(|| { log::error!("Function '{ep_name}' does not exist"); crate::PipelineError::EntryPoint(naga_stage) @@ -256,8 +256,8 @@ impl super::Device { while immutable_mask != 0 { let slot = immutable_mask.trailing_zeros(); immutable_mask ^= 1 << slot; - unsafe { buffers.object_at_indexed_subscript(slot as usize) } - .set_mutability(MTLMutability::Immutable); + unsafe { buffers.objectAtIndexedSubscript(slot as usize) } + .setMutability(MTLMutability::Immutable); } } @@ -329,7 +329,7 @@ impl crate::Device for super::Device { .shared .device .lock() - .new_buffer_with_length_options(desc.size as usize, options) + .newBufferWithLength_options(desc.size as usize, options) .unwrap(); if let Some(label) = desc.label { set_buffer_label(&raw, Some(&NSString::from_str(label))); @@ -373,34 +373,34 @@ impl crate::Device for super::Device { wgt::TextureDimension::D1 => MTLTextureType::MTLTextureType1D, wgt::TextureDimension::D2 => { if desc.sample_count > 1 { - descriptor.set_sample_count(desc.sample_count as usize); + descriptor.setSampleCount(desc.sample_count as usize); MTLTextureType::MTLTextureType2DMultisample } else if desc.size.depth_or_array_layers > 1 { - descriptor.set_array_length(desc.size.depth_or_array_layers as usize); + descriptor.setArrayLength(desc.size.depth_or_array_layers as usize); MTLTextureType::MTLTextureType2DArray } else { MTLTextureType::MTLTextureType2D } } wgt::TextureDimension::D3 => { - descriptor.set_depth(desc.size.depth_or_array_layers as usize); + descriptor.setDepth(desc.size.depth_or_array_layers as usize); MTLTextureType::MTLTextureType3D } }; - descriptor.set_texture_type(mtl_type); - descriptor.set_width(desc.size.width as usize); - descriptor.set_height(desc.size.height as usize); - descriptor.set_mipmap_level_count(desc.mip_level_count as usize); - descriptor.set_pixel_format(mtl_format); - descriptor.set_usage(conv::map_texture_usage(desc.format, desc.usage)); - descriptor.set_storage_mode(MTLStorageMode::Private); + descriptor.setTextureType(mtl_type); + descriptor.setWidth(desc.size.width as usize); + descriptor.setHeight(desc.size.height as usize); + descriptor.setMipmapLevelCount(desc.mip_level_count as usize); + descriptor.setPixelFormat(mtl_format); + descriptor.setUsage(conv::map_texture_usage(desc.format, desc.usage)); + descriptor.setStorageMode(MTLStorageMode::Private); let raw = self .shared .device .lock() - .new_texture_with_descriptor(&descriptor) + .newTextureWithDescriptor(&descriptor) .ok_or(crate::DeviceError::OutOfMemory)?; if let Some(label) = desc.label { set_texture_label(&raw, Some(&NSString::from_str(label))); @@ -460,7 +460,7 @@ impl crate::Device for super::Device { objc2::rc::autoreleasepool(|_| { let raw = texture .raw - .new_texture_view_with_pixel_format_texture_type_levels_slices( + .newTextureViewWithPixelFormat_textureType_levels_slices( raw_format, raw_type, NSRange { @@ -491,9 +491,9 @@ impl crate::Device for super::Device { objc2::rc::autoreleasepool(|_| { let descriptor = MTLSamplerDescriptor::new(); - descriptor.set_min_filter(conv::map_filter_mode(desc.min_filter)); - descriptor.set_mag_filter(conv::map_filter_mode(desc.mag_filter)); - descriptor.set_mip_filter(match desc.mipmap_filter { + descriptor.setMinFilter(conv::map_filter_mode(desc.min_filter)); + descriptor.setMagFilter(conv::map_filter_mode(desc.mag_filter)); + descriptor.setMipFilter(match desc.mipmap_filter { wgt::FilterMode::Nearest if desc.lod_clamp == (0.0..0.0) => { MTLSamplerMipFilter::NotMipmapped } @@ -502,46 +502,46 @@ impl crate::Device for super::Device { }); let [s, t, r] = desc.address_modes; - descriptor.set_s_address_mode(conv::map_address_mode(s)); - descriptor.set_t_address_mode(conv::map_address_mode(t)); - descriptor.set_r_address_mode(conv::map_address_mode(r)); + descriptor.setSAddressMode(conv::map_address_mode(s)); + descriptor.setTAddressMode(conv::map_address_mode(t)); + descriptor.setRAddressMode(conv::map_address_mode(r)); // Anisotropy is always supported on mac up to 16x - descriptor.set_max_anisotropy(desc.anisotropy_clamp as _); + descriptor.setMaxAnisotropy(desc.anisotropy_clamp as _); - descriptor.set_lod_min_clamp(desc.lod_clamp.start); - descriptor.set_lod_max_clamp(desc.lod_clamp.end); + descriptor.setLodMinClamp(desc.lod_clamp.start); + descriptor.setLodMaxClamp(desc.lod_clamp.end); if let Some(fun) = desc.compare { - descriptor.set_compare_function(conv::map_compare_function(fun)); + descriptor.setCompareFunction(conv::map_compare_function(fun)); } if let Some(border_color) = desc.border_color { if let wgt::SamplerBorderColor::Zero = border_color { if s == wgt::AddressMode::ClampToBorder { - descriptor.set_s_address_mode(MTLSamplerAddressMode::ClampToZero); + descriptor.setSAddressMode(MTLSamplerAddressMode::ClampToZero); } if t == wgt::AddressMode::ClampToBorder { - descriptor.set_t_address_mode(MTLSamplerAddressMode::ClampToZero); + descriptor.setTAddressMode(MTLSamplerAddressMode::ClampToZero); } if r == wgt::AddressMode::ClampToBorder { - descriptor.set_r_address_mode(MTLSamplerAddressMode::ClampToZero); + descriptor.setRAddressMode(MTLSamplerAddressMode::ClampToZero); } } else { - descriptor.set_border_color(conv::map_border_color(border_color)); + descriptor.setBorderColor(conv::map_border_color(border_color)); } } if let Some(label) = desc.label { - descriptor.set_label(Some(&NSString::from_str(label))); + descriptor.setLabel(Some(&NSString::from_str(label))); } let raw = self .shared .device .lock() - .new_sampler_state_with_descriptor(&descriptor) + .newSamplerStateWithDescriptor(&descriptor) .unwrap(); Ok(super::Sampler { raw }) @@ -875,10 +875,10 @@ impl crate::Device for super::Device { naga::ShaderStage::Vertex, )?; - descriptor.set_vertex_function(Some(&vs.function)); + descriptor.setVertexFunction(Some(&vs.function)); if self.shared.private_caps.supports_mutability { Self::set_buffers_mutability( - &descriptor.vertex_buffers(), + &descriptor.vertexBuffers(), vs.immutable_buffer_mask, ); } @@ -902,10 +902,10 @@ impl crate::Device for super::Device { naga::ShaderStage::Fragment, )?; - descriptor.set_fragment_function(Some(&fs.function)); + descriptor.setFragmentFunction(Some(&fs.function)); if self.shared.private_caps.supports_mutability { Self::set_buffers_mutability( - &descriptor.fragment_buffers(), + &descriptor.fragmentBuffers(), fs.immutable_buffer_mask, ); } @@ -922,39 +922,37 @@ impl crate::Device for super::Device { // TODO: This is a workaround for what appears to be a Metal validation bug // A pixel format is required even though no attachments are provided if desc.color_targets.is_empty() && desc.depth_stencil.is_none() { - descriptor.set_depth_attachment_pixel_format(MTLPixelFormat::Depth32Float); + descriptor.setDepthAttachmentPixelFormat(MTLPixelFormat::Depth32Float); } (None, None) } }; for (i, ct) in desc.color_targets.iter().enumerate() { - let at_descriptor = descriptor - .color_attachments() - .object_at_indexed_subscript(i); + let at_descriptor = descriptor.colorAttachments().objectAtIndexedSubscript(i); let ct = if let Some(color_target) = ct.as_ref() { color_target } else { - at_descriptor.set_pixel_format(MTLPixelFormat::Invalid); + at_descriptor.setPixelFormat(MTLPixelFormat::Invalid); continue; }; let raw_format = self.shared.private_caps.map_format(ct.format); - at_descriptor.set_pixel_format(raw_format); - at_descriptor.set_write_mask(conv::map_color_write(ct.write_mask)); + at_descriptor.setPixelFormat(raw_format); + at_descriptor.setWriteMask(conv::map_color_write(ct.write_mask)); if let Some(ref blend) = ct.blend { - at_descriptor.set_blending_enabled(true); + at_descriptor.setBlendingEnabled(true); let (color_op, color_src, color_dst) = conv::map_blend_component(&blend.color); let (alpha_op, alpha_src, alpha_dst) = conv::map_blend_component(&blend.alpha); - at_descriptor.set_rgb_blend_operation(color_op); - at_descriptor.set_source_rgb_blend_factor(color_src); - at_descriptor.set_destination_rgb_blend_factor(color_dst); + at_descriptor.setRgbBlendOperation(color_op); + at_descriptor.setSourceRGBBlendFactor(color_src); + at_descriptor.setDestinationRGBBlendFactor(color_dst); - at_descriptor.set_alpha_blend_operation(alpha_op); - at_descriptor.set_source_alpha_blend_factor(alpha_src); - at_descriptor.set_destination_alpha_blend_factor(alpha_dst); + at_descriptor.setAlphaBlendOperation(alpha_op); + at_descriptor.setSourceAlphaBlendFactor(alpha_src); + at_descriptor.setDestinationAlphaBlendFactor(alpha_dst); } } @@ -963,10 +961,10 @@ impl crate::Device for super::Device { let raw_format = self.shared.private_caps.map_format(ds.format); let aspects = crate::FormatAspects::from(ds.format); if aspects.contains(crate::FormatAspects::DEPTH) { - descriptor.set_depth_attachment_pixel_format(raw_format); + descriptor.setDepthAttachmentPixelFormat(raw_format); } if aspects.contains(crate::FormatAspects::STENCIL) { - descriptor.set_stencil_attachment_pixel_format(raw_format); + descriptor.setStencilAttachmentPixelFormat(raw_format); } let ds_descriptor = create_depth_stencil_desc(ds); @@ -974,7 +972,7 @@ impl crate::Device for super::Device { .shared .device .lock() - .new_depth_stencil_state_with_descriptor(&ds_descriptor) + .newDepthStencilStateWithDescriptor(&ds_descriptor) .unwrap(); Some((raw, ds.bias)) } @@ -1002,7 +1000,7 @@ impl crate::Device for super::Device { self.shared.private_caps.max_vertex_buffers as u64 - 1 - i as u64; let buffer_desc = vertex_descriptor .layouts() - .object_at_indexed_subscript(buffer_index as usize); + .objectAtIndexedSubscript(buffer_index as usize); // Metal expects the stride to be the actual size of the attributes. // The semantics of array_stride == 0 can be achieved by setting @@ -1014,44 +1012,43 @@ impl crate::Device for super::Device { .map(|attribute| attribute.offset + attribute.format.size()) .max() .unwrap_or(0); - buffer_desc.set_stride(wgt::math::align_to(stride as usize, 4)); - buffer_desc.set_step_function(MTLVertexStepFunction::Constant); - buffer_desc.set_step_rate(0); + buffer_desc.setStride(wgt::math::align_to(stride as usize, 4)); + buffer_desc.setStepFunction(MTLVertexStepFunction::Constant); + buffer_desc.setStepRate(0); } else { - buffer_desc.set_stride(vb.array_stride as usize); - buffer_desc.set_step_function(conv::map_step_mode(vb.step_mode)); + buffer_desc.setStride(vb.array_stride as usize); + buffer_desc.setStepFunction(conv::map_step_mode(vb.step_mode)); } for at in vb.attributes { let attribute_desc = vertex_descriptor .attributes() - .object_at_indexed_subscript(at.shader_location as usize); - attribute_desc.set_format(conv::map_vertex_format(at.format)); - attribute_desc.set_buffer_index(buffer_index as usize); - attribute_desc.set_offset(at.offset as usize); + .objectAtIndexedSubscript(at.shader_location as usize); + attribute_desc.setFormat(conv::map_vertex_format(at.format)); + attribute_desc.setBufferIndex(buffer_index as usize); + attribute_desc.setOffset(at.offset as usize); } } - descriptor.set_vertex_descriptor(Some(&vertex_descriptor)); + descriptor.setVertexDescriptor(Some(&vertex_descriptor)); } if desc.multisample.count != 1 { //TODO: handle sample mask #[allow(deprecated)] - descriptor.set_sample_count(desc.multisample.count as usize); - descriptor - .set_alpha_to_coverage_enabled(desc.multisample.alpha_to_coverage_enabled); + descriptor.setSampleCount(desc.multisample.count as usize); + descriptor.setAlphaToCoverageEnabled(desc.multisample.alpha_to_coverage_enabled); //descriptor.set_alpha_to_one_enabled(desc.multisample.alpha_to_one_enabled); } if let Some(name) = desc.label { - descriptor.set_label(Some(&NSString::from_str(name))); + descriptor.setLabel(Some(&NSString::from_str(name))); } let raw = self .shared .device .lock() - .new_render_pipeline_state_with_descriptor_error(&descriptor) + .newRenderPipelineStateWithDescriptor_error(&descriptor) .map_err(|e| { crate::PipelineError::Linkage( wgt::ShaderStages::VERTEX | wgt::ShaderStages::FRAGMENT, @@ -1097,7 +1094,7 @@ impl crate::Device for super::Device { MTLPrimitiveTopologyClass::Unspecified, naga::ShaderStage::Compute, )?; - descriptor.set_compute_function(Some(&cs.function)); + descriptor.setComputeFunction(Some(&cs.function)); if self.shared.private_caps.supports_mutability { Self::set_buffers_mutability(&descriptor.buffers(), cs.immutable_buffer_mask); @@ -1110,7 +1107,7 @@ impl crate::Device for super::Device { }; if let Some(name) = desc.label { - descriptor.set_label(Some(&NSString::from_str(name))); + descriptor.setLabel(Some(&NSString::from_str(name))); } let raw = @@ -1155,7 +1152,7 @@ impl crate::Device for super::Device { .shared .device .lock() - .new_buffer_with_length_options(size as usize, options) + .newBufferWithLength_options(size as usize, options) .unwrap(); if let Some(label) = desc.label { set_buffer_label(&raw_buffer, Some(&NSString::from_str(label))); @@ -1170,17 +1167,17 @@ impl crate::Device for super::Device { let size = desc.count as u64 * crate::QUERY_SIZE; let device = self.shared.device.lock(); let destination_buffer = device - .new_buffer_with_length_options(size as usize, MTLResourceOptions::empty()) + .newBufferWithLength_options(size as usize, MTLResourceOptions::empty()) .unwrap(); let csb_desc = MTLCounterSampleBufferDescriptor::new(); - csb_desc.set_storage_mode(MTLStorageMode::Shared); - csb_desc.set_sample_count(desc.count as _); + csb_desc.setStorageMode(MTLStorageMode::Shared); + csb_desc.setSampleCount(desc.count as _); if let Some(label) = desc.label { - csb_desc.set_label(&NSString::from_str(label)); + csb_desc.setLabel(&NSString::from_str(label)); } - let counter_sets = device.counter_sets().unwrap(); + let counter_sets = device.counterSets().unwrap(); let timestamp_counter = match counter_sets .iter() .find(|cs| &*cs.name() == ns_string!("timestamp")) @@ -1191,10 +1188,10 @@ impl crate::Device for super::Device { return Err(crate::DeviceError::ResourceCreationFailed); } }; - csb_desc.set_counter_set(Some(timestamp_counter)); + csb_desc.setCounterSet(Some(timestamp_counter)); let counter_sample_buffer = - match device.new_counter_sample_buffer_with_descriptor_error(&csb_desc) { + match device.newCounterSampleBufferWithDescriptor_error(&csb_desc) { Ok(buffer) => buffer, Err(err) => { log::error!("Failed to create counter sample buffer: {:?}", err); @@ -1271,20 +1268,20 @@ impl crate::Device for super::Device { return false; } let device = self.shared.device.lock(); - let shared_capture_manager = MTLCaptureManager::shared_capture_manager(); - let default_capture_scope = shared_capture_manager.new_capture_scope_with_device(&device); - shared_capture_manager.set_default_capture_scope(Some(&default_capture_scope)); + let shared_capture_manager = MTLCaptureManager::sharedCaptureManager(); + let default_capture_scope = shared_capture_manager.newCaptureScopeWithDevice(&device); + shared_capture_manager.setDefaultCaptureScope(Some(&default_capture_scope)); #[allow(deprecated)] - shared_capture_manager.start_capture_with_scope(&default_capture_scope); - default_capture_scope.begin_scope(); + shared_capture_manager.startCaptureWithScope(&default_capture_scope); + default_capture_scope.beginScope(); true } unsafe fn stop_capture(&self) { - let shared_capture_manager = MTLCaptureManager::shared_capture_manager(); - if let Some(default_capture_scope) = shared_capture_manager.default_capture_scope() { - default_capture_scope.end_scope(); + let shared_capture_manager = MTLCaptureManager::sharedCaptureManager(); + if let Some(default_capture_scope) = shared_capture_manager.defaultCaptureScope() { + default_capture_scope.endScope(); } - shared_capture_manager.stop_capture(); + shared_capture_manager.stopCapture(); } unsafe fn get_acceleration_structure_build_sizes( diff --git a/wgpu-hal/src/metal/mod.rs b/wgpu-hal/src/metal/mod.rs index e2d08d62cb..896771818d 100644 --- a/wgpu-hal/src/metal/mod.rs +++ b/wgpu-hal/src/metal/mod.rs @@ -406,11 +406,11 @@ impl crate::Queue for Queue { Some(&cmd_buf) => cmd_buf.raw.clone(), None => { let queue = self.raw.lock(); - queue.command_buffer_with_unretained_references().unwrap() + queue.commandBufferWithUnretainedReferences().unwrap() } }; - raw.set_label(Some(ns_string!("(wgpu internal) Signal"))); - raw.add_completed_handler(block.cast_mut()); + raw.setLabel(Some(ns_string!("(wgpu internal) Signal"))); + raw.addCompletedHandler(block.cast_mut()); fence.maintain(); fence.pending_command_buffers.push((value, raw.clone())); @@ -440,18 +440,18 @@ impl crate::Queue for Queue { ) -> Result<(), crate::SurfaceError> { let queue = &self.raw.lock(); objc2::rc::autoreleasepool(|_| { - let command_buffer = queue.command_buffer().unwrap(); - command_buffer.set_label(Some(ns_string!("(wgpu internal) Present"))); + let command_buffer = queue.commandBuffer().unwrap(); + command_buffer.setLabel(Some(ns_string!("(wgpu internal) Present"))); // https://developer.apple.com/documentation/quartzcore/cametallayer/1478157-presentswithtransaction?language=objc if !texture.present_with_transaction { - command_buffer.present_drawable(&texture.drawable); + command_buffer.presentDrawable(&texture.drawable); } command_buffer.commit(); if texture.present_with_transaction { - command_buffer.wait_until_scheduled(); + command_buffer.waitUntilScheduled(); texture.drawable.present(); } }); diff --git a/wgpu-hal/src/metal/surface.rs b/wgpu-hal/src/metal/surface.rs index 667cbaed86..32d766543a 100644 --- a/wgpu-hal/src/metal/surface.rs +++ b/wgpu-hal/src/metal/surface.rs @@ -194,8 +194,8 @@ impl crate::Surface for super::Surface { let drawable_size = CGSize::new(config.extent.width as f64, config.extent.height as f64); match config.composite_alpha_mode { - wgt::CompositeAlphaMode::Opaque => render_layer.set_opaque(true), - wgt::CompositeAlphaMode::PostMultiplied => render_layer.set_opaque(false), + wgt::CompositeAlphaMode::Opaque => render_layer.setOpaque(true), + wgt::CompositeAlphaMode::PostMultiplied => render_layer.setOpaque(false), _ => (), } @@ -212,25 +212,25 @@ impl crate::Surface for super::Surface { let () = msg_send![*render_layer, setFrame: bounds]; } } - render_layer.set_device(Some(&device_raw)); - render_layer.set_pixel_format(caps.map_format(config.format)); - render_layer.set_framebuffer_only(framebuffer_only); - render_layer.set_presents_with_transaction(self.present_with_transaction); + render_layer.setDevice(Some(&device_raw)); + render_layer.setPixelFormat(caps.map_format(config.format)); + render_layer.setFramebufferOnly(framebuffer_only); + render_layer.setPresentsWithTransaction(self.present_with_transaction); // opt-in to Metal EDR // EDR potentially more power used in display and more bandwidth, memory footprint. let wants_edr = config.format == wgt::TextureFormat::Rgba16Float; - if wants_edr != render_layer.wants_extended_dynamic_range_content() { - render_layer.set_wants_extended_dynamic_range_content(wants_edr); + if wants_edr != render_layer.wantsExtendedDynamicRangeContent() { + render_layer.setWantsExtendedDynamicRangeContent(wants_edr); } // this gets ignored on iOS for certain OS/device combinations (iphone5s iOS 10.3) - render_layer.set_maximum_drawable_count(config.maximum_frame_latency as usize + 1); - render_layer.set_drawable_size(drawable_size); + render_layer.setMaximumDrawableCount(config.maximum_frame_latency as usize + 1); + render_layer.setDrawableSize(drawable_size); if caps.can_set_next_drawable_timeout { - render_layer.set_allows_next_drawable_timeout(false); + render_layer.setAllowsNextDrawableTimeout(false); } if caps.can_set_display_sync { - render_layer.set_display_sync_enabled(display_sync); + render_layer.setDisplaySyncEnabled(display_sync); } Ok(()) @@ -247,7 +247,7 @@ impl crate::Surface for super::Surface { let render_layer = self.render_layer.lock(); let (drawable, texture) = match autoreleasepool(|_| { render_layer - .next_drawable() + .nextDrawable() .map(|drawable| (drawable.to_owned(), drawable.texture().to_owned())) }) { Some(pair) => pair,