diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt index e3ef26634c..d61c136270 100644 --- a/COPYRIGHT.txt +++ b/COPYRIGHT.txt @@ -432,6 +432,11 @@ Comment: meshoptimizer Copyright: 2016-2024, Arseny Kapoulkine License: Expat +Files: thirdparty/metal-cpp/* +Comment: metal-cpp +Copyright: 2024, Apple Inc. +License: Apache-2.0 + Files: thirdparty/mingw-std-threads/* Comment: mingw-std-threads Copyright: 2016, Mega Limited diff --git a/drivers/apple/foundation_helpers.h b/drivers/apple/foundation_helpers.h index db87fba96c..f07b4d5073 100644 --- a/drivers/apple/foundation_helpers.h +++ b/drivers/apple/foundation_helpers.h @@ -30,7 +30,11 @@ #pragma once +#ifdef __OBJC__ #import +#else +#include +#endif class String; template @@ -38,12 +42,20 @@ class CharStringT; using CharString = CharStringT; +template +class Span; + namespace conv { +#ifdef __OBJC__ /** * Converts a Godot String to an NSString without allocating an intermediate UTF-8 buffer. * */ NSString *to_nsstring(const String &p_str); +/** + * Converts a Godot String to an NSString without allocating an intermediate UTF-8 buffer. + * */ +NSString *to_nsstring(Span p_str); /** * Converts a Godot CharString to an NSString without allocating an intermediate UTF-8 buffer. * */ @@ -52,5 +64,24 @@ NSString *to_nsstring(const CharString &p_str); * Converts an NSString to a Godot String without allocating intermediate buffers. * */ String to_string(NSString *p_str); +#else +/** + * Converts a Godot String to an NSString without allocating an intermediate UTF-8 buffer. + * */ +NS::String *to_nsstring(const String &p_str); +/** + * Converts a Godot String to an NSString without allocating an intermediate UTF-8 buffer. + * */ +NS::String *to_nsstring(Span p_str); +/** + * Converts a Godot CharString to an NSString without allocating an intermediate UTF-8 buffer. + * */ +NS::String *to_nsstring(const CharString &p_str); +/** + * Converts an NSString to a Godot String without allocating intermediate buffers. + * */ +String to_string(NS::String *p_str); + +#endif } //namespace conv diff --git a/drivers/apple/foundation_helpers.mm b/drivers/apple/foundation_helpers.mm index 0453011b1d..df02ea2a1e 100644 --- a/drivers/apple/foundation_helpers.mm +++ b/drivers/apple/foundation_helpers.mm @@ -31,6 +31,7 @@ #import "foundation_helpers.h" #import "core/string/ustring.h" +#import "core/templates/span.h" #import @@ -42,6 +43,12 @@ NSString *to_nsstring(const String &p_str) { encoding:NSUTF32LittleEndianStringEncoding]; } +NSString *to_nsstring(Span p_str) { + return [[NSString alloc] initWithBytes:(const void *)p_str.ptr() + length:p_str.size() + encoding:NSASCIIStringEncoding]; +} + NSString *to_nsstring(const CharString &p_str) { return [[NSString alloc] initWithBytes:(const void *)p_str.ptr() length:p_str.length() diff --git a/drivers/apple_embedded/SCsub b/drivers/apple_embedded/SCsub index 7cf6599d60..59ade51e7a 100644 --- a/drivers/apple_embedded/SCsub +++ b/drivers/apple_embedded/SCsub @@ -27,6 +27,9 @@ setup_swift_builder( vulkan_dir = "#thirdparty/vulkan" env_apple_embedded.Prepend(CPPPATH=[vulkan_dir, vulkan_dir + "/include"]) +# Use bundled metal-cpp headers +env_apple_embedded.Prepend(CPPPATH=["#thirdparty/metal-cpp"]) + # Driver source files env_apple_embedded.add_source_files(env_apple_embedded.drivers_sources, "*.mm") env_apple_embedded.add_source_files(env_apple_embedded.drivers_sources, "*.swift") diff --git a/drivers/apple_embedded/display_server_apple_embedded.mm b/drivers/apple_embedded/display_server_apple_embedded.mm index b41b66e22b..0cd817541a 100644 --- a/drivers/apple_embedded/display_server_apple_embedded.mm +++ b/drivers/apple_embedded/display_server_apple_embedded.mm @@ -96,7 +96,7 @@ DisplayServerAppleEmbedded::DisplayServerAppleEmbedded(const String &p_rendering if (rendering_driver == "metal") { if (@available(iOS 14.0, *)) { layer = [GDTAppDelegateService.viewController.godotView initializeRenderingForDriver:@"metal"]; - wpd.metal.layer = (CAMetalLayer *)layer; + wpd.metal.layer = (__bridge CA::MetalLayer *)layer; rendering_context = memnew(RenderingContextDriverMetal); } else { OS::get_singleton()->alert("Metal is only supported on iOS 14.0 and later."); diff --git a/drivers/apple_embedded/os_apple_embedded.mm b/drivers/apple_embedded/os_apple_embedded.mm index 53800b6b6d..fbc610d159 100644 --- a/drivers/apple_embedded/os_apple_embedded.mm +++ b/drivers/apple_embedded/os_apple_embedded.mm @@ -51,6 +51,7 @@ #import #import #include +#include #if defined(RD_ENABLED) #include "servers/rendering/renderer_rd/renderer_compositor_rd.h" diff --git a/drivers/metal/SCsub b/drivers/metal/SCsub index 1f431b39bb..8f85363072 100644 --- a/drivers/metal/SCsub +++ b/drivers/metal/SCsub @@ -3,6 +3,9 @@ from misc.utility.scons_hints import * Import("env") +# If we're using Metal, we need metal-cpp. +env.Prepend(CPPPATH=["#thirdparty/metal-cpp/"]) + env_metal = env.Clone() # Thirdparty source files @@ -23,6 +26,11 @@ thirdparty_sources = [ ] thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources] +# Include metal-cpp +thirdparty_sources += [ + "#thirdparty/metal-cpp/metal_cpp.cpp", +] + env_metal.Prepend(CPPPATH=[thirdparty_dir, thirdparty_dir + "/include"]) env_metal.Prepend(CPPPATH=[thirdparty_spirv_headers_dir + "include/spirv/unified1"]) @@ -48,7 +56,6 @@ env_metal.Append(CCFLAGS=["-fmodules", "-fcxx-modules"]) driver_obj = [] -env_metal.add_source_files(driver_obj, "*.mm") env_metal.add_source_files(driver_obj, "*.cpp") env.drivers_sources += driver_obj diff --git a/drivers/metal/metal3_objects.cpp b/drivers/metal/metal3_objects.cpp new file mode 100644 index 0000000000..f96ead2caa --- /dev/null +++ b/drivers/metal/metal3_objects.cpp @@ -0,0 +1,1806 @@ +/**************************************************************************/ +/* metal3_objects.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +/**************************************************************************/ +/* */ +/* Portions of this code were derived from MoltenVK. */ +/* */ +/* Copyright (c) 2015-2023 The Brenwill Workshop Ltd. */ +/* (http://www.brenwill.com) */ +/* */ +/* Licensed under the Apache License, Version 2.0 (the "License"); */ +/* you may not use this file except in compliance with the License. */ +/* You may obtain a copy of the License at */ +/* */ +/* http://www.apache.org/licenses/LICENSE-2.0 */ +/* */ +/* Unless required by applicable law or agreed to in writing, software */ +/* distributed under the License is distributed on an "AS IS" BASIS, */ +/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ +/* implied. See the License for the specific language governing */ +/* permissions and limitations under the License. */ +/**************************************************************************/ + +#include "metal3_objects.h" + +#include "metal_utils.h" +#include "pixel_formats.h" +#include "rendering_device_driver_metal3.h" +#include "rendering_shader_container_metal.h" + +#include + +using namespace MTL3; + +MDCommandBuffer::MDCommandBuffer(MTL::CommandQueue *p_queue, ::RenderingDeviceDriverMetal *p_device_driver) : + _scratch(p_queue->device()), queue(p_queue) { + device_driver = p_device_driver; + type = MDCommandBufferStateType::None; + use_barriers = device_driver->use_barriers; + if (use_barriers) { + // Already validated availability if use_barriers is true. + MTL::Device *device = p_queue->device(); + NS::SharedPtr rs_desc = NS::TransferPtr(MTL::ResidencySetDescriptor::alloc()->init()); + rs_desc->setInitialCapacity(10); + rs_desc->setLabel(MTLSTR("Command Residency Set")); + NS::Error *error = nullptr; + _frame_state.rs = NS::TransferPtr(device->newResidencySet(rs_desc.get(), &error)); + CRASH_COND_MSG(error != nullptr, vformat("Failed to create residency set: %s", String(error->localizedDescription()->utf8String()))); + } +} + +void MDCommandBuffer::begin_label(const char *p_label_name, const Color &p_color) { + NS::SharedPtr s = NS::TransferPtr(NS::String::alloc()->init(p_label_name, NS::UTF8StringEncoding)); + command_buffer()->pushDebugGroup(s.get()); +} + +void MDCommandBuffer::end_label() { + command_buffer()->popDebugGroup(); +} + +void MDCommandBuffer::begin() { + DEV_ASSERT(commandBuffer.get() == nullptr && !state_begin); + state_begin = true; + bzero(pending_after_stages, sizeof(pending_after_stages)); + bzero(pending_before_queue_stages, sizeof(pending_before_queue_stages)); + binding_cache.clear(); + _scratch.reset(); + release_resources(); +} + +MDCommandBuffer::Alloc MDCommandBuffer::allocate_arg_buffer(uint32_t p_size) { + return _scratch.allocate(p_size); +} + +void MDCommandBuffer::end() { + switch (type) { + case MDCommandBufferStateType::None: + return; + case MDCommandBufferStateType::Render: + return render_end_pass(); + case MDCommandBufferStateType::Compute: + return _end_compute_dispatch(); + case MDCommandBufferStateType::Blit: + return _end_blit(); + } +} + +void MDCommandBuffer::commit() { + end(); + if (use_barriers) { + if (_scratch.is_changed()) { + Span bufs = _scratch.get_buffers(); + _frame_state.rs->addAllocations(reinterpret_cast(bufs.ptr()), bufs.size()); + _scratch.clear_changed(); + _frame_state.rs->commit(); + } + } + commandBuffer->commit(); + commandBuffer.reset(); + state_begin = false; +} + +MTL::CommandBuffer *MDCommandBuffer::command_buffer() { + DEV_ASSERT(state_begin); + if (commandBuffer.get() == nullptr) { + commandBuffer = NS::RetainPtr(queue->commandBuffer()); + if (use_barriers) { + commandBuffer->useResidencySet(_frame_state.rs.get()); + } + } + return commandBuffer.get(); +} + +void MDCommandBuffer::_encode_barrier(MTL::CommandEncoder *p_enc) { + DEV_ASSERT(p_enc); + + static const MTL::Stages empty_stages[STAGE_MAX] = { 0, 0, 0 }; + if (memcmp(&pending_before_queue_stages, empty_stages, sizeof(pending_before_queue_stages)) == 0) { + return; + } + + int stage = STAGE_MAX; + // Determine encoder type by checking if it's the current active encoder. + if (render.encoder.get() == p_enc && pending_after_stages[STAGE_RENDER] != 0) { + stage = STAGE_RENDER; + } else if (compute.encoder.get() == p_enc && pending_after_stages[STAGE_COMPUTE] != 0) { + stage = STAGE_COMPUTE; + } else if (blit.encoder.get() == p_enc && pending_after_stages[STAGE_BLIT] != 0) { + stage = STAGE_BLIT; + } + + if (stage == STAGE_MAX) { + return; + } + + p_enc->barrierAfterQueueStages(pending_after_stages[stage], pending_before_queue_stages[stage]); + pending_before_queue_stages[stage] = 0; + pending_after_stages[stage] = 0; +} + +void MDCommandBuffer::pipeline_barrier(BitField p_src_stages, + BitField p_dst_stages, + VectorView p_memory_barriers, + VectorView p_buffer_barriers, + VectorView p_texture_barriers, + VectorView p_acceleration_structure_barriers) { + MTL::Stages after_stages = convert_src_pipeline_stages_to_metal(p_src_stages); + if (after_stages == 0) { + return; + } + + MTL::Stages before_stages = convert_dst_pipeline_stages_to_metal(p_dst_stages); + if (before_stages == 0) { + return; + } + + // Encode intra-encoder memory barrier if an encoder is active for matching stages. + if (render.encoder.get() != nullptr) { + MTL::RenderStages render_after = static_cast(after_stages & (MTL::StageVertex | MTL::StageFragment)); + MTL::RenderStages render_before = static_cast(before_stages & (MTL::StageVertex | MTL::StageFragment)); + if (render_after != 0 && render_before != 0) { + render.encoder->memoryBarrier(MTL::BarrierScopeBuffers | MTL::BarrierScopeTextures, render_after, render_before); + } + } else if (compute.encoder.get() != nullptr) { + if (after_stages & MTL::StageDispatch) { + compute.encoder->memoryBarrier(MTL::BarrierScopeBuffers | MTL::BarrierScopeTextures); + } + } + // Blit encoder has no memory barrier API. + + // Also cache for inter-pass barriers based on DESTINATION stages, + // since barrierAfterQueueStages is called on the encoder that must wait. + if (before_stages & (MTL::StageVertex | MTL::StageFragment)) { + pending_after_stages[STAGE_RENDER] |= after_stages; + pending_before_queue_stages[STAGE_RENDER] |= before_stages; + } + + if (before_stages & MTL::StageDispatch) { + pending_after_stages[STAGE_COMPUTE] |= after_stages; + pending_before_queue_stages[STAGE_COMPUTE] |= before_stages; + } + + if (before_stages & MTL::StageBlit) { + pending_after_stages[STAGE_BLIT] |= after_stages; + pending_before_queue_stages[STAGE_BLIT] |= before_stages; + } +} + +void MDCommandBuffer::bind_pipeline(RDD::PipelineID p_pipeline) { + MDPipeline *p = (MDPipeline *)(p_pipeline.id); + + // End current encoder if it is a compute encoder or blit encoder, + // as they do not have a defined end boundary in the RDD like render. + if (type == MDCommandBufferStateType::Compute) { + _end_compute_dispatch(); + } else if (type == MDCommandBufferStateType::Blit) { + _end_blit(); + } + + if (p->type == MDPipelineType::Render) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + MDRenderPipeline *rp = (MDRenderPipeline *)p; + + if (render.encoder.get() == nullptr) { + // This error would happen if the render pass failed. + ERR_FAIL_NULL_MSG(render.desc.get(), "Render pass descriptor is null."); + + // This condition occurs when there are no attachments when calling render_next_subpass() + // and is due to the SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS flag. + render.desc->setDefaultRasterSampleCount(static_cast(rp->sample_count)); + + render.encoder = NS::RetainPtr(command_buffer()->renderCommandEncoder(render.desc.get())); + _encode_barrier(render.encoder.get()); + } + + if (render.pipeline != rp) { + render.dirty.set_flag((RenderState::DirtyFlag)(RenderState::DIRTY_PIPELINE | RenderState::DIRTY_RASTER)); + // Mark all uniforms as dirty, as variants of a shader pipeline may have a different entry point ABI, + // due to setting force_active_argument_buffer_resources = true for spirv_cross::CompilerMSL::Options. + // As a result, uniform sets with the same layout will generate redundant binding warnings when + // capturing a Metal frame in Xcode. + // + // If we don't mark as dirty, then some bindings will generate a validation error. + // binding_cache.clear(); + render.mark_uniforms_dirty(); + + if (render.pipeline != nullptr && render.pipeline->depth_stencil != rp->depth_stencil) { + render.dirty.set_flag(RenderState::DIRTY_DEPTH); + } + if (rp->raster_state.blend.enabled) { + render.dirty.set_flag(RenderState::DIRTY_BLEND); + } + render.pipeline = rp; + } + } else if (p->type == MDPipelineType::Compute) { + DEV_ASSERT(type == MDCommandBufferStateType::None); + type = MDCommandBufferStateType::Compute; + + if (compute.pipeline != p) { + compute.dirty.set_flag(ComputeState::DIRTY_PIPELINE); + binding_cache.clear(); + compute.mark_uniforms_dirty(); + compute.pipeline = (MDComputePipeline *)p; + } + } +} + +void MDCommandBuffer::mark_push_constants_dirty() { + switch (type) { + case MDCommandBufferStateType::Render: + render.dirty.set_flag(RenderState::DirtyFlag::DIRTY_PUSH); + break; + case MDCommandBufferStateType::Compute: + compute.dirty.set_flag(ComputeState::DirtyFlag::DIRTY_PUSH); + break; + default: + break; + } +} + +MTL::BlitCommandEncoder *MDCommandBuffer::_ensure_blit_encoder() { + switch (type) { + case MDCommandBufferStateType::None: + break; + case MDCommandBufferStateType::Render: + render_end_pass(); + break; + case MDCommandBufferStateType::Compute: + _end_compute_dispatch(); + break; + case MDCommandBufferStateType::Blit: + return blit.encoder.get(); + } + + type = MDCommandBufferStateType::Blit; + blit.encoder = NS::RetainPtr(command_buffer()->blitCommandEncoder()); + _encode_barrier(blit.encoder.get()); + + return blit.encoder.get(); +} + +void MDCommandBuffer::resolve_texture(RDD::TextureID p_src_texture, RDD::TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, RDD::TextureID p_dst_texture, RDD::TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap) { + MTL::Texture *src_tex = rid::get(p_src_texture); + MTL::Texture *dst_tex = rid::get(p_dst_texture); + + NS::SharedPtr mtlRPD = NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init()); + MTL::RenderPassColorAttachmentDescriptor *mtlColorAttDesc = mtlRPD->colorAttachments()->object(0); + mtlColorAttDesc->setLoadAction(MTL::LoadActionLoad); + mtlColorAttDesc->setStoreAction(MTL::StoreActionMultisampleResolve); + + mtlColorAttDesc->setTexture(src_tex); + mtlColorAttDesc->setResolveTexture(dst_tex); + mtlColorAttDesc->setLevel(p_src_mipmap); + mtlColorAttDesc->setSlice(p_src_layer); + mtlColorAttDesc->setResolveLevel(p_dst_mipmap); + mtlColorAttDesc->setResolveSlice(p_dst_layer); + MTL::RenderCommandEncoder *enc = get_new_render_encoder_with_descriptor(mtlRPD.get()); + enc->setLabel(MTLSTR("Resolve Image")); + enc->endEncoding(); +} + +void MDCommandBuffer::clear_color_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, const Color &p_color, const RDD::TextureSubresourceRange &p_subresources) { + MTL::Texture *src_tex = rid::get(p_texture); + + if (src_tex->parentTexture()) { + // Clear via the parent texture rather than the view. + src_tex = src_tex->parentTexture(); + } + + PixelFormats &pf = device_driver->get_pixel_formats(); + + if (pf.isDepthFormat(src_tex->pixelFormat()) || pf.isStencilFormat(src_tex->pixelFormat())) { + ERR_FAIL_MSG("invalid: depth or stencil texture format"); + } + + NS::SharedPtr desc = NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init()); + + if (p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { + MTL::RenderPassColorAttachmentDescriptor *caDesc = desc->colorAttachments()->object(0); + caDesc->setTexture(src_tex); + caDesc->setLoadAction(MTL::LoadActionClear); + caDesc->setStoreAction(MTL::StoreActionStore); + caDesc->setClearColor(MTL::ClearColor(p_color.r, p_color.g, p_color.b, p_color.a)); + + // Extract the mipmap levels that are to be updated. + uint32_t mipLvlStart = p_subresources.base_mipmap; + uint32_t mipLvlCnt = p_subresources.mipmap_count; + uint32_t mipLvlEnd = mipLvlStart + mipLvlCnt; + + uint32_t levelCount = src_tex->mipmapLevelCount(); + + // Extract the cube or array layers (slices) that are to be updated. + bool is3D = src_tex->textureType() == MTL::TextureType3D; + uint32_t layerStart = is3D ? 0 : p_subresources.base_layer; + uint32_t layerCnt = p_subresources.layer_count; + uint32_t layerEnd = layerStart + layerCnt; + + MetalFeatures const &features = device_driver->get_device_properties().features; + + // Iterate across mipmap levels and layers, and perform and empty render to clear each. + for (uint32_t mipLvl = mipLvlStart; mipLvl < mipLvlEnd; mipLvl++) { + ERR_FAIL_INDEX_MSG(mipLvl, levelCount, "mip level out of range"); + + caDesc->setLevel(mipLvl); + + // If a 3D image, we need to get the depth for each level. + if (is3D) { + layerCnt = mipmapLevelSizeFromTexture(src_tex, mipLvl).depth; + layerEnd = layerStart + layerCnt; + } + + if ((features.layeredRendering && src_tex->sampleCount() == 1) || features.multisampleLayeredRendering) { + // We can clear all layers at once. + if (is3D) { + caDesc->setDepthPlane(layerStart); + } else { + caDesc->setSlice(layerStart); + } + desc->setRenderTargetArrayLength(layerCnt); + MTL::RenderCommandEncoder *enc = get_new_render_encoder_with_descriptor(desc.get()); + enc->setLabel(MTLSTR("Clear Image")); + enc->endEncoding(); + } else { + for (uint32_t layer = layerStart; layer < layerEnd; layer++) { + if (is3D) { + caDesc->setDepthPlane(layer); + } else { + caDesc->setSlice(layer); + } + MTL::RenderCommandEncoder *enc = get_new_render_encoder_with_descriptor(desc.get()); + enc->setLabel(MTLSTR("Clear Image")); + enc->endEncoding(); + } + } + } + } +} + +void MDCommandBuffer::clear_buffer(RDD::BufferID p_buffer, uint64_t p_offset, uint64_t p_size) { + MTL::BlitCommandEncoder *blit_enc = _ensure_blit_encoder(); + const RDM::BufferInfo *buffer = (const RDM::BufferInfo *)p_buffer.id; + + blit_enc->fillBuffer(buffer->metal_buffer.get(), NS::Range(p_offset, p_size), 0); +} + +void MDCommandBuffer::clear_depth_stencil_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const RDD::TextureSubresourceRange &p_subresources) { + MTL::Texture *src_tex = rid::get(p_texture); + + if (src_tex->parentTexture()) { + // Clear via the parent texture rather than the view. + src_tex = src_tex->parentTexture(); + } + + PixelFormats &pf = device_driver->get_pixel_formats(); + + bool is_depth_format = pf.isDepthFormat(src_tex->pixelFormat()); + bool is_stencil_format = pf.isStencilFormat(src_tex->pixelFormat()); + + if (!is_depth_format && !is_stencil_format) { + ERR_FAIL_MSG("invalid: color texture format"); + } + + bool clear_depth = is_depth_format && p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT); + bool clear_stencil = is_stencil_format && p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT); + + if (clear_depth || clear_stencil) { + NS::SharedPtr desc = NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init()); + + MTL::RenderPassDepthAttachmentDescriptor *daDesc = desc->depthAttachment(); + if (clear_depth) { + daDesc->setTexture(src_tex); + daDesc->setLoadAction(MTL::LoadActionClear); + daDesc->setStoreAction(MTL::StoreActionStore); + daDesc->setClearDepth(p_depth); + } + + MTL::RenderPassStencilAttachmentDescriptor *saDesc = desc->stencilAttachment(); + if (clear_stencil) { + saDesc->setTexture(src_tex); + saDesc->setLoadAction(MTL::LoadActionClear); + saDesc->setStoreAction(MTL::StoreActionStore); + saDesc->setClearStencil(p_stencil); + } + + // Extract the mipmap levels that are to be updated. + uint32_t mipLvlStart = p_subresources.base_mipmap; + uint32_t mipLvlCnt = p_subresources.mipmap_count; + uint32_t mipLvlEnd = mipLvlStart + mipLvlCnt; + + uint32_t levelCount = src_tex->mipmapLevelCount(); + + // Extract the cube or array layers (slices) that are to be updated. + bool is3D = src_tex->textureType() == MTL::TextureType3D; + uint32_t layerStart = is3D ? 0 : p_subresources.base_layer; + uint32_t layerCnt = p_subresources.layer_count; + uint32_t layerEnd = layerStart + layerCnt; + + MetalFeatures const &features = device_driver->get_device_properties().features; + + // Iterate across mipmap levels and layers, and perform and empty render to clear each. + for (uint32_t mipLvl = mipLvlStart; mipLvl < mipLvlEnd; mipLvl++) { + ERR_FAIL_INDEX_MSG(mipLvl, levelCount, "mip level out of range"); + + if (clear_depth) { + daDesc->setLevel(mipLvl); + } + if (clear_stencil) { + saDesc->setLevel(mipLvl); + } + + // If a 3D image, we need to get the depth for each level. + if (is3D) { + layerCnt = mipmapLevelSizeFromTexture(src_tex, mipLvl).depth; + layerEnd = layerStart + layerCnt; + } + + if ((features.layeredRendering && src_tex->sampleCount() == 1) || features.multisampleLayeredRendering) { + // We can clear all layers at once. + if (is3D) { + if (clear_depth) { + daDesc->setDepthPlane(layerStart); + } + if (clear_stencil) { + saDesc->setDepthPlane(layerStart); + } + } else { + if (clear_depth) { + daDesc->setSlice(layerStart); + } + if (clear_stencil) { + saDesc->setSlice(layerStart); + } + } + desc->setRenderTargetArrayLength(layerCnt); + MTL::RenderCommandEncoder *enc = get_new_render_encoder_with_descriptor(desc.get()); + enc->setLabel(MTLSTR("Clear Image")); + enc->endEncoding(); + } else { + for (uint32_t layer = layerStart; layer < layerEnd; layer++) { + if (is3D) { + if (clear_depth) { + daDesc->setDepthPlane(layer); + } + if (clear_stencil) { + saDesc->setDepthPlane(layer); + } + } else { + if (clear_depth) { + daDesc->setSlice(layer); + } + if (clear_stencil) { + saDesc->setSlice(layer); + } + } + MTL::RenderCommandEncoder *enc = get_new_render_encoder_with_descriptor(desc.get()); + enc->setLabel(MTLSTR("Clear Image")); + enc->endEncoding(); + } + } + } + } +} + +void MDCommandBuffer::copy_buffer(RDD::BufferID p_src_buffer, RDD::BufferID p_dst_buffer, VectorView p_regions) { + const RDM::BufferInfo *src = (const RDM::BufferInfo *)p_src_buffer.id; + const RDM::BufferInfo *dst = (const RDM::BufferInfo *)p_dst_buffer.id; + + MTL::BlitCommandEncoder *enc = _ensure_blit_encoder(); + + for (uint32_t i = 0; i < p_regions.size(); i++) { + RDD::BufferCopyRegion region = p_regions[i]; + enc->copyFromBuffer(src->metal_buffer.get(), region.src_offset, + dst->metal_buffer.get(), region.dst_offset, region.size); + } +} + +void MDCommandBuffer::copy_texture(RDD::TextureID p_src_texture, RDD::TextureID p_dst_texture, VectorView p_regions) { + MTL::Texture *src = rid::get(p_src_texture); + MTL::Texture *dst = rid::get(p_dst_texture); + + MTL::BlitCommandEncoder *enc = _ensure_blit_encoder(); + PixelFormats &pf = device_driver->get_pixel_formats(); + + MTL::PixelFormat src_fmt = src->pixelFormat(); + bool src_is_compressed = pf.getFormatType(src_fmt) == MTLFormatType::Compressed; + MTL::PixelFormat dst_fmt = dst->pixelFormat(); + bool dst_is_compressed = pf.getFormatType(dst_fmt) == MTLFormatType::Compressed; + + // Validate copy. + if (src->sampleCount() != dst->sampleCount() || pf.getBytesPerBlock(src_fmt) != pf.getBytesPerBlock(dst_fmt)) { + ERR_FAIL_MSG("Cannot copy between incompatible pixel formats, such as formats of different pixel sizes, or between images with different sample counts."); + } + + // If source and destination have different formats and at least one is compressed, a temporary buffer is required. + bool need_tmp_buffer = (src_fmt != dst_fmt) && (src_is_compressed || dst_is_compressed); + if (need_tmp_buffer) { + ERR_FAIL_MSG("not implemented: copy with intermediate buffer"); + } + + if (src_fmt != dst_fmt) { + // Map the source pixel format to the dst through a texture view on the source texture. + src = src->newTextureView(dst_fmt); + } + + for (uint32_t i = 0; i < p_regions.size(); i++) { + RDD::TextureCopyRegion region = p_regions[i]; + + MTL::Size extent = MTLSizeFromVector3i(region.size); + + // If copies can be performed using direct texture-texture copying, do so. + uint32_t src_level = region.src_subresources.mipmap; + uint32_t src_base_layer = region.src_subresources.base_layer; + MTL::Size src_extent = mipmapLevelSizeFromTexture(src, src_level); + uint32_t dst_level = region.dst_subresources.mipmap; + uint32_t dst_base_layer = region.dst_subresources.base_layer; + MTL::Size dst_extent = mipmapLevelSizeFromTexture(dst, dst_level); + + // All layers may be copied at once, if the extent completely covers both images. + if (src_extent == extent && dst_extent == extent) { + enc->copyFromTexture(src, src_base_layer, src_level, + dst, dst_base_layer, dst_level, + region.src_subresources.layer_count, 1); + } else { + MTL::Origin src_origin = MTLOriginFromVector3i(region.src_offset); + MTL::Size src_size = clampMTLSize(extent, src_origin, src_extent); + uint32_t layer_count = 0; + if ((src->textureType() == MTL::TextureType3D) != (dst->textureType() == MTL::TextureType3D)) { + // In the case, the number of layers to copy is in extent.depth. Use that value, + // then clamp the depth, so we don't try to copy more than Metal will allow. + layer_count = extent.depth; + src_size.depth = 1; + } else { + layer_count = region.src_subresources.layer_count; + } + MTL::Origin dst_origin = MTLOriginFromVector3i(region.dst_offset); + + for (uint32_t layer = 0; layer < layer_count; layer++) { + // We can copy between a 3D and a 2D image easily. Just copy between + // one slice of the 2D image and one plane of the 3D image at a time. + if ((src->textureType() == MTL::TextureType3D) == (dst->textureType() == MTL::TextureType3D)) { + enc->copyFromTexture(src, src_base_layer + layer, src_level, src_origin, src_size, + dst, dst_base_layer + layer, dst_level, dst_origin); + } else if (src->textureType() == MTL::TextureType3D) { + enc->copyFromTexture(src, src_base_layer, src_level, + MTL::Origin(src_origin.x, src_origin.y, src_origin.z + layer), src_size, + dst, dst_base_layer + layer, dst_level, dst_origin); + } else { + DEV_ASSERT(dst->textureType() == MTL::TextureType3D); + enc->copyFromTexture(src, src_base_layer + layer, src_level, src_origin, src_size, + dst, dst_base_layer, dst_level, + MTL::Origin(dst_origin.x, dst_origin.y, dst_origin.z + layer)); + } + } + } + } +} + +void MDCommandBuffer::copy_buffer_to_texture(RDD::BufferID p_src_buffer, RDD::TextureID p_dst_texture, VectorView p_regions) { + _copy_texture_buffer(CopySource::Buffer, p_dst_texture, p_src_buffer, p_regions); +} + +void MDCommandBuffer::copy_texture_to_buffer(RDD::TextureID p_src_texture, RDD::BufferID p_dst_buffer, VectorView p_regions) { + _copy_texture_buffer(CopySource::Texture, p_src_texture, p_dst_buffer, p_regions); +} + +void MDCommandBuffer::_copy_texture_buffer(CopySource p_source, + RDD::TextureID p_texture, + RDD::BufferID p_buffer, + VectorView p_regions) { + const RDM::BufferInfo *buffer = (const RDM::BufferInfo *)p_buffer.id; + MTL::Texture *texture = rid::get(p_texture); + + MTL::BlitCommandEncoder *enc = _ensure_blit_encoder(); + + PixelFormats &pf = device_driver->get_pixel_formats(); + MTL::PixelFormat mtlPixFmt = texture->pixelFormat(); + + MTL::BlitOption options = MTL::BlitOptionNone; + if (pf.isPVRTCFormat(mtlPixFmt)) { + options |= MTL::BlitOptionRowLinearPVRTC; + } + + for (uint32_t i = 0; i < p_regions.size(); i++) { + RDD::BufferTextureCopyRegion region = p_regions[i]; + + uint32_t mip_level = region.texture_subresource.mipmap; + MTL::Origin txt_origin = MTL::Origin(region.texture_offset.x, region.texture_offset.y, region.texture_offset.z); + MTL::Size src_extent = mipmapLevelSizeFromTexture(texture, mip_level); + MTL::Size txt_size = clampMTLSize(MTL::Size(region.texture_region_size.x, region.texture_region_size.y, region.texture_region_size.z), + txt_origin, + src_extent); + + uint32_t buffImgWd = region.texture_region_size.x; + uint32_t buffImgHt = region.texture_region_size.y; + + NS::UInteger bytesPerRow = pf.getBytesPerRow(mtlPixFmt, buffImgWd); + NS::UInteger bytesPerImg = pf.getBytesPerLayer(mtlPixFmt, bytesPerRow, buffImgHt); + + MTL::BlitOption blit_options = options; + + if (pf.isDepthFormat(mtlPixFmt) && pf.isStencilFormat(mtlPixFmt)) { + // Don't reduce depths of 32-bit depth/stencil formats. + if (region.texture_subresource.aspect == RDD::TEXTURE_ASPECT_DEPTH) { + if (pf.getBytesPerTexel(mtlPixFmt) != 4) { + bytesPerRow -= buffImgWd; + bytesPerImg -= buffImgWd * buffImgHt; + } + blit_options |= MTL::BlitOptionDepthFromDepthStencil; + } else if (region.texture_subresource.aspect == RDD::TEXTURE_ASPECT_STENCIL) { + // The stencil component is always 1 byte per pixel. + bytesPerRow = buffImgWd; + bytesPerImg = buffImgWd * buffImgHt; + blit_options |= MTL::BlitOptionStencilFromDepthStencil; + } + } + + if (!isArrayTexture(texture->textureType())) { + bytesPerImg = 0; + } + + if (p_source == CopySource::Buffer) { + enc->copyFromBuffer(buffer->metal_buffer.get(), region.buffer_offset, bytesPerRow, bytesPerImg, txt_size, + texture, region.texture_subresource.layer, mip_level, txt_origin, blit_options); + } else { + enc->copyFromTexture(texture, region.texture_subresource.layer, mip_level, txt_origin, txt_size, + buffer->metal_buffer.get(), region.buffer_offset, bytesPerRow, bytesPerImg, blit_options); + } + } +} + +MTL::RenderCommandEncoder *MDCommandBuffer::get_new_render_encoder_with_descriptor(MTL::RenderPassDescriptor *p_desc) { + switch (type) { + case MDCommandBufferStateType::None: + break; + case MDCommandBufferStateType::Render: + render_end_pass(); + break; + case MDCommandBufferStateType::Compute: + _end_compute_dispatch(); + break; + case MDCommandBufferStateType::Blit: + _end_blit(); + break; + } + + MTL::RenderCommandEncoder *enc = command_buffer()->renderCommandEncoder(p_desc); + _encode_barrier(enc); + return enc; +} + +#pragma mark - Render Commands + +void MDCommandBuffer::render_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + + if (uint32_t new_size = p_first_set_index + p_set_count; render.uniform_sets.size() < new_size) { + uint32_t s = render.uniform_sets.size(); + render.uniform_sets.resize(new_size); + // Set intermediate values to null. + std::fill(&render.uniform_sets[s], render.uniform_sets.end().operator->(), nullptr); + } + + const MDShader *shader = (const MDShader *)p_shader.id; + DynamicOffsetLayout layout = shader->dynamic_offset_layout; + + // Clear bits for sets being bound, then OR new values. + for (uint32_t i = 0; i < p_set_count && render.dynamic_offsets != 0; i++) { + uint32_t set_index = p_first_set_index + i; + uint32_t count = layout.get_count(set_index); + if (count > 0) { + uint32_t shift = layout.get_offset_index_shift(set_index); + uint32_t mask = ((1u << (count * 4u)) - 1u) << shift; + render.dynamic_offsets &= ~mask; // Clear this set's bits + } + } + render.dynamic_offsets |= p_dynamic_offsets; + + for (size_t i = 0; i < p_set_count; ++i) { + MDUniformSet *set = (MDUniformSet *)(p_uniform_sets[i].id); + + uint32_t index = p_first_set_index + i; + if (render.uniform_sets[index] != set || layout.get_count(index) > 0) { + render.dirty.set_flag(RenderState::DIRTY_UNIFORMS); + render.uniform_set_mask |= 1ULL << index; + render.uniform_sets[index] = set; + } + } +} + +void MDCommandBuffer::render_clear_attachments(VectorView p_attachment_clears, VectorView p_rects) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + + const MDSubpass &subpass = render.get_subpass(); + + uint32_t vertex_count = p_rects.size() * 6 * subpass.view_count; + simd::float4 *vertices = ALLOCA_ARRAY(simd::float4, vertex_count); + simd::float4 clear_colors[ClearAttKey::ATTACHMENT_COUNT]; + + Size2i size = render.frameBuffer->size; + Rect2i render_area = render.clip_to_render_area({ { 0, 0 }, size }); + size = Size2i(render_area.position.x + render_area.size.width, render_area.position.y + render_area.size.height); + _populate_vertices(vertices, size, p_rects); + + ClearAttKey key; + key.sample_count = render.pass->get_sample_count(); + if (subpass.view_count > 1) { + key.enable_layered_rendering(); + } + + float depth_value = 0; + uint32_t stencil_value = 0; + + for (uint32_t i = 0; i < p_attachment_clears.size(); i++) { + RDD::AttachmentClear const &attClear = p_attachment_clears[i]; + uint32_t attachment_index; + if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { + attachment_index = attClear.color_attachment; + } else { + attachment_index = subpass.depth_stencil_reference.attachment; + } + + MDAttachment const &mda = render.pass->attachments[attachment_index]; + if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { + key.set_color_format(attachment_index, mda.format); + clear_colors[attachment_index] = { + attClear.value.color.r, + attClear.value.color.g, + attClear.value.color.b, + attClear.value.color.a + }; + } + + if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT)) { + key.set_depth_format(mda.format); + depth_value = attClear.value.depth; + } + + if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT)) { + key.set_stencil_format(mda.format); + stencil_value = attClear.value.stencil; + } + } + clear_colors[ClearAttKey::DEPTH_INDEX] = { + depth_value, + depth_value, + depth_value, + depth_value + }; + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + + MDResourceCache &cache = device_driver->get_resource_cache(); + + enc->pushDebugGroup(MTLSTR("ClearAttachments")); + enc->setRenderPipelineState(cache.get_clear_render_pipeline_state(key, nullptr)); + enc->setDepthStencilState(cache.get_depth_stencil_state( + key.is_depth_enabled(), + key.is_stencil_enabled())); + enc->setStencilReferenceValue(stencil_value); + enc->setCullMode(MTL::CullModeNone); + enc->setTriangleFillMode(MTL::TriangleFillModeFill); + enc->setDepthBias(0, 0, 0); + enc->setViewport(MTL::Viewport{ 0, 0, (double)size.width, (double)size.height, 0.0, 1.0 }); + enc->setScissorRect(MTL::ScissorRect{ 0, 0, (NS::UInteger)size.width, (NS::UInteger)size.height }); + + enc->setVertexBytes(clear_colors, sizeof(clear_colors), 0); + enc->setFragmentBytes(clear_colors, sizeof(clear_colors), 0); + enc->setVertexBytes(vertices, vertex_count * sizeof(vertices[0]), device_driver->get_metal_buffer_index_for_vertex_attribute_binding(VERT_CONTENT_BUFFER_INDEX)); + + enc->drawPrimitives(MTL::PrimitiveTypeTriangle, (NS::UInteger)0, vertex_count); + enc->popDebugGroup(); + + render.dirty.set_flag((RenderState::DirtyFlag)(RenderState::DIRTY_PIPELINE | RenderState::DIRTY_DEPTH | RenderState::DIRTY_RASTER)); + binding_cache.clear(); + render.mark_uniforms_dirty({ 0 }); // Mark index 0 dirty, if there is already a binding for index 0. + render.mark_viewport_dirty(); + render.mark_scissors_dirty(); + render.mark_vertex_dirty(); + render.mark_blend_dirty(); +} + +void MDCommandBuffer::_render_set_dirty_state() { + _render_bind_uniform_sets(); + + if (render.dirty.has_flag(RenderState::DIRTY_PUSH)) { + if (push_constant_binding != UINT32_MAX) { + render.encoder->setVertexBytes(push_constant_data, push_constant_data_len, push_constant_binding); + render.encoder->setFragmentBytes(push_constant_data, push_constant_data_len, push_constant_binding); + } + } + + MDSubpass const &subpass = render.get_subpass(); + if (subpass.view_count > 1) { + uint32_t view_range[2] = { 0, subpass.view_count }; + render.encoder->setVertexBytes(view_range, sizeof(view_range), VIEW_MASK_BUFFER_INDEX); + render.encoder->setFragmentBytes(view_range, sizeof(view_range), VIEW_MASK_BUFFER_INDEX); + } + + if (render.dirty.has_flag(RenderState::DIRTY_PIPELINE)) { + render.encoder->setRenderPipelineState(render.pipeline->state.get()); + } + + if (render.dirty.has_flag(RenderState::DIRTY_VIEWPORT)) { + render.encoder->setViewports(reinterpret_cast(render.viewports.ptr()), render.viewports.size()); + } + + if (render.dirty.has_flag(RenderState::DIRTY_DEPTH)) { + render.encoder->setDepthStencilState(render.pipeline->depth_stencil.get()); + } + + if (render.dirty.has_flag(RenderState::DIRTY_RASTER)) { + render.pipeline->raster_state.apply(render.encoder.get()); + } + + if (render.dirty.has_flag(RenderState::DIRTY_SCISSOR) && !render.scissors.is_empty()) { + size_t len = render.scissors.size(); + MTL::ScissorRect *rects = ALLOCA_ARRAY(MTL::ScissorRect, len); + for (size_t i = 0; i < len; i++) { + rects[i] = render.clip_to_render_area(render.scissors[i]); + } + render.encoder->setScissorRects(rects, len); + } + + if (render.dirty.has_flag(RenderState::DIRTY_BLEND) && render.blend_constants.has_value()) { + render.encoder->setBlendColor(render.blend_constants->r, render.blend_constants->g, render.blend_constants->b, render.blend_constants->a); + } + + if (render.dirty.has_flag(RenderState::DIRTY_VERTEX)) { + uint32_t p_binding_count = render.vertex_buffers.size(); + if (p_binding_count > 0) { + uint32_t first = device_driver->get_metal_buffer_index_for_vertex_attribute_binding(p_binding_count - 1); + render.encoder->setVertexBuffers(render.vertex_buffers.ptr(), render.vertex_offsets.ptr(), NS::Range(first, p_binding_count)); + } + } + + if (!use_barriers) { + render.resource_tracker.encode(render.encoder.get()); + } + + render.dirty.clear(); +} + +void ResourceTracker::merge_from(const ::ResourceUsageMap &p_from) { + for (KeyValue const &keyval : p_from) { + ResourceVector *resources = _current.getptr(keyval.key); + if (resources == nullptr) { + resources = &_current.insert(keyval.key, ResourceVector())->value; + } + resources->reserve(resources->size() + keyval.value.size()); + + MTL::Resource *const *keyval_ptr = (MTL::Resource *const *)(void *)keyval.value.ptr(); + + // Helper to check if a resource needs to be added based on previous usage. + auto should_add_resource = [this, usage = keyval.key](MTL::Resource *res) -> bool { + ResourceUsageEntry *existing = _previous.getptr(res); + if (existing == nullptr) { + _previous.insert(res, usage); + return true; + } + if (existing->usage != usage) { + existing->usage |= usage; + return true; + } + return false; + }; + + // 2-way merge of sorted resource lists. + uint32_t i = 0, j = 0; + while (i < resources->size() && j < keyval.value.size()) { + MTL::Resource *current_res = resources->ptr()[i]; + MTL::Resource *new_res = keyval_ptr[j]; + + if (current_res < new_res) { + i++; + } else if (current_res > new_res) { + if (should_add_resource(new_res)) { + resources->insert(i, new_res); + } + i++; + j++; + } else { + i++; + j++; + } + } + + // Append any remaining resources from the input. + for (; j < keyval.value.size(); j++) { + if (should_add_resource(keyval_ptr[j])) { + resources->push_back(keyval_ptr[j]); + } + } + } +} + +void ResourceTracker::encode(MTL::RenderCommandEncoder *p_enc) { + for (KeyValue const &keyval : _current) { + if (keyval.value.is_empty()) { + continue; + } + + MTL::ResourceUsage vert_usage = (MTL::ResourceUsage)resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_VERTEX); + MTL::ResourceUsage frag_usage = (MTL::ResourceUsage)resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_FRAGMENT); + const MTL::Resource **resources = (const MTL::Resource **)(void *)keyval.value.ptr(); + NS::UInteger count = keyval.value.size(); + if (vert_usage == frag_usage) { + p_enc->useResources(resources, count, vert_usage, MTL::RenderStageVertex | MTL::RenderStageFragment); + } else { + if (vert_usage != 0) { + p_enc->useResources(resources, count, vert_usage, MTL::RenderStageVertex); + } + if (frag_usage != 0) { + p_enc->useResources(resources, count, frag_usage, MTL::RenderStageFragment); + } + } + } + + // Keep the keys for now and clear the vectors to reduce churn. + for (KeyValue &v : _current) { + v.value.clear(); + } +} + +void ResourceTracker::encode(MTL::ComputeCommandEncoder *p_enc) { + for (KeyValue const &keyval : _current) { + if (keyval.value.is_empty()) { + continue; + } + MTL::ResourceUsage usage = (MTL::ResourceUsage)resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_COMPUTE); + if (usage != 0) { + const MTL::Resource **resources = (const MTL::Resource **)(void *)keyval.value.ptr(); + p_enc->useResources(resources, keyval.value.size(), usage); + } + } + + // Keep the keys for now and clear the vectors to reduce churn. + for (KeyValue &v : _current) { + v.value.clear(); + } +} + +void ResourceTracker::reset() { + // Keep the keys for now, as they are likely to be used repeatedly. + for (KeyValue &v : _previous) { + if (v.value.usage == ResourceUnused) { + v.value.unused++; + if (v.value.unused >= RESOURCE_UNUSED_CLEANUP_COUNT) { + _scratch.push_back(v.key); + } + } else { + v.value = ResourceUnused; + v.value.unused = 0; + } + } + + // Clear up resources that weren't used for the last pass. + for (MTL::Resource *res : _scratch) { + _previous.erase(res); + } + _scratch.clear(); +} + +void MDCommandBuffer::_render_bind_uniform_sets() { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + if (!render.dirty.has_flag(RenderState::DIRTY_UNIFORMS)) { + return; + } + + render.dirty.clear_flag(RenderState::DIRTY_UNIFORMS); + uint64_t set_uniforms = render.uniform_set_mask; + render.uniform_set_mask = 0; + + MDRenderShader *shader = render.pipeline->shader; + const uint32_t dynamic_offsets = render.dynamic_offsets; + + while (set_uniforms != 0) { + // Find the index of the next set bit. + uint32_t index = (uint32_t)__builtin_ctzll(set_uniforms); + // Clear the set bit. + set_uniforms &= (set_uniforms - 1); + MDUniformSet *set = render.uniform_sets[index]; + if (set == nullptr || index >= (uint32_t)shader->sets.size()) { + continue; + } + if (shader->uses_argument_buffers) { + _bind_uniforms_argument_buffers(set, shader, index, dynamic_offsets); + } else { + DirectEncoder de(render.encoder.get(), binding_cache, DirectEncoder::RENDER); + _bind_uniforms_direct(set, shader, de, index, dynamic_offsets); + } + } +} + +void MDCommandBuffer::render_begin_pass(RDD::RenderPassID p_render_pass, RDD::FramebufferID p_frameBuffer, RDD::CommandBufferType p_cmd_buffer_type, const Rect2i &p_rect, VectorView p_clear_values) { + DEV_ASSERT(command_buffer() != nullptr); + end(); + + MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); + MDFrameBuffer *fb = (MDFrameBuffer *)(p_frameBuffer.id); + + type = MDCommandBufferStateType::Render; + render.pass = pass; + render.current_subpass = UINT32_MAX; + render.render_area = p_rect; + render.clear_values.resize(p_clear_values.size()); + for (uint32_t i = 0; i < p_clear_values.size(); i++) { + render.clear_values[i] = p_clear_values[i]; + } + render.is_rendering_entire_area = (p_rect.position == Point2i(0, 0)) && p_rect.size == fb->size; + render.frameBuffer = fb; + render_next_subpass(); +} + +void MDCommandBuffer::render_next_subpass() { + DEV_ASSERT(command_buffer() != nullptr); + + if (render.current_subpass == UINT32_MAX) { + render.current_subpass = 0; + } else { + _end_render_pass(); + render.current_subpass++; + } + + MDFrameBuffer const &fb = *render.frameBuffer; + MDRenderPass const &pass = *render.pass; + MDSubpass const &subpass = render.get_subpass(); + + NS::SharedPtr desc = NS::TransferPtr(MTL::RenderPassDescriptor::alloc()->init()); + + if (subpass.view_count > 1) { + desc->setRenderTargetArrayLength(subpass.view_count); + } + + PixelFormats &pf = device_driver->get_pixel_formats(); + + uint32_t attachmentCount = 0; + for (uint32_t i = 0; i < subpass.color_references.size(); i++) { + uint32_t idx = subpass.color_references[i].attachment; + if (idx == RDD::AttachmentReference::UNUSED) { + continue; + } + + attachmentCount += 1; + MTL::RenderPassColorAttachmentDescriptor *ca = desc->colorAttachments()->object(i); + + uint32_t resolveIdx = subpass.resolve_references.is_empty() ? RDD::AttachmentReference::UNUSED : subpass.resolve_references[i].attachment; + bool has_resolve = resolveIdx != RDD::AttachmentReference::UNUSED; + bool can_resolve = true; + if (resolveIdx != RDD::AttachmentReference::UNUSED) { + MTL::Texture *resolve_tex = fb.get_texture(resolveIdx); + can_resolve = flags::all(pf.getCapabilities(resolve_tex->pixelFormat()), kMTLFmtCapsResolve); + if (can_resolve) { + ca->setResolveTexture(resolve_tex); + } else { + CRASH_NOW_MSG("unimplemented: using a texture format that is not supported for resolve"); + } + } + + MDAttachment const &attachment = pass.attachments[idx]; + + MTL::Texture *tex = fb.get_texture(idx); + ERR_FAIL_NULL_MSG(tex, "Frame buffer color texture is null."); + + if ((attachment.type & MDAttachmentType::Color)) { + if (attachment.configureDescriptor(ca, pf, subpass, tex, render.is_rendering_entire_area, has_resolve, can_resolve, false)) { + Color clearColor = render.clear_values[idx].color; + ca->setClearColor(MTL::ClearColor(clearColor.r, clearColor.g, clearColor.b, clearColor.a)); + } + } + } + + if (subpass.depth_stencil_reference.attachment != RDD::AttachmentReference::UNUSED) { + attachmentCount += 1; + uint32_t idx = subpass.depth_stencil_reference.attachment; + MDAttachment const &attachment = pass.attachments[idx]; + MTL::Texture *tex = fb.get_texture(idx); + ERR_FAIL_NULL_MSG(tex, "Frame buffer depth / stencil texture is null."); + if (attachment.type & MDAttachmentType::Depth) { + MTL::RenderPassDepthAttachmentDescriptor *da = desc->depthAttachment(); + if (attachment.configureDescriptor(da, pf, subpass, tex, render.is_rendering_entire_area, false, false, false)) { + da->setClearDepth(render.clear_values[idx].depth); + } + } + + if (attachment.type & MDAttachmentType::Stencil) { + MTL::RenderPassStencilAttachmentDescriptor *sa = desc->stencilAttachment(); + if (attachment.configureDescriptor(sa, pf, subpass, tex, render.is_rendering_entire_area, false, false, true)) { + sa->setClearStencil(render.clear_values[idx].stencil); + } + } + } + + desc->setRenderTargetWidth(MAX((NS::UInteger)MIN(render.render_area.position.x + render.render_area.size.width, fb.size.width), 1u)); + desc->setRenderTargetHeight(MAX((NS::UInteger)MIN(render.render_area.position.y + render.render_area.size.height, fb.size.height), 1u)); + + if (attachmentCount == 0) { + // If there are no attachments, delay the creation of the encoder, + // so we can use a matching sample count for the pipeline, by setting + // the defaultRasterSampleCount from the pipeline's sample count. + render.desc = desc; + } else { + render.encoder = NS::RetainPtr(command_buffer()->renderCommandEncoder(desc.get())); + _encode_barrier(render.encoder.get()); + + if (!render.is_rendering_entire_area) { + _render_clear_render_area(); + } + // With a new encoder, all state is dirty. + render.dirty.set_flag(RenderState::DIRTY_ALL); + } +} + +void MDCommandBuffer::render_draw(uint32_t p_vertex_count, + uint32_t p_instance_count, + uint32_t p_base_vertex, + uint32_t p_first_instance) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); + + _render_set_dirty_state(); + + MDSubpass const &subpass = render.get_subpass(); + if (subpass.view_count > 1) { + p_instance_count *= subpass.view_count; + } + + DEV_ASSERT(render.dirty == 0); + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + enc->drawPrimitives(render.pipeline->raster_state.render_primitive, p_base_vertex, p_vertex_count, p_instance_count, p_first_instance); +} + +void MDCommandBuffer::render_bind_vertex_buffers(uint32_t p_binding_count, const RDD::BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + + render.vertex_buffers.resize(p_binding_count); + render.vertex_offsets.resize(p_binding_count); + + // Are the existing buffer bindings the same? + bool same = true; + + // Reverse the buffers, as their bindings are assigned in descending order. + for (uint32_t i = 0; i < p_binding_count; i += 1) { + const RenderingDeviceDriverMetal::BufferInfo *buf_info = (const RenderingDeviceDriverMetal::BufferInfo *)p_buffers[p_binding_count - i - 1].id; + + NS::UInteger dynamic_offset = 0; + if (buf_info->is_dynamic()) { + const MetalBufferDynamicInfo *dyn_buf = (const MetalBufferDynamicInfo *)buf_info; + uint64_t frame_idx = p_dynamic_offsets & 0x3; + p_dynamic_offsets >>= 2; + dynamic_offset = frame_idx * dyn_buf->size_bytes; + } + if (render.vertex_buffers[i] != buf_info->metal_buffer.get()) { + render.vertex_buffers[i] = buf_info->metal_buffer.get(); + same = false; + } + + render.vertex_offsets[i] = dynamic_offset + p_offsets[p_binding_count - i - 1]; + } + + if (render.encoder.get() != nullptr) { + uint32_t first = device_driver->get_metal_buffer_index_for_vertex_attribute_binding(p_binding_count - 1); + if (same) { + NS::UInteger *offset_ptr = render.vertex_offsets.ptr(); + for (uint32_t i = first; i < first + p_binding_count; i++) { + render.encoder->setVertexBufferOffset(*offset_ptr, i); + offset_ptr++; + } + } else { + render.encoder->setVertexBuffers(render.vertex_buffers.ptr(), render.vertex_offsets.ptr(), NS::Range(first, p_binding_count)); + } + render.dirty.clear_flag(RenderState::DIRTY_VERTEX); + } else { + render.dirty.set_flag(RenderState::DIRTY_VERTEX); + } +} + +void MDCommandBuffer::render_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint64_t p_offset) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + + const RenderingDeviceDriverMetal::BufferInfo *buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_buffer.id; + + render.index_buffer = buffer->metal_buffer.get(); + render.index_type = p_format == RDD::IndexBufferFormat::INDEX_BUFFER_FORMAT_UINT16 ? MTL::IndexTypeUInt16 : MTL::IndexTypeUInt32; + render.index_offset = p_offset; +} + +void MDCommandBuffer::render_draw_indexed(uint32_t p_index_count, + uint32_t p_instance_count, + uint32_t p_first_index, + int32_t p_vertex_offset, + uint32_t p_first_instance) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); + + _render_set_dirty_state(); + + MDSubpass const &subpass = render.get_subpass(); + if (subpass.view_count > 1) { + p_instance_count *= subpass.view_count; + } + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + + uint32_t index_offset = render.index_offset; + index_offset += p_first_index * (render.index_type == MTL::IndexTypeUInt16 ? sizeof(uint16_t) : sizeof(uint32_t)); + + enc->drawIndexedPrimitives(render.pipeline->raster_state.render_primitive, p_index_count, render.index_type, render.index_buffer, index_offset, p_instance_count, p_vertex_offset, p_first_instance); +} + +void MDCommandBuffer::render_draw_indexed_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); + + _render_set_dirty_state(); + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + + const RenderingDeviceDriverMetal::BufferInfo *indirect_buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; + NS::UInteger indirect_offset = p_offset; + + for (uint32_t i = 0; i < p_draw_count; i++) { + enc->drawIndexedPrimitives(render.pipeline->raster_state.render_primitive, render.index_type, render.index_buffer, 0, indirect_buffer->metal_buffer.get(), indirect_offset); + indirect_offset += p_stride; + } +} + +void MDCommandBuffer::render_draw_indexed_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { + ERR_FAIL_MSG("not implemented"); +} + +void MDCommandBuffer::render_draw_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); + + _render_set_dirty_state(); + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + + const RenderingDeviceDriverMetal::BufferInfo *indirect_buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; + NS::UInteger indirect_offset = p_offset; + + for (uint32_t i = 0; i < p_draw_count; i++) { + enc->drawPrimitives(render.pipeline->raster_state.render_primitive, indirect_buffer->metal_buffer.get(), indirect_offset); + indirect_offset += p_stride; + } +} + +void MDCommandBuffer::render_draw_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { + ERR_FAIL_MSG("not implemented"); +} + +void MDCommandBuffer::render_end_pass() { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + + render.end_encoding(); + render.reset(); + reset(); +} + +#pragma mark - RenderState + +void MDCommandBuffer::RenderState::reset() { + pass = nullptr; + frameBuffer = nullptr; + pipeline = nullptr; + current_subpass = UINT32_MAX; + render_area = {}; + is_rendering_entire_area = false; + desc.reset(); + encoder.reset(); + index_buffer = nullptr; + index_type = MTL::IndexTypeUInt16; + dirty = DIRTY_NONE; + uniform_sets.clear(); + dynamic_offsets = 0; + uniform_set_mask = 0; + clear_values.clear(); + viewports.clear(); + scissors.clear(); + blend_constants.reset(); + bzero(vertex_buffers.ptr(), sizeof(MTL::Buffer *) * vertex_buffers.size()); + vertex_buffers.clear(); + bzero(vertex_offsets.ptr(), sizeof(NS::UInteger) * vertex_offsets.size()); + vertex_offsets.clear(); + resource_tracker.reset(); +} + +void MDCommandBuffer::RenderState::end_encoding() { + if (encoder.get() == nullptr) { + return; + } + + encoder->endEncoding(); + encoder.reset(); +} + +#pragma mark - ComputeState + +void MDCommandBuffer::ComputeState::end_encoding() { + if (encoder.get() == nullptr) { + return; + } + + encoder->endEncoding(); + encoder.reset(); +} + +#pragma mark - Compute + +void MDCommandBuffer::_compute_set_dirty_state() { + if (compute.dirty.has_flag(ComputeState::DIRTY_PIPELINE)) { + compute.encoder = NS::RetainPtr(command_buffer()->computeCommandEncoder(MTL::DispatchTypeConcurrent)); + _encode_barrier(compute.encoder.get()); + compute.encoder->setComputePipelineState(compute.pipeline->state.get()); + } + + _compute_bind_uniform_sets(); + + if (compute.dirty.has_flag(ComputeState::DIRTY_PUSH)) { + if (push_constant_binding != UINT32_MAX) { + compute.encoder->setBytes(push_constant_data, push_constant_data_len, push_constant_binding); + } + } + + if (!use_barriers) { + compute.resource_tracker.encode(compute.encoder.get()); + } + + compute.dirty.clear(); +} + +void MDCommandBuffer::_compute_bind_uniform_sets() { + DEV_ASSERT(type == MDCommandBufferStateType::Compute); + if (!compute.dirty.has_flag(ComputeState::DIRTY_UNIFORMS)) { + return; + } + + compute.dirty.clear_flag(ComputeState::DIRTY_UNIFORMS); + uint64_t set_uniforms = compute.uniform_set_mask; + compute.uniform_set_mask = 0; + + MDComputeShader *shader = compute.pipeline->shader; + const uint32_t dynamic_offsets = compute.dynamic_offsets; + + while (set_uniforms != 0) { + // Find the index of the next set bit. + uint32_t index = (uint32_t)__builtin_ctzll(set_uniforms); + // Clear the set bit. + set_uniforms &= (set_uniforms - 1); + MDUniformSet *set = compute.uniform_sets[index]; + if (set == nullptr || index >= (uint32_t)shader->sets.size()) { + continue; + } + if (shader->uses_argument_buffers) { + _bind_uniforms_argument_buffers_compute(set, shader, index, dynamic_offsets); + } else { + DirectEncoder de(compute.encoder.get(), binding_cache, DirectEncoder::COMPUTE); + _bind_uniforms_direct(set, shader, de, index, dynamic_offsets); + } + } +} + +void MDCommandBuffer::ComputeState::reset() { + pipeline = nullptr; + encoder.reset(); + dirty = DIRTY_NONE; + uniform_sets.clear(); + dynamic_offsets = 0; + uniform_set_mask = 0; + resource_tracker.reset(); +} + +void MDCommandBuffer::compute_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { + DEV_ASSERT(type == MDCommandBufferStateType::Compute); + + if (uint32_t new_size = p_first_set_index + p_set_count; compute.uniform_sets.size() < new_size) { + uint32_t s = compute.uniform_sets.size(); + compute.uniform_sets.resize(new_size); + // Set intermediate values to null. + std::fill(&compute.uniform_sets[s], compute.uniform_sets.end().operator->(), nullptr); + } + + const MDShader *shader = (const MDShader *)p_shader.id; + DynamicOffsetLayout layout = shader->dynamic_offset_layout; + + // Clear bits for sets being bound, then OR new values. + for (uint32_t i = 0; i < p_set_count && compute.dynamic_offsets != 0; i++) { + uint32_t set_index = p_first_set_index + i; + uint32_t count = layout.get_count(set_index); + if (count > 0) { + uint32_t shift = layout.get_offset_index_shift(set_index); + uint32_t mask = ((1u << (count * 4u)) - 1u) << shift; + compute.dynamic_offsets &= ~mask; // Clear this set's bits + } + } + compute.dynamic_offsets |= p_dynamic_offsets; + + for (size_t i = 0; i < p_set_count; ++i) { + MDUniformSet *set = (MDUniformSet *)(p_uniform_sets[i].id); + + uint32_t index = p_first_set_index + i; + if (compute.uniform_sets[index] != set || layout.get_count(index) > 0) { + compute.dirty.set_flag(ComputeState::DIRTY_UNIFORMS); + compute.uniform_set_mask |= 1ULL << index; + compute.uniform_sets[index] = set; + } + } +} + +void MDCommandBuffer::compute_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) { + DEV_ASSERT(type == MDCommandBufferStateType::Compute); + + _compute_set_dirty_state(); + + MTL::Size size = MTL::Size(p_x_groups, p_y_groups, p_z_groups); + + MTL::ComputeCommandEncoder *enc = compute.encoder.get(); + enc->dispatchThreadgroups(size, compute.pipeline->compute_state.local); +} + +void MDCommandBuffer::compute_dispatch_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset) { + DEV_ASSERT(type == MDCommandBufferStateType::Compute); + + _compute_set_dirty_state(); + + const RenderingDeviceDriverMetal::BufferInfo *indirectBuffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; + + MTL::ComputeCommandEncoder *enc = compute.encoder.get(); + enc->dispatchThreadgroups(indirectBuffer->metal_buffer.get(), p_offset, compute.pipeline->compute_state.local); +} + +void MDCommandBuffer::reset() { + push_constant_binding = UINT32_MAX; + push_constant_data_len = 0; + type = MDCommandBufferStateType::None; + binding_cache.clear(); +} + +void MDCommandBuffer::_end_compute_dispatch() { + DEV_ASSERT(type == MDCommandBufferStateType::Compute); + + compute.end_encoding(); + compute.reset(); + reset(); +} + +void MDCommandBuffer::_end_blit() { + DEV_ASSERT(type == MDCommandBufferStateType::Blit); + + blit.encoder->endEncoding(); + blit.reset(); + reset(); +} + +MDComputeShader::MDComputeShader(CharString p_name, + Vector p_sets, + bool p_uses_argument_buffers, + std::shared_ptr p_kernel) : + MDShader(p_name, p_sets, p_uses_argument_buffers), kernel(std::move(p_kernel)) { +} + +MDRenderShader::MDRenderShader(CharString p_name, + Vector p_sets, + bool p_needs_view_mask_buffer, + bool p_uses_argument_buffers, + std::shared_ptr p_vert, std::shared_ptr p_frag) : + MDShader(p_name, p_sets, p_uses_argument_buffers), + needs_view_mask_buffer(p_needs_view_mask_buffer), + vert(std::move(p_vert)), + frag(std::move(p_frag)) { +} + +void DirectEncoder::set(MTL::Texture **p_textures, NS::Range p_range) { + if (cache.update(p_range, p_textures)) { + switch (mode) { + case RENDER: { + MTL::RenderCommandEncoder *enc = static_cast(encoder); + enc->setVertexTextures(p_textures, p_range); + enc->setFragmentTextures(p_textures, p_range); + } break; + case COMPUTE: { + MTL::ComputeCommandEncoder *enc = static_cast(encoder); + enc->setTextures(p_textures, p_range); + } break; + } + } +} + +void DirectEncoder::set(MTL::Buffer **p_buffers, const NS::UInteger *p_offsets, NS::Range p_range) { + if (cache.update(p_range, p_buffers, p_offsets)) { + switch (mode) { + case RENDER: { + MTL::RenderCommandEncoder *enc = static_cast(encoder); + enc->setVertexBuffers(p_buffers, p_offsets, p_range); + enc->setFragmentBuffers(p_buffers, p_offsets, p_range); + } break; + case COMPUTE: { + MTL::ComputeCommandEncoder *enc = static_cast(encoder); + enc->setBuffers(p_buffers, p_offsets, p_range); + } break; + } + } +} + +void DirectEncoder::set(MTL::Buffer *p_buffer, NS::UInteger p_offset, uint32_t p_index) { + if (cache.update(p_buffer, p_offset, p_index)) { + switch (mode) { + case RENDER: { + MTL::RenderCommandEncoder *enc = static_cast(encoder); + enc->setVertexBuffer(p_buffer, p_offset, p_index); + enc->setFragmentBuffer(p_buffer, p_offset, p_index); + } break; + case COMPUTE: { + MTL::ComputeCommandEncoder *enc = static_cast(encoder); + enc->setBuffer(p_buffer, p_offset, p_index); + } break; + } + } +} + +void DirectEncoder::set(MTL::SamplerState **p_samplers, NS::Range p_range) { + if (cache.update(p_range, p_samplers)) { + switch (mode) { + case RENDER: { + MTL::RenderCommandEncoder *enc = static_cast(encoder); + enc->setVertexSamplerStates(p_samplers, p_range); + enc->setFragmentSamplerStates(p_samplers, p_range); + } break; + case COMPUTE: { + MTL::ComputeCommandEncoder *enc = static_cast(encoder); + enc->setSamplerStates(p_samplers, p_range); + } break; + } + } +} + +GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability-new") + +void MDCommandBuffer::_bind_uniforms_argument_buffers(MDUniformSet *p_set, MDShader *p_shader, uint32_t p_set_index, uint32_t p_dynamic_offsets) { + DEV_ASSERT(p_shader->uses_argument_buffers); + DEV_ASSERT(render.encoder.get() != nullptr); + + MTL::RenderCommandEncoder *enc = render.encoder.get(); + render.resource_tracker.merge_from(p_set->usage_to_resources); + + const UniformSet &shader_set = p_shader->sets[p_set_index]; + + // Check if this set has dynamic uniforms. + if (!shader_set.dynamic_uniforms.is_empty()) { + // Allocate from the ring buffer. + uint32_t buffer_size = p_set->arg_buffer_data.size(); + MDRingBuffer::Allocation alloc = allocate_arg_buffer(buffer_size); + + // Copy the base argument buffer data. + memcpy(alloc.ptr, p_set->arg_buffer_data.ptr(), buffer_size); + + // Update dynamic buffer GPU addresses. + uint64_t *ptr = (uint64_t *)alloc.ptr; + DynamicOffsetLayout layout = p_shader->dynamic_offset_layout; + uint32_t dynamic_index = 0; + + for (uint32_t i : shader_set.dynamic_uniforms) { + RDD::BoundUniform const &uniform = p_set->uniforms[i]; + const UniformInfo &ui = shader_set.uniforms[i]; + const UniformInfo::Indexes &idx = ui.arg_buffer; + + uint32_t shift = layout.get_offset_index_shift(p_set_index, dynamic_index); + dynamic_index++; + uint32_t frame_idx = (p_dynamic_offsets >> shift) & 0xf; + + const MetalBufferDynamicInfo *buf_info = (const MetalBufferDynamicInfo *)uniform.ids[0].id; + uint64_t gpu_address = buf_info->metal_buffer.get()->gpuAddress() + frame_idx * buf_info->size_bytes; + *(uint64_t *)(ptr + idx.buffer) = gpu_address; + } + + enc->setVertexBuffer(alloc.buffer, alloc.offset, p_set_index); + enc->setFragmentBuffer(alloc.buffer, alloc.offset, p_set_index); + } else { + enc->setVertexBuffer(p_set->arg_buffer.get(), 0, p_set_index); + enc->setFragmentBuffer(p_set->arg_buffer.get(), 0, p_set_index); + } +} + +void MDCommandBuffer::_bind_uniforms_direct(MDUniformSet *p_set, MDShader *p_shader, DirectEncoder p_enc, uint32_t p_set_index, uint32_t p_dynamic_offsets) { + DEV_ASSERT(!p_shader->uses_argument_buffers); + + UniformSet const &set = p_shader->sets[p_set_index]; + DynamicOffsetLayout layout = p_shader->dynamic_offset_layout; + uint32_t dynamic_index = 0; + + for (uint32_t i = 0; i < MIN(p_set->uniforms.size(), set.uniforms.size()); i++) { + RDD::BoundUniform const &uniform = p_set->uniforms[i]; + const UniformInfo &ui = set.uniforms[i]; + const UniformInfo::Indexes &indexes = ui.slot; + + uint32_t frame_idx; + if (uniform.is_dynamic()) { + uint32_t shift = layout.get_offset_index_shift(p_set_index, dynamic_index); + dynamic_index++; + frame_idx = (p_dynamic_offsets >> shift) & 0xf; + } else { + frame_idx = 0; + } + + switch (uniform.type) { + case RDD::UNIFORM_TYPE_SAMPLER: { + size_t count = uniform.ids.size(); + MTL::SamplerState **objects = ALLOCA_ARRAY(MTL::SamplerState *, count); + for (size_t j = 0; j < count; j += 1) { + objects[j] = rid::get(uniform.ids[j]); + } + NS::Range sampler_range = { indexes.sampler, count }; + p_enc.set(objects, sampler_range); + } break; + case RDD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: { + size_t count = uniform.ids.size() / 2; + MTL::Texture **textures = ALLOCA_ARRAY(MTL::Texture *, count); + MTL::SamplerState **samplers = ALLOCA_ARRAY(MTL::SamplerState *, count); + for (uint32_t j = 0; j < count; j += 1) { + samplers[j] = rid::get(uniform.ids[j * 2 + 0]); + textures[j] = rid::get(uniform.ids[j * 2 + 1]); + } + NS::Range sampler_range = { indexes.sampler, count }; + NS::Range texture_range = { indexes.texture, count }; + p_enc.set(samplers, sampler_range); + p_enc.set(textures, texture_range); + } break; + case RDD::UNIFORM_TYPE_TEXTURE: { + size_t count = uniform.ids.size(); + MTL::Texture **objects = ALLOCA_ARRAY(MTL::Texture *, count); + for (size_t j = 0; j < count; j += 1) { + objects[j] = rid::get(uniform.ids[j]); + } + NS::Range texture_range = { indexes.texture, count }; + p_enc.set(objects, texture_range); + } break; + case RDD::UNIFORM_TYPE_IMAGE: { + size_t count = uniform.ids.size(); + MTL::Texture **objects = ALLOCA_ARRAY(MTL::Texture *, count); + for (size_t j = 0; j < count; j += 1) { + objects[j] = rid::get(uniform.ids[j]); + } + NS::Range texture_range = { indexes.texture, count }; + p_enc.set(objects, texture_range); + + if (indexes.buffer != UINT32_MAX) { + // Emulated atomic image access. + MTL::Buffer **bufs = ALLOCA_ARRAY(MTL::Buffer *, count); + for (size_t j = 0; j < count; j += 1) { + MTL::Texture *obj = objects[j]; + MTL::Texture *tex = obj->parentTexture() ? obj->parentTexture() : obj; + bufs[j] = tex->buffer(); + } + NS::UInteger *offs = ALLOCA_ARRAY(NS::UInteger, count); + bzero(offs, sizeof(NS::UInteger) * count); + NS::Range buffer_range = { indexes.buffer, count }; + p_enc.set(bufs, offs, buffer_range); + } + } break; + case RDD::UNIFORM_TYPE_TEXTURE_BUFFER: { + ERR_PRINT("not implemented: UNIFORM_TYPE_TEXTURE_BUFFER"); + } break; + case RDD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER: { + ERR_PRINT("not implemented: UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER"); + } break; + case RDD::UNIFORM_TYPE_IMAGE_BUFFER: { + CRASH_NOW_MSG("not implemented: UNIFORM_TYPE_IMAGE_BUFFER"); + } break; + case RDD::UNIFORM_TYPE_UNIFORM_BUFFER: + case RDD::UNIFORM_TYPE_STORAGE_BUFFER: { + const RDM::BufferInfo *buf_info = (const RDM::BufferInfo *)uniform.ids[0].id; + p_enc.set(buf_info->metal_buffer.get(), 0, indexes.buffer); + } break; + case RDD::UNIFORM_TYPE_UNIFORM_BUFFER_DYNAMIC: + case RDD::UNIFORM_TYPE_STORAGE_BUFFER_DYNAMIC: { + const MetalBufferDynamicInfo *buf_info = (const MetalBufferDynamicInfo *)uniform.ids[0].id; + p_enc.set(buf_info->metal_buffer.get(), frame_idx * buf_info->size_bytes, indexes.buffer); + } break; + case RDD::UNIFORM_TYPE_INPUT_ATTACHMENT: { + size_t count = uniform.ids.size(); + MTL::Texture **objects = ALLOCA_ARRAY(MTL::Texture *, count); + for (size_t j = 0; j < count; j += 1) { + objects[j] = rid::get(uniform.ids[j]); + } + NS::Range texture_range = { indexes.texture, count }; + p_enc.set(objects, texture_range); + } break; + default: { + DEV_ASSERT(false); + } + } + } +} + +void MDCommandBuffer::_bind_uniforms_argument_buffers_compute(MDUniformSet *p_set, MDShader *p_shader, uint32_t p_set_index, uint32_t p_dynamic_offsets) { + DEV_ASSERT(p_shader->uses_argument_buffers); + DEV_ASSERT(compute.encoder.get() != nullptr); + + MTL::ComputeCommandEncoder *enc = compute.encoder.get(); + compute.resource_tracker.merge_from(p_set->usage_to_resources); + + const UniformSet &shader_set = p_shader->sets[p_set_index]; + + // Check if this set has dynamic uniforms. + if (!shader_set.dynamic_uniforms.is_empty()) { + // Allocate from the ring buffer. + uint32_t buffer_size = p_set->arg_buffer_data.size(); + MDRingBuffer::Allocation alloc = allocate_arg_buffer(buffer_size); + + // Copy the base argument buffer data. + memcpy(alloc.ptr, p_set->arg_buffer_data.ptr(), buffer_size); + + // Update dynamic buffer GPU addresses. + uint64_t *ptr = (uint64_t *)alloc.ptr; + DynamicOffsetLayout layout = p_shader->dynamic_offset_layout; + uint32_t dynamic_index = 0; + + for (uint32_t i : shader_set.dynamic_uniforms) { + RDD::BoundUniform const &uniform = p_set->uniforms[i]; + const UniformInfo &ui = shader_set.uniforms[i]; + const UniformInfo::Indexes &idx = ui.arg_buffer; + + uint32_t shift = layout.get_offset_index_shift(p_set_index, dynamic_index); + dynamic_index++; + uint32_t frame_idx = (p_dynamic_offsets >> shift) & 0xf; + + const MetalBufferDynamicInfo *buf_info = (const MetalBufferDynamicInfo *)uniform.ids[0].id; + uint64_t gpu_address = buf_info->metal_buffer.get()->gpuAddress() + frame_idx * buf_info->size_bytes; + *(uint64_t *)(ptr + idx.buffer) = gpu_address; + } + + enc->setBuffer(alloc.buffer, alloc.offset, p_set_index); + } else { + enc->setBuffer(p_set->arg_buffer.get(), 0, p_set_index); + } +} + +GODOT_CLANG_WARNING_POP diff --git a/drivers/metal/metal3_objects.h b/drivers/metal/metal3_objects.h new file mode 100644 index 0000000000..cde410dc5e --- /dev/null +++ b/drivers/metal/metal3_objects.h @@ -0,0 +1,590 @@ +/**************************************************************************/ +/* metal3_objects.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +/**************************************************************************/ +/* */ +/* Portions of this code were derived from MoltenVK. */ +/* */ +/* Copyright (c) 2015-2023 The Brenwill Workshop Ltd. */ +/* (http://www.brenwill.com) */ +/* */ +/* Licensed under the Apache License, Version 2.0 (the "License"); */ +/* you may not use this file except in compliance with the License. */ +/* You may obtain a copy of the License at */ +/* */ +/* http://www.apache.org/licenses/LICENSE-2.0 */ +/* */ +/* Unless required by applicable law or agreed to in writing, software */ +/* distributed under the License is distributed on an "AS IS" BASIS, */ +/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ +/* implied. See the License for the specific language governing */ +/* permissions and limitations under the License. */ +/**************************************************************************/ + +#include "metal_objects_shared.h" + +#include "servers/rendering/rendering_device_driver.h" + +#include + +#include +#include + +namespace MTL3 { + +// These types are defined in the global namespace (metal_objects_shared.h / rendering_device_driver_metal.h) +using ::MDAttachment; +using ::MDAttachmentType; +using ::MDCommandBufferBase; +using ::MDCommandBufferStateType; +using ::MDFrameBuffer; +using ::MDRenderPass; +using ::MDRingBuffer; +using ::MDSubpass; +using ::RenderStateBase; + +using ::DynamicOffsetLayout; +using ::MDComputePipeline; +using ::MDComputeShader; +using ::MDLibrary; +using ::MDPipeline; +using ::MDPipelineType; +using ::MDRenderPipeline; +using ::MDRenderShader; +using ::MDShader; +using ::MDUniformSet; +using ::ShaderCacheEntry; +using ::ShaderLoadStrategy; +using ::UniformInfo; +using ::UniformSet; + +using RDM = ::RenderingDeviceDriverMetal; + +struct ResourceUsageEntry { + StageResourceUsage usage = ResourceUnused; + uint32_t unused = 0; + + ResourceUsageEntry() {} + ResourceUsageEntry(StageResourceUsage p_usage) : + usage(p_usage) {} +}; + +} // namespace MTL3 + +template <> +struct is_zero_constructible : std::true_type {}; + +namespace MTL3 { + +/*! Track the cumulative usage for a resource during a render or compute pass */ +typedef HashMap ResourceToStageUsage; + +/*! Track resource and ensure they are resident prior to dispatch or draw commands. + * + * The primary purpose of this data structure is to track all the resources that must be made resident prior + * to issuing the next dispatch or draw command. It aggregates all resources used from argument buffers. + * + * As an optimization, this data structure also tracks previous usage for resources, so that + * it may avoid binding them again in later commands if the resource is already resident and its usage flagged. + */ +struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) ResourceTracker { + // A constant specifying how many iterations a resource can remain in + // the _previous HashSet before it will be removed permanently. + // + // Keeping them in the _previous HashMap reduces churn if resources are regularly + // bound. 256 is arbitrary, but if an object remains unused for 256 encoders, + // it will be released. + static constexpr uint32_t RESOURCE_UNUSED_CLEANUP_COUNT = 256; + + // Used as a scratch buffer to periodically clean up resources from _previous. + ResourceVector _scratch; + // Tracks all resources and their prior usage for the duration of the encoder. + ResourceToStageUsage _previous; + // Tracks resources for the current command that must be made resident + ResourceUsageMap _current; + + void merge_from(const ::ResourceUsageMap &p_from); + void encode(MTL::RenderCommandEncoder *p_enc); + void encode(MTL::ComputeCommandEncoder *p_enc); + void reset(); +}; + +struct BindingCache { + struct BufferBinding { + MTL::Buffer *buffer = nullptr; + NS::UInteger offset = 0; + + bool operator!=(const BufferBinding &p_other) const { + return buffer != p_other.buffer || offset != p_other.offset; + } + }; + + LocalVector textures; + LocalVector samplers; + LocalVector buffers; + + _FORCE_INLINE_ void clear() { + textures.clear(); + samplers.clear(); + buffers.clear(); + } + +private: + template + _FORCE_INLINE_ void ensure_size(LocalVector &p_vec, uint32_t p_required) { + if (p_vec.size() < p_required) { + p_vec.resize_initialized(p_required); + } + } + +public: + _FORCE_INLINE_ bool update(NS::Range p_range, MTL::Texture *const *p_values) { + if (p_range.length == 0) { + return false; + } + uint32_t required = (uint32_t)(p_range.location + p_range.length); + ensure_size(textures, required); + bool changed = false; + for (NS::UInteger i = 0; i < p_range.length; ++i) { + uint32_t slot = (uint32_t)(p_range.location + i); + MTL::Texture *value = p_values[i]; + if (textures[slot] != value) { + textures[slot] = value; + changed = true; + } + } + return changed; + } + + _FORCE_INLINE_ bool update(NS::Range p_range, MTL::SamplerState *const *p_values) { + if (p_range.length == 0) { + return false; + } + uint32_t required = (uint32_t)(p_range.location + p_range.length); + ensure_size(samplers, required); + bool changed = false; + for (NS::UInteger i = 0; i < p_range.length; ++i) { + uint32_t slot = (uint32_t)(p_range.location + i); + MTL::SamplerState *value = p_values[i]; + if (samplers[slot] != value) { + samplers[slot] = value; + changed = true; + } + } + return changed; + } + + _FORCE_INLINE_ bool update(NS::Range p_range, MTL::Buffer *const *p_values, const NS::UInteger *p_offsets) { + if (p_range.length == 0) { + return false; + } + uint32_t required = (uint32_t)(p_range.location + p_range.length); + ensure_size(buffers, required); + BufferBinding *buffers_ptr = buffers.ptr() + p_range.location; + bool changed = false; + for (NS::UInteger i = 0; i < p_range.length; ++i) { + BufferBinding &binding = *buffers_ptr; + BufferBinding new_binding = { + .buffer = p_values[i], + .offset = p_offsets[i], + }; + if (binding != new_binding) { + binding = new_binding; + changed = true; + } + ++buffers_ptr; + } + return changed; + } + + _FORCE_INLINE_ bool update(MTL::Buffer *p_buffer, NS::UInteger p_offset, uint32_t p_index) { + uint32_t required = p_index + 1; + ensure_size(buffers, required); + BufferBinding &binding = buffers.ptr()[p_index]; + BufferBinding new_binding = { + .buffer = p_buffer, + .offset = p_offset, + }; + if (binding != new_binding) { + binding = new_binding; + return true; + } + return false; + } +}; + +// A type used to encode resources directly to a MTLCommandEncoder +struct DirectEncoder { + MTL::CommandEncoder *encoder; + BindingCache &cache; + enum Mode { + RENDER, + COMPUTE + }; + Mode mode; + + void set(MTL::Buffer **p_buffers, const NS::UInteger *p_offsets, NS::Range p_range); + void set(MTL::Buffer *p_buffer, NS::UInteger p_offset, uint32_t p_index); + void set(MTL::Texture **p_textures, NS::Range p_range); + void set(MTL::SamplerState **p_samplers, NS::Range p_range); + + DirectEncoder(MTL::CommandEncoder *p_encoder, BindingCache &p_cache, Mode p_mode) : + encoder(p_encoder), cache(p_cache), mode(p_mode) {} +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDCommandBuffer : public MDCommandBufferBase { + friend class MDUniformSet; + +private: +#pragma mark - Common State + + BindingCache binding_cache; + +#pragma mark - Argument Buffer Ring Allocator + + using Alloc = MDRingBuffer::Allocation; + + // Used for argument buffers that contain dynamic uniforms. + MDRingBuffer _scratch; + + /// Allocates from the ring buffer for dynamic argument buffers. + Alloc allocate_arg_buffer(uint32_t p_size); + + struct { + NS::SharedPtr rs; + } _frame_state; + +#pragma mark - Synchronization + + enum { + STAGE_RENDER, + STAGE_COMPUTE, + STAGE_BLIT, + STAGE_MAX, + }; + bool use_barriers = false; + MTL::Stages pending_after_stages[STAGE_MAX] = { 0, 0, 0 }; + MTL::Stages pending_before_queue_stages[STAGE_MAX] = { 0, 0, 0 }; + void _encode_barrier(MTL::CommandEncoder *p_enc); + + void reset(); + + MTL::CommandQueue *queue = nullptr; + NS::SharedPtr commandBuffer; + bool state_begin = false; + + MTL::CommandBuffer *command_buffer(); + + void _end_compute_dispatch(); + void _end_blit(); + MTL::BlitCommandEncoder *_ensure_blit_encoder(); + + enum class CopySource { + Buffer, + Texture, + }; + void _copy_texture_buffer(CopySource p_source, + RDD::TextureID p_texture, + RDD::BufferID p_buffer, + VectorView p_regions); + +#pragma mark - Render + + void _render_set_dirty_state(); + void _render_bind_uniform_sets(); + void _bind_uniforms_argument_buffers(MDUniformSet *p_set, MDShader *p_shader, uint32_t p_set_index, uint32_t p_dynamic_offsets); + void _bind_uniforms_direct(MDUniformSet *p_set, MDShader *p_shader, DirectEncoder p_enc, uint32_t p_set_index, uint32_t p_dynamic_offsets); + +#pragma mark - Compute + + void _compute_set_dirty_state(); + void _compute_bind_uniform_sets(); + void _bind_uniforms_argument_buffers_compute(MDUniformSet *p_set, MDShader *p_shader, uint32_t p_set_index, uint32_t p_dynamic_offsets); + +protected: + void mark_push_constants_dirty() override; + RenderStateBase &get_render_state_base() override { return render; } + uint32_t get_current_view_count() const override { return render.get_subpass().view_count; } + MDRenderPass *get_render_pass() const override { return render.pass; } + MDFrameBuffer *get_frame_buffer() const override { return render.frameBuffer; } + const MDSubpass &get_current_subpass() const override { return render.get_subpass(); } + LocalVector &get_clear_values() override { return render.clear_values; } + const Rect2i &get_render_area() const override { return render.render_area; } + void end_render_encoding() override { render.end_encoding(); } + +public: + struct RenderState : public RenderStateBase { + MDRenderPass *pass = nullptr; + MDFrameBuffer *frameBuffer = nullptr; + MDRenderPipeline *pipeline = nullptr; + LocalVector clear_values; + uint32_t current_subpass = UINT32_MAX; + Rect2i render_area = {}; + bool is_rendering_entire_area = false; + NS::SharedPtr desc; + NS::SharedPtr encoder; + MTL::Buffer *index_buffer = nullptr; // Buffer is owned by RDD. + MTL::IndexType index_type = MTL::IndexTypeUInt16; + uint32_t index_offset = 0; + LocalVector vertex_buffers; + LocalVector vertex_offsets; + ResourceTracker resource_tracker; + + LocalVector uniform_sets; + uint32_t dynamic_offsets = 0; + // Bit mask of the uniform sets that are dirty, to prevent redundant binding. + uint64_t uniform_set_mask = 0; + + _FORCE_INLINE_ void reset(); + void end_encoding(); + + _ALWAYS_INLINE_ const MDSubpass &get_subpass() const { + DEV_ASSERT(pass != nullptr); + return pass->subpasses[current_subpass]; + } + + _FORCE_INLINE_ void mark_viewport_dirty() { + if (viewports.is_empty()) { + return; + } + dirty.set_flag(DirtyFlag::DIRTY_VIEWPORT); + } + + _FORCE_INLINE_ void mark_scissors_dirty() { + if (scissors.is_empty()) { + return; + } + dirty.set_flag(DirtyFlag::DIRTY_SCISSOR); + } + + _FORCE_INLINE_ void mark_vertex_dirty() { + if (vertex_buffers.is_empty()) { + return; + } + dirty.set_flag(DirtyFlag::DIRTY_VERTEX); + } + + _FORCE_INLINE_ void mark_uniforms_dirty(std::initializer_list l) { + if (uniform_sets.is_empty()) { + return; + } + for (uint32_t i : l) { + if (i < uniform_sets.size() && uniform_sets[i] != nullptr) { + uniform_set_mask |= 1 << i; + } + } + dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); + } + + _FORCE_INLINE_ void mark_uniforms_dirty(void) { + if (uniform_sets.is_empty()) { + return; + } + for (uint32_t i = 0; i < uniform_sets.size(); i++) { + if (uniform_sets[i] != nullptr) { + uniform_set_mask |= 1 << i; + } + } + dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); + } + + _FORCE_INLINE_ void mark_blend_dirty() { + if (!blend_constants.has_value()) { + return; + } + dirty.set_flag(DirtyFlag::DIRTY_BLEND); + } + + MTL::ScissorRect clip_to_render_area(MTL::ScissorRect p_rect) const { + uint32_t raLeft = render_area.position.x; + uint32_t raRight = raLeft + render_area.size.width; + uint32_t raBottom = render_area.position.y; + uint32_t raTop = raBottom + render_area.size.height; + + p_rect.x = CLAMP(p_rect.x, raLeft, MAX(raRight - 1, raLeft)); + p_rect.y = CLAMP(p_rect.y, raBottom, MAX(raTop - 1, raBottom)); + p_rect.width = MIN(p_rect.width, raRight - p_rect.x); + p_rect.height = MIN(p_rect.height, raTop - p_rect.y); + + return p_rect; + } + + Rect2i clip_to_render_area(Rect2i p_rect) const { + int32_t raLeft = render_area.position.x; + int32_t raRight = raLeft + render_area.size.width; + int32_t raBottom = render_area.position.y; + int32_t raTop = raBottom + render_area.size.height; + + p_rect.position.x = CLAMP(p_rect.position.x, raLeft, MAX(raRight - 1, raLeft)); + p_rect.position.y = CLAMP(p_rect.position.y, raBottom, MAX(raTop - 1, raBottom)); + p_rect.size.width = MIN(p_rect.size.width, raRight - p_rect.position.x); + p_rect.size.height = MIN(p_rect.size.height, raTop - p_rect.position.y); + + return p_rect; + } + + } render; + + // State specific for a compute pass. + struct ComputeState { + MDComputePipeline *pipeline = nullptr; + NS::SharedPtr encoder; + ResourceTracker resource_tracker; + // clang-format off + enum DirtyFlag: uint16_t { + DIRTY_NONE = 0, + DIRTY_PIPELINE = 1 << 0, //! pipeline state + DIRTY_UNIFORMS = 1 << 1, //! uniform sets + DIRTY_PUSH = 1 << 2, //! push constants + DIRTY_ALL = (1 << 3) - 1, + }; + // clang-format on + BitField dirty = DIRTY_NONE; + + LocalVector uniform_sets; + uint32_t dynamic_offsets = 0; + // Bit mask of the uniform sets that are dirty, to prevent redundant binding. + uint64_t uniform_set_mask = 0; + + _FORCE_INLINE_ void reset(); + void end_encoding(); + + _FORCE_INLINE_ void mark_uniforms_dirty(void) { + if (uniform_sets.is_empty()) { + return; + } + for (uint32_t i = 0; i < uniform_sets.size(); i++) { + if (uniform_sets[i] != nullptr) { + uniform_set_mask |= 1 << i; + } + } + dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); + } + } compute; + + // State specific to a blit pass. + struct { + NS::SharedPtr encoder; + _FORCE_INLINE_ void reset() { + encoder.reset(); + } + } blit; + + _FORCE_INLINE_ MTL::CommandBuffer *get_command_buffer() const { + return commandBuffer.get(); + } + + void begin() override; + void commit() override; + void end() override; + + void bind_pipeline(RDD::PipelineID p_pipeline) override; + +#pragma mark - Render Commands + + void render_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) override; + void render_clear_attachments(VectorView p_attachment_clears, VectorView p_rects) override; + void render_begin_pass(RDD::RenderPassID p_render_pass, + RDD::FramebufferID p_frameBuffer, + RDD::CommandBufferType p_cmd_buffer_type, + const Rect2i &p_rect, + VectorView p_clear_values) override; + void render_next_subpass() override; + void render_draw(uint32_t p_vertex_count, + uint32_t p_instance_count, + uint32_t p_base_vertex, + uint32_t p_first_instance) override; + void render_bind_vertex_buffers(uint32_t p_binding_count, const RDD::BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets) override; + void render_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint64_t p_offset) override; + + void render_draw_indexed(uint32_t p_index_count, + uint32_t p_instance_count, + uint32_t p_first_index, + int32_t p_vertex_offset, + uint32_t p_first_instance) override; + + void render_draw_indexed_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) override; + void render_draw_indexed_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) override; + void render_draw_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) override; + void render_draw_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) override; + + void render_end_pass() override; + +#pragma mark - Compute Commands + + void compute_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) override; + void compute_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) override; + void compute_dispatch_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset) override; + +#pragma mark - Transfer + +private: + MTL::RenderCommandEncoder *get_new_render_encoder_with_descriptor(MTL::RenderPassDescriptor *p_desc); + +public: + void resolve_texture(RDD::TextureID p_src_texture, RDD::TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, RDD::TextureID p_dst_texture, RDD::TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap) override; + void clear_color_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, const Color &p_color, const RDD::TextureSubresourceRange &p_subresources) override; + void clear_depth_stencil_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const RDD::TextureSubresourceRange &p_subresources) override; + void clear_buffer(RDD::BufferID p_buffer, uint64_t p_offset, uint64_t p_size) override; + void copy_buffer(RDD::BufferID p_src_buffer, RDD::BufferID p_dst_buffer, VectorView p_regions) override; + void copy_texture(RDD::TextureID p_src_texture, RDD::TextureID p_dst_texture, VectorView p_regions) override; + void copy_buffer_to_texture(RDD::BufferID p_src_buffer, RDD::TextureID p_dst_texture, VectorView p_regions) override; + void copy_texture_to_buffer(RDD::TextureID p_src_texture, RDD::BufferID p_dst_buffer, VectorView p_regions) override; + +#pragma mark - Synchronization + + void pipeline_barrier(BitField p_src_stages, + BitField p_dst_stages, + VectorView p_memory_barriers, + VectorView p_buffer_barriers, + VectorView p_texture_barriers, + VectorView p_acceleration_structure_barriers) override; + +#pragma mark - Debugging + + void begin_label(const char *p_label_name, const Color &p_color) override; + void end_label() override; + + MDCommandBuffer(MTL::CommandQueue *p_queue, ::RenderingDeviceDriverMetal *p_device_driver); + MDCommandBuffer() = default; +}; + +} // namespace MTL3 + +// C++ helper to get mipmap level size from texture +_FORCE_INLINE_ static MTL::Size mipmapLevelSizeFromTexture(MTL::Texture *p_tex, NS::UInteger p_level) { + MTL::Size lvlSize; + lvlSize.width = MAX(p_tex->width() >> p_level, 1UL); + lvlSize.height = MAX(p_tex->height() >> p_level, 1UL); + lvlSize.depth = MAX(p_tex->depth() >> p_level, 1UL); + return lvlSize; +} diff --git a/drivers/metal/metal_device_properties.mm b/drivers/metal/metal_device_properties.cpp similarity index 73% rename from drivers/metal/metal_device_properties.mm rename to drivers/metal/metal_device_properties.cpp index 2abec4b401..9806c1c84d 100644 --- a/drivers/metal/metal_device_properties.mm +++ b/drivers/metal/metal_device_properties.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* metal_device_properties.mm */ +/* metal_device_properties.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -48,41 +48,46 @@ /* permissions and limitations under the License. */ /**************************************************************************/ -#import "metal_device_properties.h" +#include "metal_device_properties.h" -#import "metal_utils.h" +#include "metal_utils.h" -#import "servers/rendering/renderer_rd/effects/metal_fx.h" +#include "servers/rendering/renderer_rd/effects/metal_fx.h" -#import -#import -#import -#import +#include +#include +#include + +#include // Common scaling multipliers. #define KIBI (1024) #define MEBI (KIBI * KIBI) #if (TARGET_OS_OSX && __MAC_OS_X_VERSION_MAX_ALLOWED < 140000) || (TARGET_OS_IPHONE && __IPHONE_OS_VERSION_MAX_ALLOWED < 170000) -#define MTLGPUFamilyApple9 (MTLGPUFamily)1009 +constexpr MTL::GPUFamily GPUFamilyApple9 = static_cast(1009); +#else +constexpr MTL::GPUFamily GPUFamilyApple9 = MTL::GPUFamilyApple9; #endif API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(1.0)) -MTLGPUFamily &operator--(MTLGPUFamily &p_family) { - p_family = static_cast(static_cast(p_family) - 1); - if (p_family < MTLGPUFamilyApple1) { - p_family = MTLGPUFamilyApple9; +MTL::GPUFamily &operator--(MTL::GPUFamily &p_family) { + p_family = static_cast(static_cast(p_family) - 1); + if (p_family < MTL::GPUFamilyApple1) { + p_family = GPUFamilyApple9; } return p_family; } -void MetalDeviceProperties::init_features(id p_device) { +void MetalDeviceProperties::init_features(MTL::Device *p_device) { features = {}; - MTLCompileOptions *opts = [MTLCompileOptions new]; - features.msl_max_version = make_msl_version((opts.languageVersion >> 0x10) & 0xff, (opts.languageVersion >> 0x00) & 0xff); + MTL::CompileOptions *opts = MTL::CompileOptions::alloc()->init(); + MTL::LanguageVersion lang_version = opts->languageVersion(); + features.msl_max_version = make_msl_version((static_cast(lang_version) >> 0x10) & 0xff, (static_cast(lang_version) >> 0x00) & 0xff); features.msl_target_version = features.msl_max_version; + opts->release(); if (String version = OS::get_singleton()->get_environment("GODOT_MTL_TARGET_VERSION"); !version.is_empty()) { if (version != "max") { Vector parts = version.split(".", true, 2); @@ -102,55 +107,55 @@ void MetalDeviceProperties::init_features(id p_device) { } } - features.highestFamily = MTLGPUFamilyApple1; - for (MTLGPUFamily family = MTLGPUFamilyApple9; family >= MTLGPUFamilyApple1; --family) { - if ([p_device supportsFamily:family]) { + features.highestFamily = MTL::GPUFamilyApple1; + for (MTL::GPUFamily family = GPUFamilyApple9; family >= MTL::GPUFamilyApple1; --family) { + if (p_device->supportsFamily(family)) { features.highestFamily = family; break; } } - if (@available(macOS 11, iOS 16.4, tvOS 16.4, *)) { - features.supportsBCTextureCompression = p_device.supportsBCTextureCompression; + if (__builtin_available(macOS 11, iOS 16.4, tvOS 16.4, *)) { + features.supportsBCTextureCompression = p_device->supportsBCTextureCompression(); } else { features.supportsBCTextureCompression = false; } #if TARGET_OS_OSX - features.supportsDepth24Stencil8 = p_device.isDepth24Stencil8PixelFormatSupported; + features.supportsDepth24Stencil8 = p_device->isDepth24Stencil8PixelFormatSupported(); #endif - if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) { - features.supports32BitFloatFiltering = p_device.supports32BitFloatFiltering; - features.supports32BitMSAA = p_device.supports32BitMSAA; + if (__builtin_available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) { + features.supports32BitFloatFiltering = p_device->supports32BitFloatFiltering(); + features.supports32BitMSAA = p_device->supports32BitMSAA(); } - if (@available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { + if (__builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { features.supports_gpu_address = true; } features.hostMemoryPageSize = sysconf(_SC_PAGESIZE); for (SampleCount sc = SampleCount1; sc <= SampleCount64; sc <<= 1) { - if ([p_device supportsTextureSampleCount:sc]) { + if (p_device->supportsTextureSampleCount(sc)) { features.supportedSampleCounts |= sc; } } - features.layeredRendering = [p_device supportsFamily:MTLGPUFamilyApple5]; - features.multisampleLayeredRendering = [p_device supportsFamily:MTLGPUFamilyApple7]; - features.tessellationShader = [p_device supportsFamily:MTLGPUFamilyApple3]; - features.imageCubeArray = [p_device supportsFamily:MTLGPUFamilyApple3]; - features.quadPermute = [p_device supportsFamily:MTLGPUFamilyApple4]; - features.simdPermute = [p_device supportsFamily:MTLGPUFamilyApple6]; - features.simdReduction = [p_device supportsFamily:MTLGPUFamilyApple7]; - features.argument_buffers_tier = p_device.argumentBuffersSupport; - features.supports_image_atomic_32_bit = [p_device supportsFamily:MTLGPUFamilyApple6]; - features.supports_image_atomic_64_bit = [p_device supportsFamily:MTLGPUFamilyApple9] || ([p_device supportsFamily:MTLGPUFamilyApple8] && [p_device supportsFamily:MTLGPUFamilyMac2]); + features.layeredRendering = p_device->supportsFamily(MTL::GPUFamilyApple5); + features.multisampleLayeredRendering = p_device->supportsFamily(MTL::GPUFamilyApple7); + features.tessellationShader = p_device->supportsFamily(MTL::GPUFamilyApple3); + features.imageCubeArray = p_device->supportsFamily(MTL::GPUFamilyApple3); + features.quadPermute = p_device->supportsFamily(MTL::GPUFamilyApple4); + features.simdPermute = p_device->supportsFamily(MTL::GPUFamilyApple6); + features.simdReduction = p_device->supportsFamily(MTL::GPUFamilyApple7); + features.argument_buffers_tier = p_device->argumentBuffersSupport(); + features.supports_image_atomic_32_bit = p_device->supportsFamily(MTL::GPUFamilyApple6); + features.supports_image_atomic_64_bit = p_device->supportsFamily(GPUFamilyApple9) || (p_device->supportsFamily(MTL::GPUFamilyApple8) && p_device->supportsFamily(MTL::GPUFamilyMac2)); if (features.msl_target_version >= MSL_VERSION_31) { // Native atomics are only supported on 3.1 and above. - if (@available(macOS 14.0, iOS 17.0, tvOS 17.0, visionOS 1.0, *)) { + if (__builtin_available(macOS 14.0, iOS 17.0, tvOS 17.0, visionOS 1.0, *)) { features.supports_native_image_atomics = true; } } @@ -159,31 +164,31 @@ void MetalDeviceProperties::init_features(id p_device) { features.supports_native_image_atomics = false; } - if (@available(macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 2.0, *)) { + if (__builtin_available(macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 2.0, *)) { features.supports_residency_sets = true; } else { features.supports_residency_sets = false; } - if (@available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { - features.needs_arg_encoders = !([p_device supportsFamily:MTLGPUFamilyMetal3] && features.argument_buffers_tier == MTLArgumentBuffersTier2); + if (__builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { + features.needs_arg_encoders = !(p_device->supportsFamily(MTL::GPUFamilyMetal3) && features.argument_buffers_tier == MTL::ArgumentBuffersTier2); } if (String v = OS::get_singleton()->get_environment("GODOT_MTL_DISABLE_ARGUMENT_BUFFERS"); v == "1") { features.use_argument_buffers = false; } - if (@available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { - features.metal_fx_spatial = [MTLFXSpatialScalerDescriptor supportsDevice:p_device]; + if (__builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { + features.metal_fx_spatial = MTLFX::SpatialScalerDescriptor::supportsDevice(p_device); #ifdef METAL_MFXTEMPORAL_ENABLED - features.metal_fx_temporal = [MTLFXTemporalScalerDescriptor supportsDevice:p_device]; + features.metal_fx_temporal = MTLFX::TemporalScalerDescriptor::supportsDevice(p_device); #else features.metal_fx_temporal = false; #endif } } -void MetalDeviceProperties::init_limits(id p_device) { +void MetalDeviceProperties::init_limits(MTL::Device *p_device) { using std::max; using std::min; @@ -191,7 +196,7 @@ void MetalDeviceProperties::init_limits(id p_device) { // FST: Maximum number of layers per 1D texture array, 2D texture array, or 3D texture. limits.maxImageArrayLayers = 2048; - if ([p_device supportsFamily:MTLGPUFamilyApple3]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple3)) { // FST: Maximum 2D texture width and height. limits.maxFramebufferWidth = 16384; limits.maxFramebufferHeight = 16384; @@ -219,7 +224,7 @@ void MetalDeviceProperties::init_limits(id p_device) { // FST: Maximum 3D texture width, height, and depth. limits.maxImageDimension3D = 2048; - limits.maxThreadsPerThreadGroup = p_device.maxThreadsPerThreadgroup; + limits.maxThreadsPerThreadGroup = p_device->maxThreadsPerThreadgroup(); // No effective limits. limits.maxComputeWorkGroupCount = { std::numeric_limits::max(), std::numeric_limits::max(), std::numeric_limits::max() }; // https://github.com/KhronosGroup/MoltenVK/blob/568cc3acc0e2299931fdaecaaa1fc3ec5b4af281/MoltenVK/MoltenVK/GPUObjects/MVKDevice.h#L85 @@ -228,25 +233,25 @@ void MetalDeviceProperties::init_limits(id p_device) { limits.maxColorAttachments = 8; // Maximum number of textures the device can access, per stage, from an argument buffer. - if ([p_device supportsFamily:MTLGPUFamilyApple6]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple6)) { limits.maxTexturesPerArgumentBuffer = 1'000'000; - } else if ([p_device supportsFamily:MTLGPUFamilyApple4]) { + } else if (p_device->supportsFamily(MTL::GPUFamilyApple4)) { limits.maxTexturesPerArgumentBuffer = 96; } else { limits.maxTexturesPerArgumentBuffer = 31; } // Maximum number of samplers the device can access, per stage, from an argument buffer. - if ([p_device supportsFamily:MTLGPUFamilyApple6]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple6)) { limits.maxSamplersPerArgumentBuffer = 1024; } else { limits.maxSamplersPerArgumentBuffer = 16; } // Maximum number of buffers the device can access, per stage, from an argument buffer. - if ([p_device supportsFamily:MTLGPUFamilyApple6]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple6)) { limits.maxBuffersPerArgumentBuffer = std::numeric_limits::max(); - } else if ([p_device supportsFamily:MTLGPUFamilyApple4]) { + } else if (p_device->supportsFamily(MTL::GPUFamilyApple4)) { limits.maxBuffersPerArgumentBuffer = 96; } else { limits.maxBuffersPerArgumentBuffer = 31; @@ -283,13 +288,13 @@ void MetalDeviceProperties::init_limits(id p_device) { limits.subgroupSupportedOperations.set_flag(RD::SubgroupOperations::SUBGROUP_QUAD_BIT); } - limits.maxBufferLength = p_device.maxBufferLength; + limits.maxBufferLength = p_device->maxBufferLength(); // FST: Maximum size of vertex descriptor layout stride. limits.maxVertexDescriptorLayoutStride = std::numeric_limits::max(); // Maximum number of viewports. - if ([p_device supportsFamily:MTLGPUFamilyApple5]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple5)) { limits.maxViewports = 16; } else { limits.maxViewports = 1; @@ -297,9 +302,9 @@ void MetalDeviceProperties::init_limits(id p_device) { limits.maxPerStageBufferCount = 31; limits.maxPerStageSamplerCount = 16; - if ([p_device supportsFamily:MTLGPUFamilyApple6]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple6)) { limits.maxPerStageTextureCount = 128; - } else if ([p_device supportsFamily:MTLGPUFamilyApple4]) { + } else if (p_device->supportsFamily(MTL::GPUFamilyApple4)) { limits.maxPerStageTextureCount = 96; } else { limits.maxPerStageTextureCount = 31; @@ -310,9 +315,9 @@ void MetalDeviceProperties::init_limits(id p_device) { limits.maxVertexInputBindingStride = (2 * KIBI); limits.maxShaderVaryings = 31; // Accurate on Apple4 and above. See: https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf - if ([p_device supportsFamily:MTLGPUFamilyApple4]) { + if (p_device->supportsFamily(MTL::GPUFamilyApple4)) { limits.maxThreadGroupMemoryAllocation = 32768; - } else if ([p_device supportsFamily:MTLGPUFamilyApple3]) { + } else if (p_device->supportsFamily(MTL::GPUFamilyApple3)) { limits.maxThreadGroupMemoryAllocation = 16384; } else { limits.maxThreadGroupMemoryAllocation = 16352; @@ -330,9 +335,9 @@ void MetalDeviceProperties::init_limits(id p_device) { limits.maxDrawIndexedIndexValue = std::numeric_limits::max() - 1; #ifdef METAL_MFXTEMPORAL_ENABLED - if (@available(macOS 14.0, iOS 17.0, tvOS 17.0, *)) { - limits.temporalScalerInputContentMinScale = (double)[MTLFXTemporalScalerDescriptor supportedInputContentMinScaleForDevice:p_device]; - limits.temporalScalerInputContentMaxScale = (double)[MTLFXTemporalScalerDescriptor supportedInputContentMaxScaleForDevice:p_device]; + if (__builtin_available(macOS 14.0, iOS 17.0, tvOS 17.0, *)) { + limits.temporalScalerInputContentMinScale = MTLFX::TemporalScalerDescriptor::supportedInputContentMinScale(p_device); + limits.temporalScalerInputContentMaxScale = MTLFX::TemporalScalerDescriptor::supportedInputContentMaxScale(p_device); } else { // Defaults taken from macOS 14+ limits.temporalScalerInputContentMinScale = 1.0; @@ -346,11 +351,11 @@ void MetalDeviceProperties::init_limits(id p_device) { } void MetalDeviceProperties::init_os_props() { - NSOperatingSystemVersion ver = NSProcessInfo.processInfo.operatingSystemVersion; + NS::OperatingSystemVersion ver = NS::ProcessInfo::processInfo()->operatingSystemVersion(); os_version = (uint32_t)ver.majorVersion * 10000 + (uint32_t)ver.minorVersion * 100 + (uint32_t)ver.patchVersion; } -MetalDeviceProperties::MetalDeviceProperties(id p_device) { +MetalDeviceProperties::MetalDeviceProperties(MTL::Device *p_device) { init_features(p_device); init_limits(p_device); init_os_props(); diff --git a/drivers/metal/metal_device_properties.h b/drivers/metal/metal_device_properties.h index 447e485de6..e4acc47346 100644 --- a/drivers/metal/metal_device_properties.h +++ b/drivers/metal/metal_device_properties.h @@ -50,16 +50,16 @@ /* permissions and limitations under the License. */ /**************************************************************************/ -#import "servers/rendering/rendering_device.h" +#include "servers/rendering/rendering_device.h" -#import -#import +#include +#include /** The buffer index to use for vertex content. */ const static uint32_t VERT_CONTENT_BUFFER_INDEX = 0; const static uint32_t MAX_COLOR_ATTACHMENT_COUNT = 8; -typedef NS_OPTIONS(NSUInteger, SampleCount) { +enum SampleCount : NS::UInteger { SampleCount1 = (1UL << 0), SampleCount2 = (1UL << 1), SampleCount4 = (1UL << 2), @@ -69,6 +69,22 @@ typedef NS_OPTIONS(NSUInteger, SampleCount) { SampleCount64 = (1UL << 6), }; +_FORCE_INLINE_ SampleCount operator|(SampleCount a, SampleCount b) { + return static_cast(static_cast(a) | static_cast(b)); +} + +_FORCE_INLINE_ SampleCount &operator|=(SampleCount &a, SampleCount b) { + return a = a | b; +} + +_FORCE_INLINE_ SampleCount operator<<(SampleCount a, int shift) { + return static_cast(static_cast(a) << shift); +} + +_FORCE_INLINE_ SampleCount &operator<<=(SampleCount &a, int shift) { + return a = a << shift; +} + struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalFeatures { /// Maximum version of the Metal Shading Language version available. uint32_t msl_max_version = 0; @@ -78,7 +94,7 @@ struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalFeatures { * for engine developers for testing. */ uint32_t msl_target_version = 0; - MTLGPUFamily highestFamily = MTLGPUFamilyApple4; + MTL::GPUFamily highestFamily = MTL::GPUFamilyApple4; bool supportsBCTextureCompression = false; bool supportsDepth24Stencil8 = false; bool supports32BitFloatFiltering = false; @@ -93,7 +109,7 @@ struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalFeatures { bool simdReduction = false; /**< If true, SIMD-group reduction functions (arithmetic) are supported in shaders. */ bool tessellationShader = false; /**< If true, tessellation shaders are supported. */ bool imageCubeArray = false; /**< If true, image cube arrays are supported. */ - MTLArgumentBuffersTier argument_buffers_tier = MTLArgumentBuffersTier1; + MTL::ArgumentBuffersTier argument_buffers_tier = MTL::ArgumentBuffersTier1; bool needs_arg_encoders = true; /**< If true, argument encoders are required to encode arguments into an argument buffer. */ bool use_argument_buffers = true; /**< If true, argument buffers are can be used instead of slot binding, if available. */ bool metal_fx_spatial = false; /**< If true, Metal FX spatial functions are supported. */ @@ -108,7 +124,7 @@ struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalFeatures { * Check if argument buffers are fully supported, which requires tier 2 support and no need for argument encoders. */ _FORCE_INLINE_ bool argument_buffers_supported() const { - return argument_buffers_tier == MTLArgumentBuffersTier2 && needs_arg_encoders == false; + return argument_buffers_tier == MTL::ArgumentBuffersTier2 && needs_arg_encoders == false; } /*! @@ -129,8 +145,8 @@ struct MetalLimits { uint64_t maxImageDimensionCube; uint64_t maxViewportDimensionX; uint64_t maxViewportDimensionY; - MTLSize maxThreadsPerThreadGroup; - MTLSize maxComputeWorkGroupCount; + MTL::Size maxThreadsPerThreadGroup; + MTL::Size maxComputeWorkGroupCount; uint64_t maxBoundDescriptorSets; uint64_t maxColorAttachments; uint64_t maxTexturesPerArgumentBuffer; @@ -161,8 +177,8 @@ struct MetalLimits { class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalDeviceProperties { private: - void init_features(id p_device); - void init_limits(id p_device); + void init_features(MTL::Device *p_device); + void init_limits(MTL::Device *p_device); void init_os_props(); public: @@ -174,7 +190,7 @@ public: SampleCount find_nearest_supported_sample_count(RenderingDevice::TextureSamples p_samples) const; - MetalDeviceProperties(id p_device); + MetalDeviceProperties(MTL::Device *p_device); ~MetalDeviceProperties(); private: diff --git a/drivers/metal/metal_objects.h b/drivers/metal/metal_objects.h deleted file mode 100644 index 1d3d512f55..0000000000 --- a/drivers/metal/metal_objects.h +++ /dev/null @@ -1,1086 +0,0 @@ -/**************************************************************************/ -/* metal_objects.h */ -/**************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/**************************************************************************/ -/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ -/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/**************************************************************************/ - -#pragma once - -/**************************************************************************/ -/* */ -/* Portions of this code were derived from MoltenVK. */ -/* */ -/* Copyright (c) 2015-2023 The Brenwill Workshop Ltd. */ -/* (http://www.brenwill.com) */ -/* */ -/* Licensed under the Apache License, Version 2.0 (the "License"); */ -/* you may not use this file except in compliance with the License. */ -/* You may obtain a copy of the License at */ -/* */ -/* http://www.apache.org/licenses/LICENSE-2.0 */ -/* */ -/* Unless required by applicable law or agreed to in writing, software */ -/* distributed under the License is distributed on an "AS IS" BASIS, */ -/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ -/* implied. See the License for the specific language governing */ -/* permissions and limitations under the License. */ -/**************************************************************************/ - -#import "metal_device_properties.h" -#import "metal_objects_shared.h" -#import "metal_utils.h" -#import "pixel_formats.h" -#import "sha256_digest.h" - -#include "servers/rendering/rendering_device_driver.h" - -#import -#import -#import -#import -#import -#import -#import -#import -#import - -enum StageResourceUsage : uint32_t { - ResourceUnused = 0, - VertexRead = (MTLResourceUsageRead << RDD::SHADER_STAGE_VERTEX * 2), - VertexWrite = (MTLResourceUsageWrite << RDD::SHADER_STAGE_VERTEX * 2), - FragmentRead = (MTLResourceUsageRead << RDD::SHADER_STAGE_FRAGMENT * 2), - FragmentWrite = (MTLResourceUsageWrite << RDD::SHADER_STAGE_FRAGMENT * 2), - TesselationControlRead = (MTLResourceUsageRead << RDD::SHADER_STAGE_TESSELATION_CONTROL * 2), - TesselationControlWrite = (MTLResourceUsageWrite << RDD::SHADER_STAGE_TESSELATION_CONTROL * 2), - TesselationEvaluationRead = (MTLResourceUsageRead << RDD::SHADER_STAGE_TESSELATION_EVALUATION * 2), - TesselationEvaluationWrite = (MTLResourceUsageWrite << RDD::SHADER_STAGE_TESSELATION_EVALUATION * 2), - ComputeRead = (MTLResourceUsageRead << RDD::SHADER_STAGE_COMPUTE * 2), - ComputeWrite = (MTLResourceUsageWrite << RDD::SHADER_STAGE_COMPUTE * 2), -}; - -typedef id __unsafe_unretained MTLResourceUnsafe; - -template <> -struct HashMapHasherDefaultImpl { - static _FORCE_INLINE_ uint32_t hash(const MTLResourceUnsafe p_pointer) { return hash_one_uint64((uint64_t)p_pointer); } -}; - -typedef LocalVector ResourceVector; -typedef HashMap ResourceUsageMap; - -struct ResourceUsageEntry { - StageResourceUsage usage = ResourceUnused; - uint32_t unused = 0; - - ResourceUsageEntry() {} - ResourceUsageEntry(StageResourceUsage p_usage) : - usage(p_usage) {} -}; - -template <> -struct is_zero_constructible : std::true_type {}; - -/*! Track the cumulative usage for a resource during a render or compute pass */ -typedef HashMap ResourceToStageUsage; - -/*! Track resource and ensure they are resident prior to dispatch or draw commands. - * - * The primary purpose of this data structure is to track all the resources that must be made resident prior - * to issuing the next dispatch or draw command. It aggregates all resources used from argument buffers. - * - * As an optimization, this data structure also tracks previous usage for resources, so that - * it may avoid binding them again in later commands if the resource is already resident and its usage flagged. - */ -struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) ResourceTracker { - // A constant specifying how many iterations a resource can remain in - // the _previous HashSet before it will be removed permanently. - // - // Keeping them in the _previous HashMap reduces churn if resources are regularly - // bound. 256 is arbitrary, but if an object remains unused for 256 encoders, - // it will be released. - static constexpr uint32_t RESOURCE_UNUSED_CLEANUP_COUNT = 256; - - // Used as a scratch buffer to periodically clean up resources from _previous. - ResourceVector _scratch; - // Tracks all resources and their prior usage for the duration of the encoder. - ResourceToStageUsage _previous; - // Tracks resources for the current command that must be made resident - ResourceUsageMap _current; - - void merge_from(const ResourceUsageMap &p_from); - void encode(id __unsafe_unretained p_enc); - void encode(id __unsafe_unretained p_enc); - void reset(); -}; - -enum class MDCommandBufferStateType { - None, - Render, - Compute, - Blit, -}; - -enum class MDPipelineType { - None, - Render, - Compute, -}; - -class MDRenderPass; -class MDPipeline; -class MDRenderPipeline; -class MDComputePipeline; -class RenderingDeviceDriverMetal; -class MDUniformSet; -class MDShader; - -struct MetalBufferDynamicInfo; - -using RDM = RenderingDeviceDriverMetal; - -#pragma mark - Resource Factory - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDResourceFactory { -private: - RenderingDeviceDriverMetal *device_driver; - - id new_func(NSString *p_source, NSString *p_name, NSError **p_error); - id new_clear_vert_func(ClearAttKey &p_key); - id new_clear_frag_func(ClearAttKey &p_key); - NSString *get_format_type_string(MTLPixelFormat p_fmt); - -public: - id new_clear_pipeline_state(ClearAttKey &p_key, NSError **p_error); - id new_depth_stencil_state(bool p_use_depth, bool p_use_stencil); - - MDResourceFactory(RenderingDeviceDriverMetal *p_device_driver) : - device_driver(p_device_driver) {} - ~MDResourceFactory() = default; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDResourceCache { -private: - typedef HashMap> HashMap; - std::unique_ptr resource_factory; - HashMap clear_states; - - struct { - id all; - id depth_only; - id stencil_only; - id none; - } clear_depth_stencil_state; - -public: - id get_clear_render_pipeline_state(ClearAttKey &p_key, NSError **p_error); - id get_depth_stencil_state(bool p_use_depth, bool p_use_stencil); - - explicit MDResourceCache(RenderingDeviceDriverMetal *p_device_driver) : - resource_factory(new MDResourceFactory(p_device_driver)) {} - ~MDResourceCache() = default; -}; - -enum class MDAttachmentType : uint8_t { - None = 0, - Color = 1 << 0, - Depth = 1 << 1, - Stencil = 1 << 2, -}; - -_FORCE_INLINE_ MDAttachmentType &operator|=(MDAttachmentType &p_a, MDAttachmentType p_b) { - flags::set(p_a, p_b); - return p_a; -} - -_FORCE_INLINE_ bool operator&(MDAttachmentType p_a, MDAttachmentType p_b) { - return uint8_t(p_a) & uint8_t(p_b); -} - -struct MDSubpass { - uint32_t subpass_index = 0; - uint32_t view_count = 0; - LocalVector input_references; - LocalVector color_references; - RDD::AttachmentReference depth_stencil_reference; - LocalVector resolve_references; - - MTLFmtCaps getRequiredFmtCapsForAttachmentAt(uint32_t p_index) const; -}; - -struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDAttachment { -private: - uint32_t index = 0; - uint32_t firstUseSubpassIndex = 0; - uint32_t lastUseSubpassIndex = 0; - -public: - MTLPixelFormat format = MTLPixelFormatInvalid; - MDAttachmentType type = MDAttachmentType::None; - MTLLoadAction loadAction = MTLLoadActionDontCare; - MTLStoreAction storeAction = MTLStoreActionDontCare; - MTLLoadAction stencilLoadAction = MTLLoadActionDontCare; - MTLStoreAction stencilStoreAction = MTLStoreActionDontCare; - uint32_t samples = 1; - - /*! - * @brief Returns true if this attachment is first used in the given subpass. - * @param p_subpass - * @return - */ - _FORCE_INLINE_ bool isFirstUseOf(MDSubpass const &p_subpass) const { - return p_subpass.subpass_index == firstUseSubpassIndex; - } - - /*! - * @brief Returns true if this attachment is last used in the given subpass. - * @param p_subpass - * @return - */ - _FORCE_INLINE_ bool isLastUseOf(MDSubpass const &p_subpass) const { - return p_subpass.subpass_index == lastUseSubpassIndex; - } - - void linkToSubpass(MDRenderPass const &p_pass); - - MTLStoreAction getMTLStoreAction(MDSubpass const &p_subpass, - bool p_is_rendering_entire_area, - bool p_has_resolve, - bool p_can_resolve, - bool p_is_stencil) const; - bool configureDescriptor(MTLRenderPassAttachmentDescriptor *p_desc, - PixelFormats &p_pf, - MDSubpass const &p_subpass, - id p_attachment, - bool p_is_rendering_entire_area, - bool p_has_resolve, - bool p_can_resolve, - bool p_is_stencil) const; - /** Returns whether this attachment should be cleared in the subpass. */ - bool shouldClear(MDSubpass const &p_subpass, bool p_is_stencil) const; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDRenderPass { -public: - Vector attachments; - Vector subpasses; - - uint32_t get_sample_count() const { - return attachments.is_empty() ? 1 : attachments[0].samples; - } - - MDRenderPass(Vector &p_attachments, Vector &p_subpasses); -}; - -struct BindingCache { - struct BufferBinding { - id __unsafe_unretained buffer = nil; - NSUInteger offset = 0; - - bool operator!=(const BufferBinding &p_other) const { - return buffer != p_other.buffer || offset != p_other.offset; - } - }; - - LocalVector __unsafe_unretained> textures; - LocalVector __unsafe_unretained> samplers; - LocalVector buffers; - - _FORCE_INLINE_ void clear() { - textures.clear(); - samplers.clear(); - buffers.clear(); - } - -private: - template - _FORCE_INLINE_ void ensure_size(LocalVector &p_vec, uint32_t p_required) { - if (p_vec.size() < p_required) { - p_vec.resize_initialized(p_required); - } - } - -public: - _FORCE_INLINE_ bool update(NSRange p_range, id __unsafe_unretained const *p_values) { - if (p_range.length == 0) { - return false; - } - uint32_t required = (uint32_t)(p_range.location + p_range.length); - ensure_size(textures, required); - bool changed = false; - for (NSUInteger i = 0; i < p_range.length; ++i) { - uint32_t slot = (uint32_t)(p_range.location + i); - id value = p_values[i]; - if (textures[slot] != value) { - textures[slot] = value; - changed = true; - } - } - return changed; - } - - _FORCE_INLINE_ bool update(NSRange p_range, id __unsafe_unretained const *p_values) { - if (p_range.length == 0) { - return false; - } - uint32_t required = (uint32_t)(p_range.location + p_range.length); - ensure_size(samplers, required); - bool changed = false; - for (NSUInteger i = 0; i < p_range.length; ++i) { - uint32_t slot = (uint32_t)(p_range.location + i); - id __unsafe_unretained value = p_values[i]; - if (samplers[slot] != value) { - samplers[slot] = value; - changed = true; - } - } - return changed; - } - - _FORCE_INLINE_ bool update(NSRange p_range, id __unsafe_unretained const *p_values, const NSUInteger *p_offsets) { - if (p_range.length == 0) { - return false; - } - uint32_t required = (uint32_t)(p_range.location + p_range.length); - ensure_size(buffers, required); - BufferBinding *buffers_ptr = buffers.ptr() + p_range.location; - bool changed = false; - for (NSUInteger i = 0; i < p_range.length; ++i) { - BufferBinding &binding = *buffers_ptr; - BufferBinding new_binding = { - .buffer = p_values[i], - .offset = p_offsets[i], - }; - if (binding != new_binding) { - binding = new_binding; - changed = true; - } - ++buffers_ptr; - } - return changed; - } - - _FORCE_INLINE_ bool update(id __unsafe_unretained p_buffer, NSUInteger p_offset, uint32_t p_index) { - uint32_t required = p_index + 1; - ensure_size(buffers, required); - BufferBinding &binding = buffers.ptr()[p_index]; - BufferBinding new_binding = { - .buffer = p_buffer, - .offset = p_offset, - }; - if (binding != new_binding) { - binding = new_binding; - return true; - } - return false; - } -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDCommandBuffer { - friend class MDUniformSet; - -private: -#pragma mark - Common State - - // From RenderingDevice - static constexpr uint32_t MAX_PUSH_CONSTANT_SIZE = 128; - - uint8_t push_constant_data[MAX_PUSH_CONSTANT_SIZE]; - uint32_t push_constant_data_len = 0; - uint32_t push_constant_binding = UINT32_MAX; - - BindingCache binding_cache; - - void reset(); - - RenderingDeviceDriverMetal *device_driver = nullptr; - id queue = nil; - id commandBuffer = nil; - bool state_begin = false; - - _FORCE_INLINE_ id command_buffer() { - DEV_ASSERT(state_begin); - if (commandBuffer == nil) { - commandBuffer = queue.commandBuffer; - } - return commandBuffer; - } - - void _end_compute_dispatch(); - void _end_blit(); - id _ensure_blit_encoder(); - - enum class CopySource { - Buffer, - Texture, - }; - void _copy_texture_buffer(CopySource p_source, - RDD::TextureID p_texture, - RDD::BufferID p_buffer, - VectorView p_regions); - -#pragma mark - Render - - void _render_set_dirty_state(); - void _render_bind_uniform_sets(); - - void _populate_vertices(simd::float4 *p_vertices, Size2i p_fb_size, VectorView p_rects); - uint32_t _populate_vertices(simd::float4 *p_vertices, uint32_t p_index, Rect2i const &p_rect, Size2i p_fb_size); - void _end_render_pass(); - void _render_clear_render_area(); - -#pragma mark - Compute - - void _compute_set_dirty_state(); - void _compute_bind_uniform_sets(); - -public: - MDCommandBufferStateType type = MDCommandBufferStateType::None; - - struct RenderState { - MDRenderPass *pass = nullptr; - MDFrameBuffer *frameBuffer = nullptr; - MDRenderPipeline *pipeline = nullptr; - LocalVector clear_values; - LocalVector viewports; - LocalVector scissors; - std::optional blend_constants; - uint32_t current_subpass = UINT32_MAX; - Rect2i render_area = {}; - bool is_rendering_entire_area = false; - MTLRenderPassDescriptor *desc = nil; - id encoder = nil; - id __unsafe_unretained index_buffer = nil; // Buffer is owned by RDD. - MTLIndexType index_type = MTLIndexTypeUInt16; - uint32_t index_offset = 0; - LocalVector __unsafe_unretained> vertex_buffers; - LocalVector vertex_offsets; - ResourceTracker resource_tracker; - // clang-format off - enum DirtyFlag: uint16_t { - DIRTY_NONE = 0, - DIRTY_PIPELINE = 1 << 0, //! pipeline state - DIRTY_UNIFORMS = 1 << 1, //! uniform sets - DIRTY_PUSH = 1 << 2, //! push constants - DIRTY_DEPTH = 1 << 3, //! depth / stencil state - DIRTY_VERTEX = 1 << 4, //! vertex buffers - DIRTY_VIEWPORT = 1 << 5, //! viewport rectangles - DIRTY_SCISSOR = 1 << 6, //! scissor rectangles - DIRTY_BLEND = 1 << 7, //! blend state - DIRTY_RASTER = 1 << 8, //! encoder state like cull mode - DIRTY_ALL = (1 << 9) - 1, - }; - // clang-format on - BitField dirty = DIRTY_NONE; - - LocalVector uniform_sets; - uint32_t dynamic_offsets = 0; - // Bit mask of the uniform sets that are dirty, to prevent redundant binding. - uint64_t uniform_set_mask = 0; - - _FORCE_INLINE_ void reset(); - void end_encoding(); - - _ALWAYS_INLINE_ const MDSubpass &get_subpass() const { - DEV_ASSERT(pass != nullptr); - return pass->subpasses[current_subpass]; - } - - _FORCE_INLINE_ void mark_viewport_dirty() { - if (viewports.is_empty()) { - return; - } - dirty.set_flag(DirtyFlag::DIRTY_VIEWPORT); - } - - _FORCE_INLINE_ void mark_scissors_dirty() { - if (scissors.is_empty()) { - return; - } - dirty.set_flag(DirtyFlag::DIRTY_SCISSOR); - } - - _FORCE_INLINE_ void mark_vertex_dirty() { - if (vertex_buffers.is_empty()) { - return; - } - dirty.set_flag(DirtyFlag::DIRTY_VERTEX); - } - - _FORCE_INLINE_ void mark_uniforms_dirty(std::initializer_list l) { - if (uniform_sets.is_empty()) { - return; - } - for (uint32_t i : l) { - if (i < uniform_sets.size() && uniform_sets[i] != nullptr) { - uniform_set_mask |= 1 << i; - } - } - dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); - } - - _FORCE_INLINE_ void mark_uniforms_dirty(void) { - if (uniform_sets.is_empty()) { - return; - } - for (uint32_t i = 0; i < uniform_sets.size(); i++) { - if (uniform_sets[i] != nullptr) { - uniform_set_mask |= 1 << i; - } - } - dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); - } - - _FORCE_INLINE_ void mark_blend_dirty() { - if (!blend_constants.has_value()) { - return; - } - dirty.set_flag(DirtyFlag::DIRTY_BLEND); - } - - MTLScissorRect clip_to_render_area(MTLScissorRect p_rect) const { - uint32_t raLeft = render_area.position.x; - uint32_t raRight = raLeft + render_area.size.width; - uint32_t raBottom = render_area.position.y; - uint32_t raTop = raBottom + render_area.size.height; - - p_rect.x = CLAMP(p_rect.x, raLeft, MAX(raRight - 1, raLeft)); - p_rect.y = CLAMP(p_rect.y, raBottom, MAX(raTop - 1, raBottom)); - p_rect.width = MIN(p_rect.width, raRight - p_rect.x); - p_rect.height = MIN(p_rect.height, raTop - p_rect.y); - - return p_rect; - } - - Rect2i clip_to_render_area(Rect2i p_rect) const { - int32_t raLeft = render_area.position.x; - int32_t raRight = raLeft + render_area.size.width; - int32_t raBottom = render_area.position.y; - int32_t raTop = raBottom + render_area.size.height; - - p_rect.position.x = CLAMP(p_rect.position.x, raLeft, MAX(raRight - 1, raLeft)); - p_rect.position.y = CLAMP(p_rect.position.y, raBottom, MAX(raTop - 1, raBottom)); - p_rect.size.width = MIN(p_rect.size.width, raRight - p_rect.position.x); - p_rect.size.height = MIN(p_rect.size.height, raTop - p_rect.position.y); - - return p_rect; - } - - } render; - - // State specific for a compute pass. - struct ComputeState { - MDComputePipeline *pipeline = nullptr; - id encoder = nil; - ResourceTracker resource_tracker; - // clang-format off - enum DirtyFlag: uint16_t { - DIRTY_NONE = 0, - DIRTY_PIPELINE = 1 << 0, //! pipeline state - DIRTY_UNIFORMS = 1 << 1, //! uniform sets - DIRTY_PUSH = 1 << 2, //! push constants - DIRTY_ALL = (1 << 3) - 1, - }; - // clang-format on - BitField dirty = DIRTY_NONE; - - LocalVector uniform_sets; - uint32_t dynamic_offsets = 0; - // Bit mask of the uniform sets that are dirty, to prevent redundant binding. - uint64_t uniform_set_mask = 0; - - _FORCE_INLINE_ void reset(); - void end_encoding(); - - _FORCE_INLINE_ void mark_uniforms_dirty(void) { - if (uniform_sets.is_empty()) { - return; - } - for (uint32_t i = 0; i < uniform_sets.size(); i++) { - if (uniform_sets[i] != nullptr) { - uniform_set_mask |= 1 << i; - } - } - dirty.set_flag(DirtyFlag::DIRTY_UNIFORMS); - } - } compute; - - // State specific to a blit pass. - struct { - id encoder = nil; - _FORCE_INLINE_ void reset() { - encoder = nil; - } - } blit; - - _FORCE_INLINE_ id get_command_buffer() const { - return commandBuffer; - } - - void begin(); - void commit(); - void end(); - - void bind_pipeline(RDD::PipelineID p_pipeline); - void encode_push_constant_data(RDD::ShaderID p_shader, VectorView p_data); - -#pragma mark - Render Commands - - void render_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets); - void render_clear_attachments(VectorView p_attachment_clears, VectorView p_rects); - void render_set_viewport(VectorView p_viewports); - void render_set_scissor(VectorView p_scissors); - void render_set_blend_constants(const Color &p_constants); - void render_begin_pass(RDD::RenderPassID p_render_pass, - RDD::FramebufferID p_frameBuffer, - RDD::CommandBufferType p_cmd_buffer_type, - const Rect2i &p_rect, - VectorView p_clear_values); - void render_next_subpass(); - void render_draw(uint32_t p_vertex_count, - uint32_t p_instance_count, - uint32_t p_base_vertex, - uint32_t p_first_instance); - void render_bind_vertex_buffers(uint32_t p_binding_count, const RDD::BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets); - void render_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint64_t p_offset); - - void render_draw_indexed(uint32_t p_index_count, - uint32_t p_instance_count, - uint32_t p_first_index, - int32_t p_vertex_offset, - uint32_t p_first_instance); - - void render_draw_indexed_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride); - void render_draw_indexed_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride); - void render_draw_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride); - void render_draw_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride); - - void render_end_pass(); - -#pragma mark - Compute Commands - - void compute_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets); - void compute_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups); - void compute_dispatch_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset); - -#pragma mark - Transfer - -private: - void encodeRenderCommandEncoderWithDescriptor(MTLRenderPassDescriptor *p_desc, NSString *p_label); - -public: - void resolve_texture(RDD::TextureID p_src_texture, RDD::TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, RDD::TextureID p_dst_texture, RDD::TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap); - void clear_color_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, const Color &p_color, const RDD::TextureSubresourceRange &p_subresources); - void clear_depth_stencil_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const RDD::TextureSubresourceRange &p_subresources); - void clear_buffer(RDD::BufferID p_buffer, uint64_t p_offset, uint64_t p_size); - void copy_buffer(RDD::BufferID p_src_buffer, RDD::BufferID p_dst_buffer, VectorView p_regions); - void copy_texture(RDD::TextureID p_src_texture, RDD::TextureID p_dst_texture, VectorView p_regions); - void copy_buffer_to_texture(RDD::BufferID p_src_buffer, RDD::TextureID p_dst_texture, VectorView p_regions); - void copy_texture_to_buffer(RDD::TextureID p_src_texture, RDD::BufferID p_dst_buffer, VectorView p_regions); - -#pragma mark - Debugging - - void begin_label(const char *p_label_name, const Color &p_color); - void end_label(); - - MDCommandBuffer(id p_queue, RenderingDeviceDriverMetal *p_device_driver) : - device_driver(p_device_driver), queue(p_queue) { - type = MDCommandBufferStateType::None; - } - - MDCommandBuffer() = default; -}; - -#if (TARGET_OS_OSX && __MAC_OS_X_VERSION_MAX_ALLOWED < 140000) || (TARGET_OS_IOS && __IPHONE_OS_VERSION_MAX_ALLOWED < 170000) -#define MTLBindingAccess MTLArgumentAccess -#define MTLBindingAccessReadOnly MTLArgumentAccessReadOnly -#define MTLBindingAccessReadWrite MTLArgumentAccessReadWrite -#define MTLBindingAccessWriteOnly MTLArgumentAccessWriteOnly -#endif - -struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) UniformInfo { - uint32_t binding; - BitField active_stages; - MTLDataType dataType = MTLDataTypeNone; - MTLBindingAccess access = MTLBindingAccessReadOnly; - MTLResourceUsage usage = 0; - MTLTextureType textureType = MTLTextureType2D; - uint32_t imageFormat = 0; - uint32_t arrayLength = 0; - bool isMultisampled = 0; - - struct Indexes { - uint32_t buffer = UINT32_MAX; - uint32_t texture = UINT32_MAX; - uint32_t sampler = UINT32_MAX; - }; - Indexes slot; - Indexes arg_buffer; - - enum class IndexType { - SLOT, - ARG, - }; - - _FORCE_INLINE_ Indexes &get_indexes(IndexType p_type) { - switch (p_type) { - case IndexType::SLOT: - return slot; - case IndexType::ARG: - return arg_buffer; - } - } -}; - -struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) UniformSet { - LocalVector uniforms; - LocalVector dynamic_uniforms; - uint32_t buffer_size = 0; -}; - -struct ShaderCacheEntry; - -enum class ShaderLoadStrategy { - IMMEDIATE, - LAZY, - - /// The default strategy is to load the shader immediately. - DEFAULT = IMMEDIATE, -}; - -/// A Metal shader library. -@interface MDLibrary : NSObject { - ShaderCacheEntry *_entry; - NSString *_original_source; -}; -- (id)library; -- (NSError *)error; -- (void)setLabel:(NSString *)label; -#ifdef DEV_ENABLED -- (NSString *)originalSource; -#endif - -+ (instancetype)newLibraryWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options - strategy:(ShaderLoadStrategy)strategy; - -+ (instancetype)newLibraryWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device -#ifdef DEV_ENABLED - source:(NSString *)source -#endif - data:(dispatch_data_t)data; -@end - -/// A cache entry for a Metal shader library. -struct ShaderCacheEntry { - RenderingDeviceDriverMetal &owner; - /// A hash of the Metal shader source code. - SHA256Digest key; - CharString name; - RD::ShaderStage stage = RD::SHADER_STAGE_VERTEX; - /// This reference must be weak, to ensure that when the last strong reference to the library - /// is released, the cache entry is freed. - MDLibrary *__weak library = nil; - - /// Notify the cache that this entry is no longer needed. - void notify_free() const; - - ShaderCacheEntry(RenderingDeviceDriverMetal &p_owner, SHA256Digest p_key) : - owner(p_owner), key(p_key) { - } - ~ShaderCacheEntry() = default; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) DynamicOffsetLayout { - struct Data { - uint8_t offset : 4; - uint8_t count : 4; - }; - - union { - Data data[MAX_DYNAMIC_BUFFERS]; - uint64_t _val = 0; - }; - -public: - _FORCE_INLINE_ bool is_empty() const { return _val == 0; } - - _FORCE_INLINE_ uint32_t get_count(uint32_t p_set_index) const { - return data[p_set_index].count; - } - - _FORCE_INLINE_ uint32_t get_offset(uint32_t p_set_index) const { - return data[p_set_index].offset; - } - - _FORCE_INLINE_ void set_offset_count(uint32_t p_set_index, uint8_t p_offset, uint8_t p_count) { - data[p_set_index].offset = p_offset; - data[p_set_index].count = p_count; - } - - _FORCE_INLINE_ uint32_t get_offset_index_shift(uint32_t p_set_index, uint32_t p_dynamic_index = 0) const { - return (data[p_set_index].offset + p_dynamic_index) * 4u; - } -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDShader { -public: - CharString name; - Vector sets; - struct { - BitField stages = {}; - uint32_t binding = UINT32_MAX; - uint32_t size = 0; - } push_constants; - DynamicOffsetLayout dynamic_offset_layout; - bool uses_argument_buffers = true; - - MDShader(CharString p_name, Vector p_sets, bool p_uses_argument_buffers) : - name(p_name), sets(p_sets), uses_argument_buffers(p_uses_argument_buffers) {} - virtual ~MDShader() = default; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDComputeShader final : public MDShader { -public: - MTLSize local = {}; - - MDLibrary *kernel; - - MDComputeShader(CharString p_name, Vector p_sets, bool p_uses_argument_buffers, MDLibrary *p_kernel); -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDRenderShader final : public MDShader { -public: - bool needs_view_mask_buffer = false; - - MDLibrary *vert; - MDLibrary *frag; - - MDRenderShader(CharString p_name, - Vector p_sets, - bool p_needs_view_mask_buffer, - bool p_uses_argument_buffers, - MDLibrary *p_vert, MDLibrary *p_frag); -}; - -_FORCE_INLINE_ StageResourceUsage &operator|=(StageResourceUsage &p_a, uint32_t p_b) { - p_a = StageResourceUsage(uint32_t(p_a) | p_b); - return p_a; -} - -_FORCE_INLINE_ StageResourceUsage stage_resource_usage(RDC::ShaderStage p_stage, MTLResourceUsage p_usage) { - return StageResourceUsage(p_usage << (p_stage * 2)); -} - -_FORCE_INLINE_ MTLResourceUsage resource_usage_for_stage(StageResourceUsage p_usage, RDC::ShaderStage p_stage) { - return MTLResourceUsage((p_usage >> (p_stage * 2)) & 0b11); -} - -template <> -struct HashMapComparatorDefault { - static bool compare(const RDD::ShaderID &p_lhs, const RDD::ShaderID &p_rhs) { - return p_lhs.id == p_rhs.id; - } -}; - -template <> -struct HashMapComparatorDefault { - static bool compare(const RDD::BufferID &p_lhs, const RDD::BufferID &p_rhs) { - return p_lhs.id == p_rhs.id; - } -}; - -template <> -struct HashMapComparatorDefault { - static bool compare(const RDD::TextureID &p_lhs, const RDD::TextureID &p_rhs) { - return p_lhs.id == p_rhs.id; - } -}; - -template <> -struct HashMapHasherDefaultImpl { - static _FORCE_INLINE_ uint32_t hash(const RDD::BufferID &p_value) { - return HashMapHasherDefaultImpl::hash(p_value.id); - } -}; - -template <> -struct HashMapHasherDefaultImpl { - static _FORCE_INLINE_ uint32_t hash(const RDD::TextureID &p_value) { - return HashMapHasherDefaultImpl::hash(p_value.id); - } -}; - -// A type used to encode resources directly to a MTLCommandEncoder -struct DirectEncoder { - id __unsafe_unretained encoder; - BindingCache &cache; - enum Mode { - RENDER, - COMPUTE - }; - Mode mode; - - void set(id __unsafe_unretained *p_buffers, const NSUInteger *p_offsets, NSRange p_range); - void set(id __unsafe_unretained p_buffer, const NSUInteger p_offset, uint32_t p_index); - void set(id __unsafe_unretained *p_textures, NSRange p_range); - void set(id __unsafe_unretained *p_samplers, NSRange p_range); - - DirectEncoder(id __unsafe_unretained p_encoder, BindingCache &p_cache) : - encoder(p_encoder), cache(p_cache) { - if ([p_encoder conformsToProtocol:@protocol(MTLRenderCommandEncoder)]) { - mode = RENDER; - } else { - mode = COMPUTE; - } - } -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDUniformSet { -public: - uint32_t index = 0; - id arg_buffer = nil; - ResourceUsageMap usage_to_resources; - LocalVector uniforms; - - void bind_uniforms_argument_buffers(MDShader *p_shader, MDCommandBuffer::RenderState &p_state, uint32_t p_set_index, uint32_t p_dynamic_offsets, uint32_t p_frame_idx, uint32_t p_frame_count); - void bind_uniforms_argument_buffers(MDShader *p_shader, MDCommandBuffer::ComputeState &p_state, uint32_t p_set_index, uint32_t p_dynamic_offsets, uint32_t p_frame_idx, uint32_t p_frame_count); - void bind_uniforms_direct(MDShader *p_shader, DirectEncoder p_enc, uint32_t p_set_index, uint32_t p_dynamic_offsets); -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDPipeline { -public: - MDPipelineType type; - - explicit MDPipeline(MDPipelineType p_type) : - type(p_type) {} - virtual ~MDPipeline() = default; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDRenderPipeline final : public MDPipeline { -public: - id state = nil; - id depth_stencil = nil; - uint32_t push_constant_size = 0; - uint32_t push_constant_stages_mask = 0; - SampleCount sample_count = SampleCount1; - - struct { - MTLCullMode cull_mode = MTLCullModeNone; - MTLTriangleFillMode fill_mode = MTLTriangleFillModeFill; - MTLDepthClipMode clip_mode = MTLDepthClipModeClip; - MTLWinding winding = MTLWindingClockwise; - MTLPrimitiveType render_primitive = MTLPrimitiveTypePoint; - - struct { - bool enabled = false; - } depth_test; - - struct { - bool enabled = false; - float depth_bias = 0.0; - float slope_scale = 0.0; - float clamp = 0.0; - _FORCE_INLINE_ void apply(id __unsafe_unretained p_enc) const { - if (!enabled) { - return; - } - [p_enc setDepthBias:depth_bias slopeScale:slope_scale clamp:clamp]; - } - } depth_bias; - - struct { - bool enabled = false; - uint32_t front_reference = 0; - uint32_t back_reference = 0; - _FORCE_INLINE_ void apply(id __unsafe_unretained p_enc) const { - if (!enabled) { - return; - } - [p_enc setStencilFrontReferenceValue:front_reference backReferenceValue:back_reference]; - } - } stencil; - - struct { - bool enabled = false; - float r = 0.0; - float g = 0.0; - float b = 0.0; - float a = 0.0; - - _FORCE_INLINE_ void apply(id __unsafe_unretained p_enc) const { - //if (!enabled) - // return; - [p_enc setBlendColorRed:r green:g blue:b alpha:a]; - } - } blend; - - _FORCE_INLINE_ void apply(id __unsafe_unretained p_enc) const { - [p_enc setCullMode:cull_mode]; - [p_enc setTriangleFillMode:fill_mode]; - [p_enc setDepthClipMode:clip_mode]; - [p_enc setFrontFacingWinding:winding]; - depth_bias.apply(p_enc); - stencil.apply(p_enc); - blend.apply(p_enc); - } - - } raster_state; - - MDRenderShader *shader = nil; - - MDRenderPipeline() : - MDPipeline(MDPipelineType::Render) {} - ~MDRenderPipeline() final = default; -}; - -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDComputePipeline final : public MDPipeline { -public: - id state = nil; - struct { - MTLSize local = {}; - } compute_state; - - MDComputeShader *shader = nil; - - explicit MDComputePipeline(id p_state) : - MDPipeline(MDPipelineType::Compute), state(p_state) {} - ~MDComputePipeline() final = default; -}; - -namespace rid { -#define MAKE_ID(FROM, TO) \ - _FORCE_INLINE_ TO make(FROM p_obj) { \ - return TO(owned(p_obj)); \ - } - -MAKE_ID(id, RDD::CommandPoolID) - -#undef MAKE_ID -} //namespace rid diff --git a/drivers/metal/metal_objects.mm b/drivers/metal/metal_objects.mm deleted file mode 100644 index 76a3f67d0d..0000000000 --- a/drivers/metal/metal_objects.mm +++ /dev/null @@ -1,2548 +0,0 @@ -/**************************************************************************/ -/* metal_objects.mm */ -/**************************************************************************/ -/* This file is part of: */ -/* GODOT ENGINE */ -/* https://godotengine.org */ -/**************************************************************************/ -/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ -/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ -/* */ -/* Permission is hereby granted, free of charge, to any person obtaining */ -/* a copy of this software and associated documentation files (the */ -/* "Software"), to deal in the Software without restriction, including */ -/* without limitation the rights to use, copy, modify, merge, publish, */ -/* distribute, sublicense, and/or sell copies of the Software, and to */ -/* permit persons to whom the Software is furnished to do so, subject to */ -/* the following conditions: */ -/* */ -/* The above copyright notice and this permission notice shall be */ -/* included in all copies or substantial portions of the Software. */ -/* */ -/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ -/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ -/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ -/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ -/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ -/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ -/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ -/**************************************************************************/ - -/**************************************************************************/ -/* */ -/* Portions of this code were derived from MoltenVK. */ -/* */ -/* Copyright (c) 2015-2023 The Brenwill Workshop Ltd. */ -/* (http://www.brenwill.com) */ -/* */ -/* Licensed under the Apache License, Version 2.0 (the "License"); */ -/* you may not use this file except in compliance with the License. */ -/* You may obtain a copy of the License at */ -/* */ -/* http://www.apache.org/licenses/LICENSE-2.0 */ -/* */ -/* Unless required by applicable law or agreed to in writing, software */ -/* distributed under the License is distributed on an "AS IS" BASIS, */ -/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */ -/* implied. See the License for the specific language governing */ -/* permissions and limitations under the License. */ -/**************************************************************************/ - -#import "metal_objects.h" - -#import "metal_utils.h" -#import "pixel_formats.h" -#import "rendering_device_driver_metal.h" -#import "rendering_shader_container_metal.h" - -#import -#import - -// We have to undefine these macros because they are defined in NSObjCRuntime.h. -#undef MIN -#undef MAX - -void MDCommandBuffer::begin_label(const char *p_label_name, const Color &p_color) { - NSString *s = [[NSString alloc] initWithBytesNoCopy:(void *)p_label_name length:strlen(p_label_name) encoding:NSUTF8StringEncoding freeWhenDone:NO]; - [commandBuffer pushDebugGroup:s]; -} - -void MDCommandBuffer::end_label() { - [commandBuffer popDebugGroup]; -} - -void MDCommandBuffer::begin() { - DEV_ASSERT(commandBuffer == nil && !state_begin); - state_begin = true; - binding_cache.clear(); -} - -void MDCommandBuffer::end() { - switch (type) { - case MDCommandBufferStateType::None: - return; - case MDCommandBufferStateType::Render: - return render_end_pass(); - case MDCommandBufferStateType::Compute: - return _end_compute_dispatch(); - case MDCommandBufferStateType::Blit: - return _end_blit(); - } -} - -void MDCommandBuffer::commit() { - end(); - [commandBuffer commit]; - commandBuffer = nil; - state_begin = false; -} - -void MDCommandBuffer::bind_pipeline(RDD::PipelineID p_pipeline) { - MDPipeline *p = (MDPipeline *)(p_pipeline.id); - - // End current encoder if it is a compute encoder or blit encoder, - // as they do not have a defined end boundary in the RDD like render. - if (type == MDCommandBufferStateType::Compute) { - _end_compute_dispatch(); - } else if (type == MDCommandBufferStateType::Blit) { - _end_blit(); - } - - if (p->type == MDPipelineType::Render) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - MDRenderPipeline *rp = (MDRenderPipeline *)p; - - if (render.encoder == nil) { - // This error would happen if the render pass failed. - ERR_FAIL_NULL_MSG(render.desc, "Render pass descriptor is null."); - - // This condition occurs when there are no attachments when calling render_next_subpass() - // and is due to the SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS flag. - render.desc.defaultRasterSampleCount = static_cast(rp->sample_count); - -// NOTE(sgc): This is to test rdar://FB13605547 and will be deleted once fix is confirmed. -#if 0 - if (render.pipeline->sample_count == 4) { - static id tex = nil; - static id res_tex = nil; - static dispatch_once_t onceToken; - dispatch_once(&onceToken, ^{ - Size2i sz = render.frameBuffer->size; - MTLTextureDescriptor *td = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm width:sz.width height:sz.height mipmapped:NO]; - td.textureType = MTLTextureType2DMultisample; - td.storageMode = MTLStorageModeMemoryless; - td.usage = MTLTextureUsageRenderTarget; - td.sampleCount = render.pipeline->sample_count; - tex = [device_driver->get_device() newTextureWithDescriptor:td]; - - td.textureType = MTLTextureType2D; - td.storageMode = MTLStorageModePrivate; - td.usage = MTLTextureUsageShaderWrite; - td.sampleCount = 1; - res_tex = [device_driver->get_device() newTextureWithDescriptor:td]; - }); - render.desc.colorAttachments[0].texture = tex; - render.desc.colorAttachments[0].loadAction = MTLLoadActionClear; - render.desc.colorAttachments[0].storeAction = MTLStoreActionMultisampleResolve; - - render.desc.colorAttachments[0].resolveTexture = res_tex; - } -#endif - render.encoder = [command_buffer() renderCommandEncoderWithDescriptor:render.desc]; - } - - if (render.pipeline != rp) { - render.dirty.set_flag((RenderState::DirtyFlag)(RenderState::DIRTY_PIPELINE | RenderState::DIRTY_RASTER)); - // Mark all uniforms as dirty, as variants of a shader pipeline may have a different entry point ABI, - // due to setting force_active_argument_buffer_resources = true for spirv_cross::CompilerMSL::Options. - // As a result, uniform sets with the same layout will generate redundant binding warnings when - // capturing a Metal frame in Xcode. - // - // If we don't mark as dirty, then some bindings will generate a validation error. - binding_cache.clear(); - render.mark_uniforms_dirty(); - if (render.pipeline != nullptr && render.pipeline->depth_stencil != rp->depth_stencil) { - render.dirty.set_flag(RenderState::DIRTY_DEPTH); - } - if (rp->raster_state.blend.enabled) { - render.dirty.set_flag(RenderState::DIRTY_BLEND); - } - render.pipeline = rp; - } - } else if (p->type == MDPipelineType::Compute) { - DEV_ASSERT(type == MDCommandBufferStateType::None); - type = MDCommandBufferStateType::Compute; - - if (compute.pipeline != p) { - compute.dirty.set_flag(ComputeState::DIRTY_PIPELINE); - binding_cache.clear(); - compute.mark_uniforms_dirty(); - compute.pipeline = (MDComputePipeline *)p; - } - } -} - -void MDCommandBuffer::encode_push_constant_data(RDD::ShaderID p_shader, VectorView p_data) { - switch (type) { - case MDCommandBufferStateType::Render: - case MDCommandBufferStateType::Compute: { - MDShader *shader = (MDShader *)(p_shader.id); - if (shader->push_constants.binding == UINT32_MAX) { - return; - } - push_constant_binding = shader->push_constants.binding; - void const *ptr = p_data.ptr(); - push_constant_data_len = p_data.size() * sizeof(uint32_t); - DEV_ASSERT(push_constant_data_len <= sizeof(push_constant_data)); - memcpy(push_constant_data, ptr, push_constant_data_len); - if (push_constant_data_len > 0) { - switch (type) { - case MDCommandBufferStateType::Render: - render.dirty.set_flag(RenderState::DirtyFlag::DIRTY_PUSH); - break; - case MDCommandBufferStateType::Compute: - compute.dirty.set_flag(ComputeState::DirtyFlag::DIRTY_PUSH); - break; - default: - break; - } - } - } break; - case MDCommandBufferStateType::Blit: - case MDCommandBufferStateType::None: - return; - } -} - -id MDCommandBuffer::_ensure_blit_encoder() { - switch (type) { - case MDCommandBufferStateType::None: - break; - case MDCommandBufferStateType::Render: - render_end_pass(); - break; - case MDCommandBufferStateType::Compute: - _end_compute_dispatch(); - break; - case MDCommandBufferStateType::Blit: - return blit.encoder; - } - - type = MDCommandBufferStateType::Blit; - blit.encoder = command_buffer().blitCommandEncoder; - return blit.encoder; -} - -_FORCE_INLINE_ static MTLSize mipmapLevelSizeFromTexture(id p_tex, NSUInteger p_level) { - MTLSize lvlSize; - lvlSize.width = MAX(p_tex.width >> p_level, 1UL); - lvlSize.height = MAX(p_tex.height >> p_level, 1UL); - lvlSize.depth = MAX(p_tex.depth >> p_level, 1UL); - return lvlSize; -} - -void MDCommandBuffer::resolve_texture(RDD::TextureID p_src_texture, RDD::TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, RDD::TextureID p_dst_texture, RDD::TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap) { - id src_tex = rid::get(p_src_texture); - id dst_tex = rid::get(p_dst_texture); - - MTLRenderPassDescriptor *mtlRPD = [MTLRenderPassDescriptor renderPassDescriptor]; - MTLRenderPassColorAttachmentDescriptor *mtlColorAttDesc = mtlRPD.colorAttachments[0]; - mtlColorAttDesc.loadAction = MTLLoadActionLoad; - mtlColorAttDesc.storeAction = MTLStoreActionMultisampleResolve; - - mtlColorAttDesc.texture = src_tex; - mtlColorAttDesc.resolveTexture = dst_tex; - mtlColorAttDesc.level = p_src_mipmap; - mtlColorAttDesc.slice = p_src_layer; - mtlColorAttDesc.resolveLevel = p_dst_mipmap; - mtlColorAttDesc.resolveSlice = p_dst_layer; - encodeRenderCommandEncoderWithDescriptor(mtlRPD, @"Resolve Image"); -} - -void MDCommandBuffer::clear_color_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, const Color &p_color, const RDD::TextureSubresourceRange &p_subresources) { - id src_tex = rid::get(p_texture); - - if (src_tex.parentTexture) { - // Clear via the parent texture rather than the view. - src_tex = src_tex.parentTexture; - } - - PixelFormats &pf = device_driver->get_pixel_formats(); - - if (pf.isDepthFormat(src_tex.pixelFormat) || pf.isStencilFormat(src_tex.pixelFormat)) { - ERR_FAIL_MSG("invalid: depth or stencil texture format"); - } - - MTLRenderPassDescriptor *desc = MTLRenderPassDescriptor.renderPassDescriptor; - - if (p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { - MTLRenderPassColorAttachmentDescriptor *caDesc = desc.colorAttachments[0]; - caDesc.texture = src_tex; - caDesc.loadAction = MTLLoadActionClear; - caDesc.storeAction = MTLStoreActionStore; - caDesc.clearColor = MTLClearColorMake(p_color.r, p_color.g, p_color.b, p_color.a); - - // Extract the mipmap levels that are to be updated. - uint32_t mipLvlStart = p_subresources.base_mipmap; - uint32_t mipLvlCnt = p_subresources.mipmap_count; - uint32_t mipLvlEnd = mipLvlStart + mipLvlCnt; - - uint32_t levelCount = src_tex.mipmapLevelCount; - - // Extract the cube or array layers (slices) that are to be updated. - bool is3D = src_tex.textureType == MTLTextureType3D; - uint32_t layerStart = is3D ? 0 : p_subresources.base_layer; - uint32_t layerCnt = p_subresources.layer_count; - uint32_t layerEnd = layerStart + layerCnt; - - MetalFeatures const &features = device_driver->get_device_properties().features; - - // Iterate across mipmap levels and layers, and perform and empty render to clear each. - for (uint32_t mipLvl = mipLvlStart; mipLvl < mipLvlEnd; mipLvl++) { - ERR_FAIL_INDEX_MSG(mipLvl, levelCount, "mip level out of range"); - - caDesc.level = mipLvl; - - // If a 3D image, we need to get the depth for each level. - if (is3D) { - layerCnt = mipmapLevelSizeFromTexture(src_tex, mipLvl).depth; - layerEnd = layerStart + layerCnt; - } - - if ((features.layeredRendering && src_tex.sampleCount == 1) || features.multisampleLayeredRendering) { - // We can clear all layers at once. - if (is3D) { - caDesc.depthPlane = layerStart; - } else { - caDesc.slice = layerStart; - } - desc.renderTargetArrayLength = layerCnt; - encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); - } else { - for (uint32_t layer = layerStart; layer < layerEnd; layer++) { - if (is3D) { - caDesc.depthPlane = layer; - } else { - caDesc.slice = layer; - } - encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); - } - } - } - } -} - -void MDCommandBuffer::clear_depth_stencil_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const RDD::TextureSubresourceRange &p_subresources) { - id src_tex = rid::get(p_texture); - - if (src_tex.parentTexture) { - // Clear via the parent texture rather than the view. - src_tex = src_tex.parentTexture; - } - - PixelFormats &pf = device_driver->get_pixel_formats(); - - bool is_depth_format = pf.isDepthFormat(src_tex.pixelFormat); - bool is_stencil_format = pf.isStencilFormat(src_tex.pixelFormat); - - if (!is_depth_format && !is_stencil_format) { - ERR_FAIL_MSG("invalid: color texture format"); - } - - bool clear_depth = is_depth_format && p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT); - bool clear_stencil = is_stencil_format && p_subresources.aspect.has_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT); - - if (clear_depth || clear_stencil) { - MTLRenderPassDescriptor *desc = MTLRenderPassDescriptor.renderPassDescriptor; - - MTLRenderPassDepthAttachmentDescriptor *daDesc = desc.depthAttachment; - if (clear_depth) { - daDesc.texture = src_tex; - daDesc.loadAction = MTLLoadActionClear; - daDesc.storeAction = MTLStoreActionStore; - daDesc.clearDepth = p_depth; - } - - MTLRenderPassStencilAttachmentDescriptor *saDesc = desc.stencilAttachment; - if (clear_stencil) { - saDesc.texture = src_tex; - saDesc.loadAction = MTLLoadActionClear; - saDesc.storeAction = MTLStoreActionStore; - saDesc.clearStencil = p_stencil; - } - - // Extract the mipmap levels that are to be updated. - uint32_t mipLvlStart = p_subresources.base_mipmap; - uint32_t mipLvlCnt = p_subresources.mipmap_count; - uint32_t mipLvlEnd = mipLvlStart + mipLvlCnt; - - uint32_t levelCount = src_tex.mipmapLevelCount; - - // Extract the cube or array layers (slices) that are to be updated. - bool is3D = src_tex.textureType == MTLTextureType3D; - uint32_t layerStart = is3D ? 0 : p_subresources.base_layer; - uint32_t layerCnt = p_subresources.layer_count; - uint32_t layerEnd = layerStart + layerCnt; - - MetalFeatures const &features = device_driver->get_device_properties().features; - - // Iterate across mipmap levels and layers, and perform and empty render to clear each. - for (uint32_t mipLvl = mipLvlStart; mipLvl < mipLvlEnd; mipLvl++) { - ERR_FAIL_INDEX_MSG(mipLvl, levelCount, "mip level out of range"); - - if (clear_depth) { - daDesc.level = mipLvl; - } - if (clear_stencil) { - saDesc.level = mipLvl; - } - - // If a 3D image, we need to get the depth for each level. - if (is3D) { - layerCnt = mipmapLevelSizeFromTexture(src_tex, mipLvl).depth; - layerEnd = layerStart + layerCnt; - } - - if ((features.layeredRendering && src_tex.sampleCount == 1) || features.multisampleLayeredRendering) { - // We can clear all layers at once. - if (is3D) { - if (clear_depth) { - daDesc.depthPlane = layerStart; - } - if (clear_stencil) { - saDesc.depthPlane = layerStart; - } - } else { - if (clear_depth) { - daDesc.slice = layerStart; - } - if (clear_stencil) { - saDesc.slice = layerStart; - } - } - desc.renderTargetArrayLength = layerCnt; - encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); - } else { - for (uint32_t layer = layerStart; layer < layerEnd; layer++) { - if (is3D) { - if (clear_depth) { - daDesc.depthPlane = layer; - } - if (clear_stencil) { - saDesc.depthPlane = layer; - } - } else { - if (clear_depth) { - daDesc.slice = layer; - } - if (clear_stencil) { - saDesc.slice = layer; - } - } - encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); - } - } - } - } -} - -void MDCommandBuffer::clear_buffer(RDD::BufferID p_buffer, uint64_t p_offset, uint64_t p_size) { - id blit_enc = _ensure_blit_encoder(); - const RDM::BufferInfo *buffer = (const RDM::BufferInfo *)p_buffer.id; - - [blit_enc fillBuffer:buffer->metal_buffer - range:NSMakeRange(p_offset, p_size) - value:0]; -} - -void MDCommandBuffer::copy_buffer(RDD::BufferID p_src_buffer, RDD::BufferID p_dst_buffer, VectorView p_regions) { - const RDM::BufferInfo *src = (const RDM::BufferInfo *)p_src_buffer.id; - const RDM::BufferInfo *dst = (const RDM::BufferInfo *)p_dst_buffer.id; - - id enc = _ensure_blit_encoder(); - - for (uint32_t i = 0; i < p_regions.size(); i++) { - RDD::BufferCopyRegion region = p_regions[i]; - [enc copyFromBuffer:src->metal_buffer - sourceOffset:region.src_offset - toBuffer:dst->metal_buffer - destinationOffset:region.dst_offset - size:region.size]; - } -} - -static MTLSize MTLSizeFromVector3i(Vector3i p_size) { - return MTLSizeMake(p_size.x, p_size.y, p_size.z); -} - -static MTLOrigin MTLOriginFromVector3i(Vector3i p_origin) { - return MTLOriginMake(p_origin.x, p_origin.y, p_origin.z); -} - -// Clamps the size so that the sum of the origin and size do not exceed the maximum size. -static inline MTLSize clampMTLSize(MTLSize p_size, MTLOrigin p_origin, MTLSize p_max_size) { - MTLSize clamped; - clamped.width = MIN(p_size.width, p_max_size.width - p_origin.x); - clamped.height = MIN(p_size.height, p_max_size.height - p_origin.y); - clamped.depth = MIN(p_size.depth, p_max_size.depth - p_origin.z); - return clamped; -} - -API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) -static bool isArrayTexture(MTLTextureType p_type) { - return (p_type == MTLTextureType3D || - p_type == MTLTextureType2DArray || - p_type == MTLTextureType2DMultisampleArray || - p_type == MTLTextureType1DArray); -} - -_FORCE_INLINE_ static bool operator==(MTLSize p_a, MTLSize p_b) { - return p_a.width == p_b.width && p_a.height == p_b.height && p_a.depth == p_b.depth; -} - -void MDCommandBuffer::copy_texture(RDD::TextureID p_src_texture, RDD::TextureID p_dst_texture, VectorView p_regions) { - id src = rid::get(p_src_texture); - id dst = rid::get(p_dst_texture); - - id enc = _ensure_blit_encoder(); - PixelFormats &pf = device_driver->get_pixel_formats(); - - MTLPixelFormat src_fmt = src.pixelFormat; - bool src_is_compressed = pf.getFormatType(src_fmt) == MTLFormatType::Compressed; - MTLPixelFormat dst_fmt = dst.pixelFormat; - bool dst_is_compressed = pf.getFormatType(dst_fmt) == MTLFormatType::Compressed; - - // Validate copy. - if (src.sampleCount != dst.sampleCount || pf.getBytesPerBlock(src_fmt) != pf.getBytesPerBlock(dst_fmt)) { - ERR_FAIL_MSG("Cannot copy between incompatible pixel formats, such as formats of different pixel sizes, or between images with different sample counts."); - } - - // If source and destination have different formats and at least one is compressed, a temporary buffer is required. - bool need_tmp_buffer = (src_fmt != dst_fmt) && (src_is_compressed || dst_is_compressed); - if (need_tmp_buffer) { - ERR_FAIL_MSG("not implemented: copy with intermediate buffer"); - } - - if (src_fmt != dst_fmt) { - // Map the source pixel format to the dst through a texture view on the source texture. - src = [src newTextureViewWithPixelFormat:dst_fmt]; - } - - for (uint32_t i = 0; i < p_regions.size(); i++) { - RDD::TextureCopyRegion region = p_regions[i]; - - MTLSize extent = MTLSizeFromVector3i(region.size); - - // If copies can be performed using direct texture-texture copying, do so. - uint32_t src_level = region.src_subresources.mipmap; - uint32_t src_base_layer = region.src_subresources.base_layer; - MTLSize src_extent = mipmapLevelSizeFromTexture(src, src_level); - uint32_t dst_level = region.dst_subresources.mipmap; - uint32_t dst_base_layer = region.dst_subresources.base_layer; - MTLSize dst_extent = mipmapLevelSizeFromTexture(dst, dst_level); - - // All layers may be copied at once, if the extent completely covers both images. - if (src_extent == extent && dst_extent == extent) { - [enc copyFromTexture:src - sourceSlice:src_base_layer - sourceLevel:src_level - toTexture:dst - destinationSlice:dst_base_layer - destinationLevel:dst_level - sliceCount:region.src_subresources.layer_count - levelCount:1]; - } else { - MTLOrigin src_origin = MTLOriginFromVector3i(region.src_offset); - MTLSize src_size = clampMTLSize(extent, src_origin, src_extent); - uint32_t layer_count = 0; - if ((src.textureType == MTLTextureType3D) != (dst.textureType == MTLTextureType3D)) { - // In the case, the number of layers to copy is in extent.depth. Use that value, - // then clamp the depth, so we don't try to copy more than Metal will allow. - layer_count = extent.depth; - src_size.depth = 1; - } else { - layer_count = region.src_subresources.layer_count; - } - MTLOrigin dst_origin = MTLOriginFromVector3i(region.dst_offset); - - for (uint32_t layer = 0; layer < layer_count; layer++) { - // We can copy between a 3D and a 2D image easily. Just copy between - // one slice of the 2D image and one plane of the 3D image at a time. - if ((src.textureType == MTLTextureType3D) == (dst.textureType == MTLTextureType3D)) { - [enc copyFromTexture:src - sourceSlice:src_base_layer + layer - sourceLevel:src_level - sourceOrigin:src_origin - sourceSize:src_size - toTexture:dst - destinationSlice:dst_base_layer + layer - destinationLevel:dst_level - destinationOrigin:dst_origin]; - } else if (src.textureType == MTLTextureType3D) { - [enc copyFromTexture:src - sourceSlice:src_base_layer - sourceLevel:src_level - sourceOrigin:MTLOriginMake(src_origin.x, src_origin.y, src_origin.z + layer) - sourceSize:src_size - toTexture:dst - destinationSlice:dst_base_layer + layer - destinationLevel:dst_level - destinationOrigin:dst_origin]; - } else { - DEV_ASSERT(dst.textureType == MTLTextureType3D); - [enc copyFromTexture:src - sourceSlice:src_base_layer + layer - sourceLevel:src_level - sourceOrigin:src_origin - sourceSize:src_size - toTexture:dst - destinationSlice:dst_base_layer - destinationLevel:dst_level - destinationOrigin:MTLOriginMake(dst_origin.x, dst_origin.y, dst_origin.z + layer)]; - } - } - } - } -} - -void MDCommandBuffer::copy_buffer_to_texture(RDD::BufferID p_src_buffer, RDD::TextureID p_dst_texture, VectorView p_regions) { - _copy_texture_buffer(CopySource::Buffer, p_dst_texture, p_src_buffer, p_regions); -} - -void MDCommandBuffer::copy_texture_to_buffer(RDD::TextureID p_src_texture, RDD::BufferID p_dst_buffer, VectorView p_regions) { - _copy_texture_buffer(CopySource::Texture, p_src_texture, p_dst_buffer, p_regions); -} - -void MDCommandBuffer::_copy_texture_buffer(CopySource p_source, - RDD::TextureID p_texture, - RDD::BufferID p_buffer, - VectorView p_regions) { - const RDM::BufferInfo *buffer = (const RDM::BufferInfo *)p_buffer.id; - id texture = rid::get(p_texture); - - id enc = _ensure_blit_encoder(); - - PixelFormats &pf = device_driver->get_pixel_formats(); - MTLPixelFormat mtlPixFmt = texture.pixelFormat; - - MTLBlitOption options = MTLBlitOptionNone; - if (pf.isPVRTCFormat(mtlPixFmt)) { - options |= MTLBlitOptionRowLinearPVRTC; - } - - for (uint32_t i = 0; i < p_regions.size(); i++) { - RDD::BufferTextureCopyRegion region = p_regions[i]; - - uint32_t mip_level = region.texture_subresource.mipmap; - MTLOrigin txt_origin = MTLOriginMake(region.texture_offset.x, region.texture_offset.y, region.texture_offset.z); - MTLSize src_extent = mipmapLevelSizeFromTexture(texture, mip_level); - MTLSize txt_size = clampMTLSize(MTLSizeMake(region.texture_region_size.x, region.texture_region_size.y, region.texture_region_size.z), - txt_origin, - src_extent); - - uint32_t buffImgWd = region.texture_region_size.x; - uint32_t buffImgHt = region.texture_region_size.y; - - NSUInteger bytesPerRow = pf.getBytesPerRow(mtlPixFmt, buffImgWd); - NSUInteger bytesPerImg = pf.getBytesPerLayer(mtlPixFmt, bytesPerRow, buffImgHt); - - MTLBlitOption blit_options = options; - - if (pf.isDepthFormat(mtlPixFmt) && pf.isStencilFormat(mtlPixFmt)) { - // Don't reduce depths of 32-bit depth/stencil formats. - if (region.texture_subresource.aspect == RDD::TEXTURE_ASPECT_DEPTH) { - if (pf.getBytesPerTexel(mtlPixFmt) != 4) { - bytesPerRow -= buffImgWd; - bytesPerImg -= buffImgWd * buffImgHt; - } - blit_options |= MTLBlitOptionDepthFromDepthStencil; - } else if (region.texture_subresource.aspect == RDD::TEXTURE_ASPECT_STENCIL) { - // The stencil component is always 1 byte per pixel. - bytesPerRow = buffImgWd; - bytesPerImg = buffImgWd * buffImgHt; - blit_options |= MTLBlitOptionStencilFromDepthStencil; - } - } - - if (!isArrayTexture(texture.textureType)) { - bytesPerImg = 0; - } - - if (p_source == CopySource::Buffer) { - [enc copyFromBuffer:buffer->metal_buffer - sourceOffset:region.buffer_offset - sourceBytesPerRow:bytesPerRow - sourceBytesPerImage:bytesPerImg - sourceSize:txt_size - toTexture:texture - destinationSlice:region.texture_subresource.layer - destinationLevel:mip_level - destinationOrigin:txt_origin - options:blit_options]; - } else { - [enc copyFromTexture:texture - sourceSlice:region.texture_subresource.layer - sourceLevel:mip_level - sourceOrigin:txt_origin - sourceSize:txt_size - toBuffer:buffer->metal_buffer - destinationOffset:region.buffer_offset - destinationBytesPerRow:bytesPerRow - destinationBytesPerImage:bytesPerImg - options:blit_options]; - } - } -} - -void MDCommandBuffer::encodeRenderCommandEncoderWithDescriptor(MTLRenderPassDescriptor *p_desc, NSString *p_label) { - switch (type) { - case MDCommandBufferStateType::None: - break; - case MDCommandBufferStateType::Render: - render_end_pass(); - break; - case MDCommandBufferStateType::Compute: - _end_compute_dispatch(); - break; - case MDCommandBufferStateType::Blit: - _end_blit(); - break; - } - - id enc = [command_buffer() renderCommandEncoderWithDescriptor:p_desc]; - if (p_label != nil) { - [enc pushDebugGroup:p_label]; - [enc popDebugGroup]; - } - [enc endEncoding]; -} - -#pragma mark - Render Commands - -void MDCommandBuffer::render_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - - if (uint32_t new_size = p_first_set_index + p_set_count; render.uniform_sets.size() < new_size) { - uint32_t s = render.uniform_sets.size(); - render.uniform_sets.resize(new_size); - // Set intermediate values to null. - std::fill(&render.uniform_sets[s], render.uniform_sets.end().operator->(), nullptr); - } - - const MDShader *shader = (const MDShader *)p_shader.id; - DynamicOffsetLayout layout = shader->dynamic_offset_layout; - - // Clear bits for sets being rebound before OR'ing new values. - // This prevents corruption when the same set is bound multiple times - // with different frame indices (e.g., OPAQUE pass then ALPHA pass). - for (uint32_t i = 0; i < p_set_count && render.dynamic_offsets != 0; i++) { - uint32_t set_index = p_first_set_index + i; - uint32_t count = layout.get_count(set_index); - if (count > 0) { - uint32_t shift = layout.get_offset_index_shift(set_index); - uint32_t mask = ((1u << (count * 4u)) - 1u) << shift; - render.dynamic_offsets &= ~mask; - } - } - render.dynamic_offsets |= p_dynamic_offsets; - - for (size_t i = 0; i < p_set_count; ++i) { - MDUniformSet *set = (MDUniformSet *)(p_uniform_sets[i].id); - - uint32_t index = p_first_set_index + i; - if (render.uniform_sets[index] != set || layout.get_count(index) > 0) { - render.dirty.set_flag(RenderState::DIRTY_UNIFORMS); - render.uniform_set_mask |= 1ULL << index; - render.uniform_sets[index] = set; - } - } -} - -void MDCommandBuffer::render_clear_attachments(VectorView p_attachment_clears, VectorView p_rects) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - - const MDSubpass &subpass = render.get_subpass(); - - uint32_t vertex_count = p_rects.size() * 6 * subpass.view_count; - simd::float4 *vertices = ALLOCA_ARRAY(simd::float4, vertex_count); - simd::float4 clear_colors[ClearAttKey::ATTACHMENT_COUNT]; - - Size2i size = render.frameBuffer->size; - Rect2i render_area = render.clip_to_render_area({ { 0, 0 }, size }); - size = Size2i(render_area.position.x + render_area.size.width, render_area.position.y + render_area.size.height); - _populate_vertices(vertices, size, p_rects); - - ClearAttKey key; - key.sample_count = render.pass->get_sample_count(); - if (subpass.view_count > 1) { - key.enable_layered_rendering(); - } - - float depth_value = 0; - uint32_t stencil_value = 0; - - for (uint32_t i = 0; i < p_attachment_clears.size(); i++) { - RDD::AttachmentClear const &attClear = p_attachment_clears[i]; - uint32_t attachment_index; - if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { - attachment_index = attClear.color_attachment; - } else { - attachment_index = subpass.depth_stencil_reference.attachment; - } - - MDAttachment const &mda = render.pass->attachments[attachment_index]; - if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_COLOR_BIT)) { - key.set_color_format(attachment_index, mda.format); - clear_colors[attachment_index] = { - attClear.value.color.r, - attClear.value.color.g, - attClear.value.color.b, - attClear.value.color.a - }; - } - - if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT)) { - key.set_depth_format(mda.format); - depth_value = attClear.value.depth; - } - - if (attClear.aspect.has_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT)) { - key.set_stencil_format(mda.format); - stencil_value = attClear.value.stencil; - } - } - clear_colors[ClearAttKey::DEPTH_INDEX] = { - depth_value, - depth_value, - depth_value, - depth_value - }; - - id enc = render.encoder; - - MDResourceCache &cache = device_driver->get_resource_cache(); - - [enc pushDebugGroup:@"ClearAttachments"]; - [enc setRenderPipelineState:cache.get_clear_render_pipeline_state(key, nil)]; - [enc setDepthStencilState:cache.get_depth_stencil_state( - key.is_depth_enabled(), - key.is_stencil_enabled())]; - [enc setStencilReferenceValue:stencil_value]; - [enc setCullMode:MTLCullModeNone]; - [enc setTriangleFillMode:MTLTriangleFillModeFill]; - [enc setDepthBias:0 slopeScale:0 clamp:0]; - [enc setViewport:{ 0, 0, (double)size.width, (double)size.height, 0.0, 1.0 }]; - [enc setScissorRect:{ 0, 0, (NSUInteger)size.width, (NSUInteger)size.height }]; - - [enc setVertexBytes:clear_colors length:sizeof(clear_colors) atIndex:0]; - [enc setFragmentBytes:clear_colors length:sizeof(clear_colors) atIndex:0]; - [enc setVertexBytes:vertices length:vertex_count * sizeof(vertices[0]) atIndex:device_driver->get_metal_buffer_index_for_vertex_attribute_binding(VERT_CONTENT_BUFFER_INDEX)]; - - [enc drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:vertex_count]; - [enc popDebugGroup]; - - render.dirty.set_flag((RenderState::DirtyFlag)(RenderState::DIRTY_PIPELINE | RenderState::DIRTY_DEPTH | RenderState::DIRTY_RASTER)); - binding_cache.clear(); - render.mark_uniforms_dirty({ 0 }); // Mark index 0 dirty, if there is already a binding for index 0. - render.mark_viewport_dirty(); - render.mark_scissors_dirty(); - render.mark_vertex_dirty(); - render.mark_blend_dirty(); -} - -void MDCommandBuffer::_render_set_dirty_state() { - _render_bind_uniform_sets(); - - if (render.dirty.has_flag(RenderState::DIRTY_PUSH)) { - if (push_constant_binding != UINT32_MAX) { - [render.encoder setVertexBytes:push_constant_data - length:push_constant_data_len - atIndex:push_constant_binding]; - [render.encoder setFragmentBytes:push_constant_data - length:push_constant_data_len - atIndex:push_constant_binding]; - } - } - - MDSubpass const &subpass = render.get_subpass(); - if (subpass.view_count > 1) { - uint32_t view_range[2] = { 0, subpass.view_count }; - [render.encoder setVertexBytes:view_range length:sizeof(view_range) atIndex:VIEW_MASK_BUFFER_INDEX]; - [render.encoder setFragmentBytes:view_range length:sizeof(view_range) atIndex:VIEW_MASK_BUFFER_INDEX]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_PIPELINE)) { - [render.encoder setRenderPipelineState:render.pipeline->state]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_VIEWPORT)) { - [render.encoder setViewports:render.viewports.ptr() count:render.viewports.size()]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_DEPTH)) { - [render.encoder setDepthStencilState:render.pipeline->depth_stencil]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_RASTER)) { - render.pipeline->raster_state.apply(render.encoder); - } - - if (render.dirty.has_flag(RenderState::DIRTY_SCISSOR) && !render.scissors.is_empty()) { - size_t len = render.scissors.size(); - MTLScissorRect *rects = ALLOCA_ARRAY(MTLScissorRect, len); - for (size_t i = 0; i < len; i++) { - rects[i] = render.clip_to_render_area(render.scissors[i]); - } - [render.encoder setScissorRects:rects count:len]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_BLEND) && render.blend_constants.has_value()) { - [render.encoder setBlendColorRed:render.blend_constants->r green:render.blend_constants->g blue:render.blend_constants->b alpha:render.blend_constants->a]; - } - - if (render.dirty.has_flag(RenderState::DIRTY_VERTEX)) { - uint32_t p_binding_count = render.vertex_buffers.size(); - if (p_binding_count > 0) { - uint32_t first = device_driver->get_metal_buffer_index_for_vertex_attribute_binding(p_binding_count - 1); - [render.encoder setVertexBuffers:render.vertex_buffers.ptr() - offsets:render.vertex_offsets.ptr() - withRange:NSMakeRange(first, p_binding_count)]; - } - } - - render.resource_tracker.encode(render.encoder); - - render.dirty.clear(); -} - -void MDCommandBuffer::render_set_viewport(VectorView p_viewports) { - render.viewports.resize(p_viewports.size()); - for (uint32_t i = 0; i < p_viewports.size(); i += 1) { - Rect2i const &vp = p_viewports[i]; - render.viewports[i] = { - .originX = static_cast(vp.position.x), - .originY = static_cast(vp.position.y), - .width = static_cast(vp.size.width), - .height = static_cast(vp.size.height), - .znear = 0.0, - .zfar = 1.0, - }; - } - - render.dirty.set_flag(RenderState::DIRTY_VIEWPORT); -} - -void MDCommandBuffer::render_set_scissor(VectorView p_scissors) { - render.scissors.resize(p_scissors.size()); - for (uint32_t i = 0; i < p_scissors.size(); i += 1) { - Rect2i const &vp = p_scissors[i]; - render.scissors[i] = { - .x = static_cast(vp.position.x), - .y = static_cast(vp.position.y), - .width = static_cast(vp.size.width), - .height = static_cast(vp.size.height), - }; - } - - render.dirty.set_flag(RenderState::DIRTY_SCISSOR); -} - -void MDCommandBuffer::render_set_blend_constants(const Color &p_constants) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - if (render.blend_constants != p_constants) { - render.blend_constants = p_constants; - render.dirty.set_flag(RenderState::DIRTY_BLEND); - } -} - -void ResourceTracker::merge_from(const ResourceUsageMap &p_from) { - for (KeyValue const &keyval : p_from) { - ResourceVector *resources = _current.getptr(keyval.key); - if (resources == nullptr) { - resources = &_current.insert(keyval.key, ResourceVector())->value; - } - // Reserve space for the new resources, assuming they are all added. - resources->reserve(resources->size() + keyval.value.size()); - - uint32_t i = 0, j = 0; - MTLResourceUnsafe *resources_ptr = resources->ptr(); - const MTLResourceUnsafe *keyval_ptr = keyval.value.ptr(); - // 2-way merge. - while (i < resources->size() && j < keyval.value.size()) { - if (resources_ptr[i] < keyval_ptr[j]) { - i++; - } else if (resources_ptr[i] > keyval_ptr[j]) { - ResourceUsageEntry *existing = nullptr; - if ((existing = _previous.getptr(keyval_ptr[j])) == nullptr) { - existing = &_previous.insert(keyval_ptr[j], keyval.key)->value; - resources->insert(i, keyval_ptr[j]); - } else { - if (existing->usage != keyval.key) { - existing->usage |= keyval.key; - resources->insert(i, keyval_ptr[j]); - } - } - i++; - j++; - } else { - i++; - j++; - } - } - // Append the remaining resources. - for (; j < keyval.value.size(); j++) { - ResourceUsageEntry *existing = nullptr; - if ((existing = _previous.getptr(keyval_ptr[j])) == nullptr) { - existing = &_previous.insert(keyval_ptr[j], keyval.key)->value; - resources->push_back(keyval_ptr[j]); - } else { - if (existing->usage != keyval.key) { - existing->usage |= keyval.key; - resources->push_back(keyval_ptr[j]); - } - } - } - } -} - -void ResourceTracker::encode(id __unsafe_unretained p_enc) { - for (KeyValue const &keyval : _current) { - if (keyval.value.is_empty()) { - continue; - } - - MTLResourceUsage vert_usage = resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_VERTEX); - MTLResourceUsage frag_usage = resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_FRAGMENT); - if (vert_usage == frag_usage) { - [p_enc useResources:keyval.value.ptr() count:keyval.value.size() usage:vert_usage stages:MTLRenderStageVertex | MTLRenderStageFragment]; - } else { - if (vert_usage != 0) { - [p_enc useResources:keyval.value.ptr() count:keyval.value.size() usage:vert_usage stages:MTLRenderStageVertex]; - } - if (frag_usage != 0) { - [p_enc useResources:keyval.value.ptr() count:keyval.value.size() usage:frag_usage stages:MTLRenderStageFragment]; - } - } - } - - // Keep the keys for now and clear the vectors to reduce churn. - for (KeyValue &v : _current) { - v.value.clear(); - } -} - -void ResourceTracker::encode(id __unsafe_unretained p_enc) { - for (KeyValue const &keyval : _current) { - if (keyval.value.is_empty()) { - continue; - } - MTLResourceUsage usage = resource_usage_for_stage(keyval.key, RDD::ShaderStage::SHADER_STAGE_COMPUTE); - if (usage != 0) { - [p_enc useResources:keyval.value.ptr() count:keyval.value.size() usage:usage]; - } - } - - // Keep the keys for now and clear the vectors to reduce churn. - for (KeyValue &v : _current) { - v.value.clear(); - } -} - -void ResourceTracker::reset() { - // Keep the keys for now, as they are likely to be used repeatedly. - for (KeyValue &v : _previous) { - if (v.value.usage == ResourceUnused) { - v.value.unused++; - if (v.value.unused >= RESOURCE_UNUSED_CLEANUP_COUNT) { - _scratch.push_back(v.key); - } - } else { - v.value = ResourceUnused; - v.value.unused = 0; - } - } - - // Clear up resources that weren't used for the last pass. - for (const MTLResourceUnsafe &res : _scratch) { - _previous.erase(res); - } - _scratch.clear(); -} - -void MDCommandBuffer::_render_bind_uniform_sets() { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - if (!render.dirty.has_flag(RenderState::DIRTY_UNIFORMS)) { - return; - } - - render.dirty.clear_flag(RenderState::DIRTY_UNIFORMS); - uint64_t set_uniforms = render.uniform_set_mask; - render.uniform_set_mask = 0; - - MDRenderShader *shader = render.pipeline->shader; - const uint32_t dynamic_offsets = render.dynamic_offsets; - - while (set_uniforms != 0) { - // Find the index of the next set bit. - uint32_t index = (uint32_t)__builtin_ctzll(set_uniforms); - // Clear the set bit. - set_uniforms &= (set_uniforms - 1); - MDUniformSet *set = render.uniform_sets[index]; - if (set == nullptr || index >= (uint32_t)shader->sets.size()) { - continue; - } - if (shader->uses_argument_buffers) { - set->bind_uniforms_argument_buffers(shader, render, index, dynamic_offsets, device_driver->frame_index(), device_driver->frame_count()); - } else { - DirectEncoder de(render.encoder, binding_cache); - set->bind_uniforms_direct(shader, de, index, dynamic_offsets); - } - } -} - -void MDCommandBuffer::_populate_vertices(simd::float4 *p_vertices, Size2i p_fb_size, VectorView p_rects) { - uint32_t idx = 0; - for (uint32_t i = 0; i < p_rects.size(); i++) { - Rect2i const &rect = p_rects[i]; - idx = _populate_vertices(p_vertices, idx, rect, p_fb_size); - } -} - -uint32_t MDCommandBuffer::_populate_vertices(simd::float4 *p_vertices, uint32_t p_index, Rect2i const &p_rect, Size2i p_fb_size) { - // Determine the positions of the four edges of the - // clear rectangle as a fraction of the attachment size. - float leftPos = (float)(p_rect.position.x) / (float)p_fb_size.width; - float rightPos = (float)(p_rect.size.width) / (float)p_fb_size.width + leftPos; - float bottomPos = (float)(p_rect.position.y) / (float)p_fb_size.height; - float topPos = (float)(p_rect.size.height) / (float)p_fb_size.height + bottomPos; - - // Transform to clip-space coordinates, which are bounded by (-1.0 < p < 1.0) in clip-space. - leftPos = (leftPos * 2.0f) - 1.0f; - rightPos = (rightPos * 2.0f) - 1.0f; - bottomPos = (bottomPos * 2.0f) - 1.0f; - topPos = (topPos * 2.0f) - 1.0f; - - simd::float4 vtx; - - uint32_t idx = p_index; - uint32_t endLayer = render.get_subpass().view_count; - - for (uint32_t layer = 0; layer < endLayer; layer++) { - vtx.z = 0.0; - vtx.w = (float)layer; - - // Top left vertex - First triangle. - vtx.y = topPos; - vtx.x = leftPos; - p_vertices[idx++] = vtx; - - // Bottom left vertex. - vtx.y = bottomPos; - vtx.x = leftPos; - p_vertices[idx++] = vtx; - - // Bottom right vertex. - vtx.y = bottomPos; - vtx.x = rightPos; - p_vertices[idx++] = vtx; - - // Bottom right vertex - Second triangle. - p_vertices[idx++] = vtx; - - // Top right vertex. - vtx.y = topPos; - vtx.x = rightPos; - p_vertices[idx++] = vtx; - - // Top left vertex. - vtx.y = topPos; - vtx.x = leftPos; - p_vertices[idx++] = vtx; - } - - return idx; -} - -void MDCommandBuffer::render_begin_pass(RDD::RenderPassID p_render_pass, RDD::FramebufferID p_frameBuffer, RDD::CommandBufferType p_cmd_buffer_type, const Rect2i &p_rect, VectorView p_clear_values) { - DEV_ASSERT(command_buffer() != nil); - end(); - - MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); - MDFrameBuffer *fb = (MDFrameBuffer *)(p_frameBuffer.id); - - type = MDCommandBufferStateType::Render; - render.pass = pass; - render.current_subpass = UINT32_MAX; - render.render_area = p_rect; - render.clear_values.resize(p_clear_values.size()); - for (uint32_t i = 0; i < p_clear_values.size(); i++) { - render.clear_values[i] = p_clear_values[i]; - } - render.is_rendering_entire_area = (p_rect.position == Point2i(0, 0)) && p_rect.size == fb->size; - render.frameBuffer = fb; - render_next_subpass(); -} - -void MDCommandBuffer::_end_render_pass() { - MDFrameBuffer const &fb_info = *render.frameBuffer; - MDSubpass const &subpass = render.get_subpass(); - - PixelFormats &pf = device_driver->get_pixel_formats(); - - for (uint32_t i = 0; i < subpass.resolve_references.size(); i++) { - uint32_t color_index = subpass.color_references[i].attachment; - uint32_t resolve_index = subpass.resolve_references[i].attachment; - DEV_ASSERT((color_index == RDD::AttachmentReference::UNUSED) == (resolve_index == RDD::AttachmentReference::UNUSED)); - if (color_index == RDD::AttachmentReference::UNUSED || !fb_info.has_texture(color_index)) { - continue; - } - - id resolve_tex = fb_info.get_texture(resolve_index); - - CRASH_COND_MSG(!flags::all(pf.getCapabilities(resolve_tex.pixelFormat), kMTLFmtCapsResolve), "not implemented: unresolvable texture types"); - // see: https://github.com/KhronosGroup/MoltenVK/blob/d20d13fe2735adb845636a81522df1b9d89c0fba/MoltenVK/MoltenVK/GPUObjects/MVKRenderPass.mm#L407 - } - - render.end_encoding(); -} - -void MDCommandBuffer::_render_clear_render_area() { - MDRenderPass const &pass = *render.pass; - MDSubpass const &subpass = render.get_subpass(); - - uint32_t ds_index = subpass.depth_stencil_reference.attachment; - bool clear_depth = (ds_index != RDD::AttachmentReference::UNUSED && pass.attachments[ds_index].shouldClear(subpass, false)); - bool clear_stencil = (ds_index != RDD::AttachmentReference::UNUSED && pass.attachments[ds_index].shouldClear(subpass, true)); - - uint32_t color_count = subpass.color_references.size(); - uint32_t clears_size = color_count + (clear_depth || clear_stencil ? 1 : 0); - if (clears_size == 0) { - return; - } - - RDD::AttachmentClear *clears = ALLOCA_ARRAY(RDD::AttachmentClear, clears_size); - uint32_t clears_count = 0; - - for (uint32_t i = 0; i < color_count; i++) { - uint32_t idx = subpass.color_references[i].attachment; - if (idx != RDD::AttachmentReference::UNUSED && pass.attachments[idx].shouldClear(subpass, false)) { - clears[clears_count++] = { .aspect = RDD::TEXTURE_ASPECT_COLOR_BIT, .color_attachment = idx, .value = render.clear_values[idx] }; - } - } - - if (clear_depth || clear_stencil) { - MDAttachment const &attachment = pass.attachments[ds_index]; - BitField bits = {}; - if (clear_depth && attachment.type & MDAttachmentType::Depth) { - bits.set_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT); - } - if (clear_stencil && attachment.type & MDAttachmentType::Stencil) { - bits.set_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT); - } - - clears[clears_count++] = { .aspect = bits, .color_attachment = ds_index, .value = render.clear_values[ds_index] }; - } - - if (clears_count == 0) { - return; - } - - render_clear_attachments(VectorView(clears, clears_count), { render.render_area }); -} - -void MDCommandBuffer::render_next_subpass() { - DEV_ASSERT(command_buffer() != nil); - - if (render.current_subpass == UINT32_MAX) { - render.current_subpass = 0; - } else { - _end_render_pass(); - render.current_subpass++; - } - - MDFrameBuffer const &fb = *render.frameBuffer; - MDRenderPass const &pass = *render.pass; - MDSubpass const &subpass = render.get_subpass(); - - MTLRenderPassDescriptor *desc = MTLRenderPassDescriptor.renderPassDescriptor; - - if (subpass.view_count > 1) { - desc.renderTargetArrayLength = subpass.view_count; - } - - PixelFormats &pf = device_driver->get_pixel_formats(); - - uint32_t attachmentCount = 0; - for (uint32_t i = 0; i < subpass.color_references.size(); i++) { - uint32_t idx = subpass.color_references[i].attachment; - if (idx == RDD::AttachmentReference::UNUSED) { - continue; - } - - attachmentCount += 1; - MTLRenderPassColorAttachmentDescriptor *ca = desc.colorAttachments[i]; - - uint32_t resolveIdx = subpass.resolve_references.is_empty() ? RDD::AttachmentReference::UNUSED : subpass.resolve_references[i].attachment; - bool has_resolve = resolveIdx != RDD::AttachmentReference::UNUSED; - bool can_resolve = true; - if (resolveIdx != RDD::AttachmentReference::UNUSED) { - id resolve_tex = fb.get_texture(resolveIdx); - can_resolve = flags::all(pf.getCapabilities(resolve_tex.pixelFormat), kMTLFmtCapsResolve); - if (can_resolve) { - ca.resolveTexture = resolve_tex; - } else { - CRASH_NOW_MSG("unimplemented: using a texture format that is not supported for resolve"); - } - } - - MDAttachment const &attachment = pass.attachments[idx]; - - id tex = fb.get_texture(idx); - ERR_FAIL_NULL_MSG(tex, "Frame buffer color texture is null."); - - if ((attachment.type & MDAttachmentType::Color)) { - if (attachment.configureDescriptor(ca, pf, subpass, tex, render.is_rendering_entire_area, has_resolve, can_resolve, false)) { - Color clearColor = render.clear_values[idx].color; - ca.clearColor = MTLClearColorMake(clearColor.r, clearColor.g, clearColor.b, clearColor.a); - } - } - } - - if (subpass.depth_stencil_reference.attachment != RDD::AttachmentReference::UNUSED) { - attachmentCount += 1; - uint32_t idx = subpass.depth_stencil_reference.attachment; - MDAttachment const &attachment = pass.attachments[idx]; - id tex = fb.get_texture(idx); - ERR_FAIL_NULL_MSG(tex, "Frame buffer depth / stencil texture is null."); - if (attachment.type & MDAttachmentType::Depth) { - MTLRenderPassDepthAttachmentDescriptor *da = desc.depthAttachment; - if (attachment.configureDescriptor(da, pf, subpass, tex, render.is_rendering_entire_area, false, false, false)) { - da.clearDepth = render.clear_values[idx].depth; - } - } - - if (attachment.type & MDAttachmentType::Stencil) { - MTLRenderPassStencilAttachmentDescriptor *sa = desc.stencilAttachment; - if (attachment.configureDescriptor(sa, pf, subpass, tex, render.is_rendering_entire_area, false, false, true)) { - sa.clearStencil = render.clear_values[idx].stencil; - } - } - } - - desc.renderTargetWidth = MAX((NSUInteger)MIN(render.render_area.position.x + render.render_area.size.width, fb.size.width), 1u); - desc.renderTargetHeight = MAX((NSUInteger)MIN(render.render_area.position.y + render.render_area.size.height, fb.size.height), 1u); - - if (attachmentCount == 0) { - // If there are no attachments, delay the creation of the encoder, - // so we can use a matching sample count for the pipeline, by setting - // the defaultRasterSampleCount from the pipeline's sample count. - render.desc = desc; - } else { - render.encoder = [command_buffer() renderCommandEncoderWithDescriptor:desc]; - - if (!render.is_rendering_entire_area) { - _render_clear_render_area(); - } - // With a new encoder, all state is dirty. - render.dirty.set_flag(RenderState::DIRTY_ALL); - } -} - -void MDCommandBuffer::render_draw(uint32_t p_vertex_count, - uint32_t p_instance_count, - uint32_t p_base_vertex, - uint32_t p_first_instance) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); - - _render_set_dirty_state(); - - MDSubpass const &subpass = render.get_subpass(); - if (subpass.view_count > 1) { - p_instance_count *= subpass.view_count; - } - - DEV_ASSERT(render.dirty == 0); - - id enc = render.encoder; - - [enc drawPrimitives:render.pipeline->raster_state.render_primitive - vertexStart:p_base_vertex - vertexCount:p_vertex_count - instanceCount:p_instance_count - baseInstance:p_first_instance]; -} - -void MDCommandBuffer::render_bind_vertex_buffers(uint32_t p_binding_count, const RDD::BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - - render.vertex_buffers.resize(p_binding_count); - render.vertex_offsets.resize(p_binding_count); - - // Are the existing buffer bindings the same? - bool same = true; - - // Reverse the buffers, as their bindings are assigned in descending order. - for (uint32_t i = 0; i < p_binding_count; i += 1) { - const RenderingDeviceDriverMetal::BufferInfo *buf_info = (const RenderingDeviceDriverMetal::BufferInfo *)p_buffers[p_binding_count - i - 1].id; - - NSUInteger dynamic_offset = 0; - if (buf_info->is_dynamic()) { - const MetalBufferDynamicInfo *dyn_buf = (const MetalBufferDynamicInfo *)buf_info; - uint64_t frame_idx = p_dynamic_offsets & 0x3; - p_dynamic_offsets >>= 2; - dynamic_offset = frame_idx * dyn_buf->size_bytes; - } - if (render.vertex_buffers[i] != buf_info->metal_buffer) { - render.vertex_buffers[i] = buf_info->metal_buffer; - same = false; - } - - render.vertex_offsets[i] = dynamic_offset + p_offsets[p_binding_count - i - 1]; - } - - if (render.encoder) { - uint32_t first = device_driver->get_metal_buffer_index_for_vertex_attribute_binding(p_binding_count - 1); - if (same) { - NSUInteger *offset_ptr = render.vertex_offsets.ptr(); - for (uint32_t i = first; i < first + p_binding_count; i++) { - [render.encoder setVertexBufferOffset:*offset_ptr atIndex:i]; - offset_ptr++; - } - } else { - [render.encoder setVertexBuffers:render.vertex_buffers.ptr() - offsets:render.vertex_offsets.ptr() - withRange:NSMakeRange(first, p_binding_count)]; - } - render.dirty.clear_flag(RenderState::DIRTY_VERTEX); - } else { - render.dirty.set_flag(RenderState::DIRTY_VERTEX); - } -} - -void MDCommandBuffer::render_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint64_t p_offset) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - - const RenderingDeviceDriverMetal::BufferInfo *buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_buffer.id; - - render.index_buffer = buffer->metal_buffer; - render.index_type = p_format == RDD::IndexBufferFormat::INDEX_BUFFER_FORMAT_UINT16 ? MTLIndexTypeUInt16 : MTLIndexTypeUInt32; - render.index_offset = p_offset; -} - -void MDCommandBuffer::render_draw_indexed(uint32_t p_index_count, - uint32_t p_instance_count, - uint32_t p_first_index, - int32_t p_vertex_offset, - uint32_t p_first_instance) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); - - _render_set_dirty_state(); - - MDSubpass const &subpass = render.get_subpass(); - if (subpass.view_count > 1) { - p_instance_count *= subpass.view_count; - } - - id enc = render.encoder; - - uint32_t index_offset = render.index_offset; - index_offset += p_first_index * (render.index_type == MTLIndexTypeUInt16 ? sizeof(uint16_t) : sizeof(uint32_t)); - - [enc drawIndexedPrimitives:render.pipeline->raster_state.render_primitive - indexCount:p_index_count - indexType:render.index_type - indexBuffer:render.index_buffer - indexBufferOffset:index_offset - instanceCount:p_instance_count - baseVertex:p_vertex_offset - baseInstance:p_first_instance]; -} - -void MDCommandBuffer::render_draw_indexed_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); - - _render_set_dirty_state(); - - id enc = render.encoder; - - const RenderingDeviceDriverMetal::BufferInfo *indirect_buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; - NSUInteger indirect_offset = p_offset; - - for (uint32_t i = 0; i < p_draw_count; i++) { - [enc drawIndexedPrimitives:render.pipeline->raster_state.render_primitive - indexType:render.index_type - indexBuffer:render.index_buffer - indexBufferOffset:0 - indirectBuffer:indirect_buffer->metal_buffer - indirectBufferOffset:indirect_offset]; - indirect_offset += p_stride; - } -} - -void MDCommandBuffer::render_draw_indexed_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { - ERR_FAIL_MSG("not implemented"); -} - -void MDCommandBuffer::render_draw_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - ERR_FAIL_NULL_MSG(render.pipeline, "No pipeline set for render command buffer."); - - _render_set_dirty_state(); - - id enc = render.encoder; - - const RenderingDeviceDriverMetal::BufferInfo *indirect_buffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; - NSUInteger indirect_offset = p_offset; - - for (uint32_t i = 0; i < p_draw_count; i++) { - [enc drawPrimitives:render.pipeline->raster_state.render_primitive - indirectBuffer:indirect_buffer->metal_buffer - indirectBufferOffset:indirect_offset]; - indirect_offset += p_stride; - } -} - -void MDCommandBuffer::render_draw_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { - ERR_FAIL_MSG("not implemented"); -} - -void MDCommandBuffer::render_end_pass() { - DEV_ASSERT(type == MDCommandBufferStateType::Render); - - render.end_encoding(); - render.reset(); - reset(); -} - -#pragma mark - RenderState - -void MDCommandBuffer::RenderState::reset() { - pass = nil; - frameBuffer = nil; - pipeline = nil; - current_subpass = UINT32_MAX; - render_area = {}; - is_rendering_entire_area = false; - desc = nil; - encoder = nil; - index_buffer = nil; - index_type = MTLIndexTypeUInt16; - dirty = DIRTY_NONE; - uniform_sets.clear(); - dynamic_offsets = 0; - uniform_set_mask = 0; - clear_values.clear(); - viewports.clear(); - scissors.clear(); - blend_constants.reset(); - bzero(vertex_buffers.ptr(), sizeof(id __unsafe_unretained) * vertex_buffers.size()); - vertex_buffers.clear(); - bzero(vertex_offsets.ptr(), sizeof(NSUInteger) * vertex_offsets.size()); - vertex_offsets.clear(); - resource_tracker.reset(); -} - -void MDCommandBuffer::RenderState::end_encoding() { - if (encoder == nil) { - return; - } - - [encoder endEncoding]; - encoder = nil; -} - -#pragma mark - ComputeState - -void MDCommandBuffer::ComputeState::end_encoding() { - if (encoder == nil) { - return; - } - - [encoder endEncoding]; - encoder = nil; -} - -#pragma mark - Compute - -void MDCommandBuffer::_compute_set_dirty_state() { - if (compute.dirty.has_flag(ComputeState::DIRTY_PIPELINE)) { - compute.encoder = [command_buffer() computeCommandEncoderWithDispatchType:MTLDispatchTypeConcurrent]; - [compute.encoder setComputePipelineState:compute.pipeline->state]; - } - - _compute_bind_uniform_sets(); - - if (compute.dirty.has_flag(ComputeState::DIRTY_PUSH)) { - if (push_constant_binding != UINT32_MAX) { - [compute.encoder setBytes:push_constant_data - length:push_constant_data_len - atIndex:push_constant_binding]; - } - } - - compute.resource_tracker.encode(compute.encoder); - - compute.dirty.clear(); -} - -void MDCommandBuffer::_compute_bind_uniform_sets() { - DEV_ASSERT(type == MDCommandBufferStateType::Compute); - if (!compute.dirty.has_flag(ComputeState::DIRTY_UNIFORMS)) { - return; - } - - compute.dirty.clear_flag(ComputeState::DIRTY_UNIFORMS); - uint64_t set_uniforms = compute.uniform_set_mask; - compute.uniform_set_mask = 0; - - MDComputeShader *shader = compute.pipeline->shader; - const uint32_t dynamic_offsets = compute.dynamic_offsets; - - while (set_uniforms != 0) { - // Find the index of the next set bit. - uint32_t index = (uint32_t)__builtin_ctzll(set_uniforms); - // Clear the set bit. - set_uniforms &= (set_uniforms - 1); - MDUniformSet *set = compute.uniform_sets[index]; - if (set == nullptr || index >= (uint32_t)shader->sets.size()) { - continue; - } - if (shader->uses_argument_buffers) { - set->bind_uniforms_argument_buffers(shader, compute, index, dynamic_offsets, device_driver->frame_index(), device_driver->frame_count()); - } else { - DirectEncoder de(compute.encoder, binding_cache); - set->bind_uniforms_direct(shader, de, index, dynamic_offsets); - } - } -} - -void MDCommandBuffer::ComputeState::reset() { - pipeline = nil; - encoder = nil; - dirty = DIRTY_NONE; - uniform_sets.clear(); - dynamic_offsets = 0; - uniform_set_mask = 0; - resource_tracker.reset(); -} - -void MDCommandBuffer::compute_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { - DEV_ASSERT(type == MDCommandBufferStateType::Compute); - - if (uint32_t new_size = p_first_set_index + p_set_count; compute.uniform_sets.size() < new_size) { - uint32_t s = compute.uniform_sets.size(); - compute.uniform_sets.resize(new_size); - // Set intermediate values to null. - std::fill(&compute.uniform_sets[s], compute.uniform_sets.end().operator->(), nullptr); - } - - const MDShader *shader = (const MDShader *)p_shader.id; - DynamicOffsetLayout layout = shader->dynamic_offset_layout; - - // Clear bits for sets being rebound before OR'ing new values. - // This prevents corruption when the same set is bound multiple times - // with different frame indices. - for (uint32_t i = 0; i < p_set_count && compute.dynamic_offsets != 0; i++) { - uint32_t set_index = p_first_set_index + i; - uint32_t count = layout.get_count(set_index); - if (count > 0) { - uint32_t shift = layout.get_offset_index_shift(set_index); - uint32_t mask = ((1u << (count * 4u)) - 1u) << shift; - compute.dynamic_offsets &= ~mask; - } - } - compute.dynamic_offsets |= p_dynamic_offsets; - - for (size_t i = 0; i < p_set_count; ++i) { - MDUniformSet *set = (MDUniformSet *)(p_uniform_sets[i].id); - - uint32_t index = p_first_set_index + i; - if (compute.uniform_sets[index] != set || layout.get_count(index) > 0) { - compute.dirty.set_flag(ComputeState::DIRTY_UNIFORMS); - compute.uniform_set_mask |= 1ULL << index; - compute.uniform_sets[index] = set; - } - } -} - -void MDCommandBuffer::compute_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) { - DEV_ASSERT(type == MDCommandBufferStateType::Compute); - - _compute_set_dirty_state(); - - MTLRegion region = MTLRegionMake3D(0, 0, 0, p_x_groups, p_y_groups, p_z_groups); - - id enc = compute.encoder; - [enc dispatchThreadgroups:region.size threadsPerThreadgroup:compute.pipeline->compute_state.local]; -} - -void MDCommandBuffer::compute_dispatch_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset) { - DEV_ASSERT(type == MDCommandBufferStateType::Compute); - - _compute_set_dirty_state(); - - const RenderingDeviceDriverMetal::BufferInfo *indirectBuffer = (const RenderingDeviceDriverMetal::BufferInfo *)p_indirect_buffer.id; - - id enc = compute.encoder; - [enc dispatchThreadgroupsWithIndirectBuffer:indirectBuffer->metal_buffer indirectBufferOffset:p_offset threadsPerThreadgroup:compute.pipeline->compute_state.local]; -} - -void MDCommandBuffer::reset() { - push_constant_data_len = 0; - type = MDCommandBufferStateType::None; -} - -void MDCommandBuffer::_end_compute_dispatch() { - DEV_ASSERT(type == MDCommandBufferStateType::Compute); - - compute.end_encoding(); - compute.reset(); - reset(); -} - -void MDCommandBuffer::_end_blit() { - DEV_ASSERT(type == MDCommandBufferStateType::Blit); - - [blit.encoder endEncoding]; - blit.reset(); - reset(); -} - -MDComputeShader::MDComputeShader(CharString p_name, - Vector p_sets, - bool p_uses_argument_buffers, - MDLibrary *p_kernel) : - MDShader(p_name, p_sets, p_uses_argument_buffers), kernel(p_kernel) { -} - -MDRenderShader::MDRenderShader(CharString p_name, - Vector p_sets, - bool p_needs_view_mask_buffer, - bool p_uses_argument_buffers, - MDLibrary *_Nonnull p_vert, MDLibrary *_Nonnull p_frag) : - MDShader(p_name, p_sets, p_uses_argument_buffers), - needs_view_mask_buffer(p_needs_view_mask_buffer), - vert(p_vert), - frag(p_frag) { -} - -void DirectEncoder::set(__unsafe_unretained id *p_textures, NSRange p_range) { - if (cache.update(p_range, p_textures)) { - switch (mode) { - case RENDER: { - id __unsafe_unretained enc = (id)encoder; - [enc setVertexTextures:p_textures withRange:p_range]; - [enc setFragmentTextures:p_textures withRange:p_range]; - } break; - case COMPUTE: { - id __unsafe_unretained enc = (id)encoder; - [enc setTextures:p_textures withRange:p_range]; - } break; - } - } -} - -void DirectEncoder::set(__unsafe_unretained id *p_buffers, const NSUInteger *p_offsets, NSRange p_range) { - if (cache.update(p_range, p_buffers, p_offsets)) { - switch (mode) { - case RENDER: { - id __unsafe_unretained enc = (id)encoder; - [enc setVertexBuffers:p_buffers offsets:p_offsets withRange:p_range]; - [enc setFragmentBuffers:p_buffers offsets:p_offsets withRange:p_range]; - } break; - case COMPUTE: { - id __unsafe_unretained enc = (id)encoder; - [enc setBuffers:p_buffers offsets:p_offsets withRange:p_range]; - } break; - } - } -} - -void DirectEncoder::set(id __unsafe_unretained p_buffer, const NSUInteger p_offset, uint32_t p_index) { - if (cache.update(p_buffer, p_offset, p_index)) { - switch (mode) { - case RENDER: { - id __unsafe_unretained enc = (id)encoder; - [enc setVertexBuffer:p_buffer offset:p_offset atIndex:p_index]; - [enc setFragmentBuffer:p_buffer offset:p_offset atIndex:p_index]; - } break; - case COMPUTE: { - id __unsafe_unretained enc = (id)encoder; - [enc setBuffer:p_buffer offset:p_offset atIndex:p_index]; - } break; - } - } -} - -void DirectEncoder::set(__unsafe_unretained id *p_samplers, NSRange p_range) { - if (cache.update(p_range, p_samplers)) { - switch (mode) { - case RENDER: { - id __unsafe_unretained enc = (id)encoder; - [enc setVertexSamplerStates:p_samplers withRange:p_range]; - [enc setFragmentSamplerStates:p_samplers withRange:p_range]; - } break; - case COMPUTE: { - id __unsafe_unretained enc = (id)encoder; - [enc setSamplerStates:p_samplers withRange:p_range]; - } break; - } - } -} - -void MDUniformSet::bind_uniforms_argument_buffers(MDShader *p_shader, MDCommandBuffer::RenderState &p_state, uint32_t p_set_index, uint32_t p_dynamic_offsets, uint32_t p_frame_idx, uint32_t p_frame_count) { - DEV_ASSERT(p_shader->uses_argument_buffers); - DEV_ASSERT(p_state.encoder != nil); - DEV_ASSERT(p_shader->dynamic_offset_layout.is_empty()); // Argument buffers do not support dynamic offsets. - - id __unsafe_unretained enc = p_state.encoder; - - p_state.resource_tracker.merge_from(usage_to_resources); - - [enc setVertexBuffer:arg_buffer - offset:0 - atIndex:p_set_index]; - [enc setFragmentBuffer:arg_buffer offset:0 atIndex:p_set_index]; -} - -void MDUniformSet::bind_uniforms_direct(MDShader *p_shader, DirectEncoder p_enc, uint32_t p_set_index, uint32_t p_dynamic_offsets) { - DEV_ASSERT(!p_shader->uses_argument_buffers); - - UniformSet const &set = p_shader->sets[p_set_index]; - DynamicOffsetLayout layout = p_shader->dynamic_offset_layout; - uint32_t dynamic_index = 0; - - for (uint32_t i = 0; i < MIN(uniforms.size(), set.uniforms.size()); i++) { - RDD::BoundUniform const &uniform = uniforms[i]; - const UniformInfo &ui = set.uniforms[i]; - const UniformInfo::Indexes &indexes = ui.slot; - - uint32_t frame_idx; - if (uniform.is_dynamic()) { - uint32_t shift = layout.get_offset_index_shift(p_set_index, dynamic_index); - dynamic_index++; - frame_idx = (p_dynamic_offsets >> shift) & 0xf; - } else { - frame_idx = 0; - } - - switch (uniform.type) { - case RDD::UNIFORM_TYPE_SAMPLER: { - size_t count = uniform.ids.size(); - id __unsafe_unretained *objects = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (size_t j = 0; j < count; j += 1) { - objects[j] = rid::get(uniform.ids[j].id); - } - NSRange sampler_range = NSMakeRange(indexes.sampler, count); - p_enc.set(objects, sampler_range); - } break; - case RDD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: { - size_t count = uniform.ids.size() / 2; - id __unsafe_unretained *textures = ALLOCA_ARRAY(id __unsafe_unretained, count); - id __unsafe_unretained *samplers = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (uint32_t j = 0; j < count; j += 1) { - id sampler = rid::get(uniform.ids[j * 2 + 0]); - id texture = rid::get(uniform.ids[j * 2 + 1]); - samplers[j] = sampler; - textures[j] = texture; - } - NSRange sampler_range = NSMakeRange(indexes.sampler, count); - NSRange texture_range = NSMakeRange(indexes.texture, count); - p_enc.set(samplers, sampler_range); - p_enc.set(textures, texture_range); - } break; - case RDD::UNIFORM_TYPE_TEXTURE: { - size_t count = uniform.ids.size(); - id __unsafe_unretained *objects = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (size_t j = 0; j < count; j += 1) { - id obj = rid::get(uniform.ids[j]); - objects[j] = obj; - } - NSRange texture_range = NSMakeRange(indexes.texture, count); - p_enc.set(objects, texture_range); - } break; - case RDD::UNIFORM_TYPE_IMAGE: { - size_t count = uniform.ids.size(); - id __unsafe_unretained *objects = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (size_t j = 0; j < count; j += 1) { - id obj = rid::get(uniform.ids[j]); - objects[j] = obj; - } - NSRange texture_range = NSMakeRange(indexes.texture, count); - p_enc.set(objects, texture_range); - - if (indexes.buffer != UINT32_MAX) { - // Emulated atomic image access. - id __unsafe_unretained *bufs = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (size_t j = 0; j < count; j += 1) { - id obj = rid::get(uniform.ids[j]); - id tex = obj.parentTexture ? obj.parentTexture : obj; - id buf = tex.buffer; - bufs[j] = buf; - } - NSUInteger *offs = ALLOCA_ARRAY(NSUInteger, count); - bzero(offs, sizeof(NSUInteger) * count); - NSRange buffer_range = NSMakeRange(indexes.buffer, count); - p_enc.set(bufs, offs, buffer_range); - } - } break; - case RDD::UNIFORM_TYPE_TEXTURE_BUFFER: { - ERR_PRINT("not implemented: UNIFORM_TYPE_TEXTURE_BUFFER"); - } break; - case RDD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER: { - ERR_PRINT("not implemented: UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER"); - } break; - case RDD::UNIFORM_TYPE_IMAGE_BUFFER: { - CRASH_NOW_MSG("not implemented: UNIFORM_TYPE_IMAGE_BUFFER"); - } break; - case RDD::UNIFORM_TYPE_UNIFORM_BUFFER: - case RDD::UNIFORM_TYPE_STORAGE_BUFFER: { - const RDM::BufferInfo *buf_info = (const RDM::BufferInfo *)uniform.ids[0].id; - p_enc.set(buf_info->metal_buffer, 0, indexes.buffer); - } break; - case RDD::UNIFORM_TYPE_UNIFORM_BUFFER_DYNAMIC: - case RDD::UNIFORM_TYPE_STORAGE_BUFFER_DYNAMIC: { - const MetalBufferDynamicInfo *buf_info = (const MetalBufferDynamicInfo *)uniform.ids[0].id; - p_enc.set(buf_info->metal_buffer, frame_idx * buf_info->size_bytes, indexes.buffer); - } break; - case RDD::UNIFORM_TYPE_INPUT_ATTACHMENT: { - size_t count = uniform.ids.size(); - id __unsafe_unretained *objects = ALLOCA_ARRAY(id __unsafe_unretained, count); - for (size_t j = 0; j < count; j += 1) { - id obj = rid::get(uniform.ids[j]); - objects[j] = obj; - } - NSRange texture_range = NSMakeRange(indexes.texture, count); - p_enc.set(objects, texture_range); - } break; - default: { - DEV_ASSERT(false); - } - } - } -} - -void MDUniformSet::bind_uniforms_argument_buffers(MDShader *p_shader, MDCommandBuffer::ComputeState &p_state, uint32_t p_set_index, uint32_t p_dynamic_offsets, uint32_t p_frame_idx, uint32_t p_frame_count) { - DEV_ASSERT(p_shader->uses_argument_buffers); - DEV_ASSERT(p_state.encoder != nil); - - id enc = p_state.encoder; - - p_state.resource_tracker.merge_from(usage_to_resources); - [enc setBuffer:arg_buffer - offset:0 - atIndex:p_set_index]; -} - -MTLFmtCaps MDSubpass::getRequiredFmtCapsForAttachmentAt(uint32_t p_index) const { - MTLFmtCaps caps = kMTLFmtCapsNone; - - for (RDD::AttachmentReference const &ar : input_references) { - if (ar.attachment == p_index) { - flags::set(caps, kMTLFmtCapsRead); - break; - } - } - - for (RDD::AttachmentReference const &ar : color_references) { - if (ar.attachment == p_index) { - flags::set(caps, kMTLFmtCapsColorAtt); - break; - } - } - - for (RDD::AttachmentReference const &ar : resolve_references) { - if (ar.attachment == p_index) { - flags::set(caps, kMTLFmtCapsResolve); - break; - } - } - - if (depth_stencil_reference.attachment == p_index) { - flags::set(caps, kMTLFmtCapsDSAtt); - } - - return caps; -} - -void MDAttachment::linkToSubpass(const MDRenderPass &p_pass) { - firstUseSubpassIndex = UINT32_MAX; - lastUseSubpassIndex = 0; - - for (MDSubpass const &subpass : p_pass.subpasses) { - MTLFmtCaps reqCaps = subpass.getRequiredFmtCapsForAttachmentAt(index); - if (reqCaps) { - firstUseSubpassIndex = MIN(subpass.subpass_index, firstUseSubpassIndex); - lastUseSubpassIndex = MAX(subpass.subpass_index, lastUseSubpassIndex); - } - } -} - -MTLStoreAction MDAttachment::getMTLStoreAction(MDSubpass const &p_subpass, - bool p_is_rendering_entire_area, - bool p_has_resolve, - bool p_can_resolve, - bool p_is_stencil) const { - if (!p_is_rendering_entire_area || !isLastUseOf(p_subpass)) { - return p_has_resolve && p_can_resolve ? MTLStoreActionStoreAndMultisampleResolve : MTLStoreActionStore; - } - - switch (p_is_stencil ? stencilStoreAction : storeAction) { - case MTLStoreActionStore: - return p_has_resolve && p_can_resolve ? MTLStoreActionStoreAndMultisampleResolve : MTLStoreActionStore; - case MTLStoreActionDontCare: - return p_has_resolve ? (p_can_resolve ? MTLStoreActionMultisampleResolve : MTLStoreActionStore) : MTLStoreActionDontCare; - - default: - return MTLStoreActionStore; - } -} - -bool MDAttachment::configureDescriptor(MTLRenderPassAttachmentDescriptor *p_desc, - PixelFormats &p_pf, - MDSubpass const &p_subpass, - id p_attachment, - bool p_is_rendering_entire_area, - bool p_has_resolve, - bool p_can_resolve, - bool p_is_stencil) const { - p_desc.texture = p_attachment; - - MTLLoadAction load; - if (!p_is_rendering_entire_area || !isFirstUseOf(p_subpass)) { - load = MTLLoadActionLoad; - } else { - load = p_is_stencil ? stencilLoadAction : loadAction; - } - - p_desc.loadAction = load; - - MTLPixelFormat mtlFmt = p_attachment.pixelFormat; - bool isDepthFormat = p_pf.isDepthFormat(mtlFmt); - bool isStencilFormat = p_pf.isStencilFormat(mtlFmt); - if (isStencilFormat && !p_is_stencil && !isDepthFormat) { - p_desc.storeAction = MTLStoreActionDontCare; - } else { - p_desc.storeAction = getMTLStoreAction(p_subpass, p_is_rendering_entire_area, p_has_resolve, p_can_resolve, p_is_stencil); - } - - return load == MTLLoadActionClear; -} - -bool MDAttachment::shouldClear(const MDSubpass &p_subpass, bool p_is_stencil) const { - // If the subpass is not the first subpass to use this attachment, don't clear this attachment. - if (p_subpass.subpass_index != firstUseSubpassIndex) { - return false; - } - return (p_is_stencil ? stencilLoadAction : loadAction) == MTLLoadActionClear; -} - -MDRenderPass::MDRenderPass(Vector &p_attachments, Vector &p_subpasses) : - attachments(p_attachments), subpasses(p_subpasses) { - for (MDAttachment &att : attachments) { - att.linkToSubpass(*this); - } -} - -#pragma mark - Resource Factory - -id MDResourceFactory::new_func(NSString *p_source, NSString *p_name, NSError **p_error) { - @autoreleasepool { - NSError *err = nil; - MTLCompileOptions *options = [MTLCompileOptions new]; - id device = device_driver->get_device(); - id mtlLib = [device newLibraryWithSource:p_source - options:options - error:&err]; - if (err) { - if (p_error != nil) { - *p_error = err; - } - } - return [mtlLib newFunctionWithName:p_name]; - } -} - -id MDResourceFactory::new_clear_vert_func(ClearAttKey &p_key) { - @autoreleasepool { - NSString *msl = [NSString stringWithFormat:@R"( -#include -using namespace metal; - -typedef struct { - float4 a_position [[attribute(0)]]; -} AttributesPos; - -typedef struct { - float4 colors[9]; -} ClearColorsIn; - -typedef struct { - float4 v_position [[position]]; - uint layer%s; -} VaryingsPos; - -vertex VaryingsPos vertClear(AttributesPos attributes [[stage_in]], constant ClearColorsIn& ccIn [[buffer(0)]]) { - VaryingsPos varyings; - varyings.v_position = float4(attributes.a_position.x, -attributes.a_position.y, ccIn.colors[%d].r, 1.0); - varyings.layer = uint(attributes.a_position.w); - return varyings; -} -)", p_key.is_layered_rendering_enabled() ? " [[render_target_array_index]]" : "", ClearAttKey::DEPTH_INDEX]; - - return new_func(msl, @"vertClear", nil); - } -} - -id MDResourceFactory::new_clear_frag_func(ClearAttKey &p_key) { - @autoreleasepool { - NSMutableString *msl = [NSMutableString stringWithCapacity:2048]; - - [msl appendFormat:@R"( -#include -using namespace metal; - -typedef struct { - float4 v_position [[position]]; -} VaryingsPos; - -typedef struct { - float4 colors[9]; -} ClearColorsIn; - -typedef struct { -)"]; - - for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { - if (p_key.is_enabled(caIdx)) { - NSString *typeStr = get_format_type_string((MTLPixelFormat)p_key.pixel_formats[caIdx]); - [msl appendFormat:@" %@4 color%u [[color(%u)]];\n", typeStr, caIdx, caIdx]; - } - } - [msl appendFormat:@R"(} ClearColorsOut; - -fragment ClearColorsOut fragClear(VaryingsPos varyings [[stage_in]], constant ClearColorsIn& ccIn [[buffer(0)]]) { - - ClearColorsOut ccOut; -)"]; - for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { - if (p_key.is_enabled(caIdx)) { - NSString *typeStr = get_format_type_string((MTLPixelFormat)p_key.pixel_formats[caIdx]); - [msl appendFormat:@" ccOut.color%u = %@4(ccIn.colors[%u]);\n", caIdx, typeStr, caIdx]; - } - } - [msl appendString:@R"( return ccOut; -})"]; - - return new_func(msl, @"fragClear", nil); - } -} - -NSString *MDResourceFactory::get_format_type_string(MTLPixelFormat p_fmt) { - switch (device_driver->get_pixel_formats().getFormatType(p_fmt)) { - case MTLFormatType::ColorInt8: - case MTLFormatType::ColorInt16: - return @"short"; - case MTLFormatType::ColorUInt8: - case MTLFormatType::ColorUInt16: - return @"ushort"; - case MTLFormatType::ColorInt32: - return @"int"; - case MTLFormatType::ColorUInt32: - return @"uint"; - case MTLFormatType::ColorHalf: - return @"half"; - case MTLFormatType::ColorFloat: - case MTLFormatType::DepthStencil: - case MTLFormatType::Compressed: - return @"float"; - case MTLFormatType::None: - return @"unexpected_MTLPixelFormatInvalid"; - } -} - -id MDResourceFactory::new_depth_stencil_state(bool p_use_depth, bool p_use_stencil) { - MTLDepthStencilDescriptor *dsDesc = [MTLDepthStencilDescriptor new]; - dsDesc.depthCompareFunction = MTLCompareFunctionAlways; - dsDesc.depthWriteEnabled = p_use_depth; - - if (p_use_stencil) { - MTLStencilDescriptor *sDesc = [MTLStencilDescriptor new]; - sDesc.stencilCompareFunction = MTLCompareFunctionAlways; - sDesc.stencilFailureOperation = MTLStencilOperationReplace; - sDesc.depthFailureOperation = MTLStencilOperationReplace; - sDesc.depthStencilPassOperation = MTLStencilOperationReplace; - - dsDesc.frontFaceStencil = sDesc; - dsDesc.backFaceStencil = sDesc; - } else { - dsDesc.frontFaceStencil = nil; - dsDesc.backFaceStencil = nil; - } - - return [device_driver->get_device() newDepthStencilStateWithDescriptor:dsDesc]; -} - -id MDResourceFactory::new_clear_pipeline_state(ClearAttKey &p_key, NSError **p_error) { - PixelFormats &pixFmts = device_driver->get_pixel_formats(); - - id vtxFunc = new_clear_vert_func(p_key); - id fragFunc = new_clear_frag_func(p_key); - MTLRenderPipelineDescriptor *plDesc = [MTLRenderPipelineDescriptor new]; - plDesc.label = @"ClearRenderAttachments"; - plDesc.vertexFunction = vtxFunc; - plDesc.fragmentFunction = fragFunc; - plDesc.rasterSampleCount = p_key.sample_count; - plDesc.inputPrimitiveTopology = MTLPrimitiveTopologyClassTriangle; - - for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { - MTLRenderPipelineColorAttachmentDescriptor *colorDesc = plDesc.colorAttachments[caIdx]; - colorDesc.pixelFormat = (MTLPixelFormat)p_key.pixel_formats[caIdx]; - colorDesc.writeMask = p_key.is_enabled(caIdx) ? MTLColorWriteMaskAll : MTLColorWriteMaskNone; - } - - MTLPixelFormat mtlDepthFormat = p_key.depth_format(); - if (pixFmts.isDepthFormat(mtlDepthFormat)) { - plDesc.depthAttachmentPixelFormat = mtlDepthFormat; - } - - MTLPixelFormat mtlStencilFormat = p_key.stencil_format(); - if (pixFmts.isStencilFormat(mtlStencilFormat)) { - plDesc.stencilAttachmentPixelFormat = mtlStencilFormat; - } - - MTLVertexDescriptor *vtxDesc = plDesc.vertexDescriptor; - - // Vertex attribute descriptors. - MTLVertexAttributeDescriptorArray *vaDescArray = vtxDesc.attributes; - MTLVertexAttributeDescriptor *vaDesc; - NSUInteger vtxBuffIdx = device_driver->get_metal_buffer_index_for_vertex_attribute_binding(VERT_CONTENT_BUFFER_INDEX); - NSUInteger vtxStride = 0; - - // Vertex location. - vaDesc = vaDescArray[0]; - vaDesc.format = MTLVertexFormatFloat4; - vaDesc.bufferIndex = vtxBuffIdx; - vaDesc.offset = vtxStride; - vtxStride += sizeof(simd::float4); - - // Vertex attribute buffer. - MTLVertexBufferLayoutDescriptorArray *vbDescArray = vtxDesc.layouts; - MTLVertexBufferLayoutDescriptor *vbDesc = vbDescArray[vtxBuffIdx]; - vbDesc.stepFunction = MTLVertexStepFunctionPerVertex; - vbDesc.stepRate = 1; - vbDesc.stride = vtxStride; - - return [device_driver->get_device() newRenderPipelineStateWithDescriptor:plDesc error:p_error]; -} - -id MDResourceCache::get_clear_render_pipeline_state(ClearAttKey &p_key, NSError **p_error) { - HashMap::ConstIterator it = clear_states.find(p_key); - if (it != clear_states.end()) { - return it->value; - } - - id state = resource_factory->new_clear_pipeline_state(p_key, p_error); - clear_states[p_key] = state; - return state; -} - -id MDResourceCache::get_depth_stencil_state(bool p_use_depth, bool p_use_stencil) { - id __strong *val; - if (p_use_depth && p_use_stencil) { - val = &clear_depth_stencil_state.all; - } else if (p_use_depth) { - val = &clear_depth_stencil_state.depth_only; - } else if (p_use_stencil) { - val = &clear_depth_stencil_state.stencil_only; - } else { - val = &clear_depth_stencil_state.none; - } - DEV_ASSERT(val != nullptr); - - if (*val == nil) { - *val = resource_factory->new_depth_stencil_state(p_use_depth, p_use_stencil); - } - return *val; -} - -static const char *SHADER_STAGE_NAMES[] = { - [RD::SHADER_STAGE_VERTEX] = "vert", - [RD::SHADER_STAGE_FRAGMENT] = "frag", - [RD::SHADER_STAGE_TESSELATION_CONTROL] = "tess_ctrl", - [RD::SHADER_STAGE_TESSELATION_EVALUATION] = "tess_eval", - [RD::SHADER_STAGE_COMPUTE] = "comp", -}; - -void ShaderCacheEntry::notify_free() const { - owner.shader_cache_free_entry(key); -} - -@interface MDLibrary () -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry -#ifdef DEV_ENABLED - source:(NSString *)source; -#endif -; -@end - -/// Loads the MTLLibrary when the library is first accessed. -@interface MDLazyLibrary : MDLibrary { - id _library; - NSError *_error; - std::shared_mutex _mu; - bool _loaded; - id _device; - NSString *_source; - MTLCompileOptions *_options; -} -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options; -@end - -/// Loads the MTLLibrary immediately on initialization, using an asynchronous API. -@interface MDImmediateLibrary : MDLibrary { - id _library; - NSError *_error; - std::mutex _cv_mutex; - std::condition_variable _cv; - std::atomic _complete; - bool _ready; -} -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options; -@end - -@interface MDBinaryLibrary : MDLibrary { - id _library; - NSError *_error; -} -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device -#ifdef DEV_ENABLED - source:(NSString *)source -#endif - data:(dispatch_data_t)data; -@end - -@implementation MDLibrary - -+ (instancetype)newLibraryWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options - strategy:(ShaderLoadStrategy)strategy { - switch (strategy) { - case ShaderLoadStrategy::IMMEDIATE: - [[fallthrough]]; - default: - return [[MDImmediateLibrary alloc] initWithCacheEntry:entry device:device source:source options:options]; - case ShaderLoadStrategy::LAZY: - return [[MDLazyLibrary alloc] initWithCacheEntry:entry device:device source:source options:options]; - } -} - -+ (instancetype)newLibraryWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device -#ifdef DEV_ENABLED - source:(NSString *)source -#endif - data:(dispatch_data_t)data { - return [[MDBinaryLibrary alloc] initWithCacheEntry:entry - device:device -#ifdef DEV_ENABLED - source:source -#endif - data:data]; -} - -#ifdef DEV_ENABLED -- (NSString *)originalSource { - return _original_source; -} -#endif - -- (id)library { - CRASH_NOW_MSG("Not implemented"); - return nil; -} - -- (NSError *)error { - CRASH_NOW_MSG("Not implemented"); - return nil; -} - -- (void)setLabel:(NSString *)label { -} - -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry -#ifdef DEV_ENABLED - source:(NSString *)source -#endif -{ - self = [super init]; - _entry = entry; - _entry->library = self; -#ifdef DEV_ENABLED - _original_source = source; -#endif - return self; -} - -- (void)dealloc { - _entry->notify_free(); -} - -@end - -@implementation MDImmediateLibrary - -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options { - self = [super initWithCacheEntry:entry -#ifdef DEV_ENABLED - source:source -#endif - ]; - _complete = false; - _ready = false; - - __block os_signpost_id_t compile_id = (os_signpost_id_t)(uintptr_t)self; - os_signpost_interval_begin(LOG_INTERVALS, compile_id, "shader_compile", - "shader_name=%{public}s stage=%{public}s hash=%X", - entry->name.get_data(), SHADER_STAGE_NAMES[entry->stage], entry->key.short_sha()); - - [device newLibraryWithSource:source - options:options - completionHandler:^(id library, NSError *error) { - os_signpost_interval_end(LOG_INTERVALS, compile_id, "shader_compile"); - self->_library = library; - self->_error = error; - if (error) { - ERR_PRINT(vformat(U"Error compiling shader %s: %s", entry->name.get_data(), error.localizedDescription.UTF8String)); - } - - { - std::lock_guard lock(self->_cv_mutex); - _ready = true; - } - _cv.notify_all(); - _complete = true; - }]; - return self; -} - -- (id)library { - if (!_complete) { - std::unique_lock lock(_cv_mutex); - _cv.wait(lock, [&] { return _ready; }); - } - return _library; -} - -- (NSError *)error { - if (!_complete) { - std::unique_lock lock(_cv_mutex); - _cv.wait(lock, [&] { return _ready; }); - } - return _error; -} - -@end - -@implementation MDLazyLibrary -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device - source:(NSString *)source - options:(MTLCompileOptions *)options { - self = [super initWithCacheEntry:entry -#ifdef DEV_ENABLED - source:source -#endif - ]; - _device = device; - _source = source; - _options = options; - - return self; -} - -- (void)load { - { - std::shared_lock lock(_mu); - if (_loaded) { - return; - } - } - - std::unique_lock lock(_mu); - if (_loaded) { - return; - } - - __block os_signpost_id_t compile_id = (os_signpost_id_t)(uintptr_t)self; - os_signpost_interval_begin(LOG_INTERVALS, compile_id, "shader_compile", - "shader_name=%{public}s stage=%{public}s hash=%X", - _entry->name.get_data(), SHADER_STAGE_NAMES[_entry->stage], _entry->key.short_sha()); - NSError *error; - _library = [_device newLibraryWithSource:_source options:_options error:&error]; - os_signpost_interval_end(LOG_INTERVALS, compile_id, "shader_compile"); - _device = nil; - _source = nil; - _options = nil; - _loaded = true; -} - -- (id)library { - [self load]; - return _library; -} - -- (NSError *)error { - [self load]; - return _error; -} - -@end - -@implementation MDBinaryLibrary - -- (instancetype)initWithCacheEntry:(ShaderCacheEntry *)entry - device:(id)device -#ifdef DEV_ENABLED - source:(NSString *)source -#endif - data:(dispatch_data_t)data { - self = [super initWithCacheEntry:entry -#ifdef DEV_ENABLED - source:source -#endif - ]; - NSError *error = nil; - _library = [device newLibraryWithData:data error:&error]; - if (error != nil) { - _error = error; - NSString *desc = [error description]; - ERR_PRINT(vformat("Unable to load shader library: %s", desc.UTF8String)); - } - return self; -} - -- (id)library { - return _library; -} - -- (NSError *)error { - return _error; -} - -@end diff --git a/drivers/metal/metal_objects_shared.cpp b/drivers/metal/metal_objects_shared.cpp new file mode 100644 index 0000000000..5cafa067fc --- /dev/null +++ b/drivers/metal/metal_objects_shared.cpp @@ -0,0 +1,897 @@ +/**************************************************************************/ +/* metal_objects_shared.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#include "metal_objects_shared.h" + +#include "rendering_device_driver_metal.h" + +#include +#include +#include + +#pragma mark - Resource Factory + +NS::SharedPtr MDResourceFactory::new_func(NS::String *p_source, NS::String *p_name, NS::Error **p_error) { + NS::SharedPtr pool = NS::TransferPtr(NS::AutoreleasePool::alloc()->init()); + NS::SharedPtr options = NS::TransferPtr(MTL::CompileOptions::alloc()->init()); + NS::Error *err = nullptr; + NS::SharedPtr mtlLib = NS::TransferPtr(device->newLibrary(p_source, options.get(), &err)); + if (err) { + if (p_error != nullptr) { + *p_error = err; + } + } + return NS::TransferPtr(mtlLib->newFunction(p_name)); +} + +NS::SharedPtr MDResourceFactory::new_clear_vert_func(ClearAttKey &p_key) { + NS::SharedPtr pool = NS::TransferPtr(NS::AutoreleasePool::alloc()->init()); + char msl[1024]; + snprintf(msl, sizeof(msl), R"( +#include +using namespace metal; + +typedef struct { + float4 a_position [[attribute(0)]]; +} AttributesPos; + +typedef struct { + float4 colors[9]; +} ClearColorsIn; + +typedef struct { + float4 v_position [[position]]; + uint layer%s; +} VaryingsPos; + +vertex VaryingsPos vertClear(AttributesPos attributes [[stage_in]], constant ClearColorsIn& ccIn [[buffer(0)]]) { + VaryingsPos varyings; + varyings.v_position = float4(attributes.a_position.x, -attributes.a_position.y, ccIn.colors[%d].r, 1.0); + varyings.layer = uint(attributes.a_position.w); + return varyings; +} +)", + p_key.is_layered_rendering_enabled() ? " [[render_target_array_index]]" : "", ClearAttKey::DEPTH_INDEX); + + return new_func(NS::String::string(msl, NS::UTF8StringEncoding), MTLSTR("vertClear"), nullptr); +} + +NS::SharedPtr MDResourceFactory::new_clear_frag_func(ClearAttKey &p_key) { + NS::SharedPtr pool = NS::TransferPtr(NS::AutoreleasePool::alloc()->init()); + std::string msl; + msl.reserve(2048); + + msl += R"( +#include +using namespace metal; + +typedef struct { + float4 v_position [[position]]; +} VaryingsPos; + +typedef struct { + float4 colors[9]; +} ClearColorsIn; + +typedef struct { +)"; + + char line[128]; + for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { + if (p_key.is_enabled(caIdx)) { + const char *typeStr = get_format_type_string((MTL::PixelFormat)p_key.pixel_formats[caIdx]); + snprintf(line, sizeof(line), " %s4 color%u [[color(%u)]];\n", typeStr, caIdx, caIdx); + msl += line; + } + } + msl += R"(} ClearColorsOut; + +fragment ClearColorsOut fragClear(VaryingsPos varyings [[stage_in]], constant ClearColorsIn& ccIn [[buffer(0)]]) { + + ClearColorsOut ccOut; +)"; + for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { + if (p_key.is_enabled(caIdx)) { + const char *typeStr = get_format_type_string((MTL::PixelFormat)p_key.pixel_formats[caIdx]); + snprintf(line, sizeof(line), " ccOut.color%u = %s4(ccIn.colors[%u]);\n", caIdx, typeStr, caIdx); + msl += line; + } + } + msl += R"( return ccOut; +})"; + + return new_func(NS::String::string(msl.c_str(), NS::UTF8StringEncoding), MTLSTR("fragClear"), nullptr); +} + +const char *MDResourceFactory::get_format_type_string(MTL::PixelFormat p_fmt) const { + switch (pixel_formats.getFormatType(p_fmt)) { + case MTLFormatType::ColorInt8: + case MTLFormatType::ColorInt16: + return "short"; + case MTLFormatType::ColorUInt8: + case MTLFormatType::ColorUInt16: + return "ushort"; + case MTLFormatType::ColorInt32: + return "int"; + case MTLFormatType::ColorUInt32: + return "uint"; + case MTLFormatType::ColorHalf: + return "half"; + case MTLFormatType::ColorFloat: + case MTLFormatType::DepthStencil: + case MTLFormatType::Compressed: + return "float"; + case MTLFormatType::None: + default: + return "unexpected_MTLPixelFormatInvalid"; + } +} + +NS::SharedPtr MDResourceFactory::new_depth_stencil_state(bool p_use_depth, bool p_use_stencil) { + NS::SharedPtr dsDesc = NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init()); + dsDesc->setDepthCompareFunction(MTL::CompareFunctionAlways); + dsDesc->setDepthWriteEnabled(p_use_depth); + + if (p_use_stencil) { + NS::SharedPtr sDesc = NS::TransferPtr(MTL::StencilDescriptor::alloc()->init()); + sDesc->setStencilCompareFunction(MTL::CompareFunctionAlways); + sDesc->setStencilFailureOperation(MTL::StencilOperationReplace); + sDesc->setDepthFailureOperation(MTL::StencilOperationReplace); + sDesc->setDepthStencilPassOperation(MTL::StencilOperationReplace); + + dsDesc->setFrontFaceStencil(sDesc.get()); + dsDesc->setBackFaceStencil(sDesc.get()); + } else { + dsDesc->setFrontFaceStencil(nullptr); + dsDesc->setBackFaceStencil(nullptr); + } + + return NS::TransferPtr(device->newDepthStencilState(dsDesc.get())); +} + +NS::SharedPtr MDResourceFactory::new_clear_pipeline_state(ClearAttKey &p_key, NS::Error **p_error) { + NS::SharedPtr vtxFunc = new_clear_vert_func(p_key); + NS::SharedPtr fragFunc = new_clear_frag_func(p_key); + NS::SharedPtr plDesc = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init()); + plDesc->setLabel(MTLSTR("ClearRenderAttachments")); + plDesc->setVertexFunction(vtxFunc.get()); + plDesc->setFragmentFunction(fragFunc.get()); + plDesc->setRasterSampleCount(p_key.sample_count); + plDesc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassTriangle); + + for (uint32_t caIdx = 0; caIdx < ClearAttKey::COLOR_COUNT; caIdx++) { + MTL::RenderPipelineColorAttachmentDescriptor *colorDesc = plDesc->colorAttachments()->object(caIdx); + colorDesc->setPixelFormat((MTL::PixelFormat)p_key.pixel_formats[caIdx]); + colorDesc->setWriteMask(p_key.is_enabled(caIdx) ? MTL::ColorWriteMaskAll : MTL::ColorWriteMaskNone); + } + + MTL::PixelFormat mtlDepthFormat = (MTL::PixelFormat)p_key.depth_format(); + if (pixel_formats.isDepthFormat(mtlDepthFormat)) { + plDesc->setDepthAttachmentPixelFormat(mtlDepthFormat); + } + + MTL::PixelFormat mtlStencilFormat = (MTL::PixelFormat)p_key.stencil_format(); + if (pixel_formats.isStencilFormat(mtlStencilFormat)) { + plDesc->setStencilAttachmentPixelFormat(mtlStencilFormat); + } + + MTL::VertexDescriptor *vtxDesc = plDesc->vertexDescriptor(); + + // Vertex attribute descriptors. + NS::UInteger vtxBuffIdx = get_vertex_buffer_index(VERT_CONTENT_BUFFER_INDEX); + NS::UInteger vtxStride = 0; + + // Vertex location. + MTL::VertexAttributeDescriptor *vaDesc = vtxDesc->attributes()->object(0); + vaDesc->setFormat(MTL::VertexFormatFloat4); + vaDesc->setBufferIndex(vtxBuffIdx); + vaDesc->setOffset(vtxStride); + vtxStride += sizeof(simd::float4); + + // Vertex attribute buffer. + MTL::VertexBufferLayoutDescriptor *vbDesc = vtxDesc->layouts()->object(vtxBuffIdx); + vbDesc->setStepFunction(MTL::VertexStepFunctionPerVertex); + vbDesc->setStepRate(1); + vbDesc->setStride(vtxStride); + + NS::Error *err = nullptr; + NS::SharedPtr state = NS::TransferPtr(device->newRenderPipelineState(plDesc.get(), &err)); + if (p_error != nullptr) { + *p_error = err; + } + return state; +} + +NS::SharedPtr MDResourceFactory::new_empty_draw_pipeline_state(ClearAttKey &p_key, NS::Error **p_error) { + DEV_ASSERT(!p_key.is_layered_rendering_enabled()); + DEV_ASSERT(p_key.is_enabled(0)); + DEV_ASSERT(!p_key.is_depth_enabled()); + DEV_ASSERT(!p_key.is_stencil_enabled()); + + NS::SharedPtr pool = NS::TransferPtr(NS::AutoreleasePool::alloc()->init()); + static const char *msl = R"(#include +using namespace metal; + +struct FullscreenNoopOut { + float4 position [[position]]; +}; + +vertex FullscreenNoopOut fullscreenNoopVert(uint vid [[vertex_id]]) { + float2 positions[3] = { float2(-1.0, -1.0), float2(3.0, -1.0), float2(-1.0, 3.0) }; + float2 pos = positions[vid]; + + FullscreenNoopOut out; + out.position = float4(pos, 0.0, 1.0); + return out; +} + +fragment void fullscreenNoopFrag(float4 gl_FragCoord [[position]]) { +} +)"; + + NS::Error *err = nullptr; + NS::SharedPtr options = NS::TransferPtr(MTL::CompileOptions::alloc()->init()); + NS::SharedPtr mtlLib = NS::TransferPtr(device->newLibrary(NS::String::string(msl, NS::UTF8StringEncoding), options.get(), &err)); + if (err && p_error != nullptr) { + *p_error = err; + } + + if (mtlLib.get() == nullptr) { + return {}; + } + + NS::SharedPtr vtxFunc = NS::TransferPtr(mtlLib->newFunction(MTLSTR("fullscreenNoopVert"))); + NS::SharedPtr fragFunc = NS::TransferPtr(mtlLib->newFunction(MTLSTR("fullscreenNoopFrag"))); + + NS::SharedPtr plDesc = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init()); + plDesc->setLabel(MTLSTR("EmptyDrawFullscreenTriangle")); + plDesc->setVertexFunction(vtxFunc.get()); + plDesc->setFragmentFunction(fragFunc.get()); + plDesc->setRasterSampleCount(p_key.sample_count ? p_key.sample_count : 1); + plDesc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassTriangle); + + MTL::RenderPipelineColorAttachmentDescriptor *colorDesc = plDesc->colorAttachments()->object(0); + colorDesc->setPixelFormat((MTL::PixelFormat)p_key.pixel_formats[0]); + colorDesc->setWriteMask(MTL::ColorWriteMaskNone); + + err = nullptr; + NS::SharedPtr state = NS::TransferPtr(device->newRenderPipelineState(plDesc.get(), &err)); + if (p_error != nullptr && err != nullptr) { + *p_error = err; + } + return state; +} + +#pragma mark - Resource Cache + +MTL::RenderPipelineState *MDResourceCache::get_clear_render_pipeline_state(ClearAttKey &p_key, NS::Error **p_error) { + HashMap::ConstIterator it = clear_states.find(p_key); + if (it != clear_states.end()) { + return it->value.get(); + } + + NS::SharedPtr state = resource_factory->new_clear_pipeline_state(p_key, p_error); + MTL::RenderPipelineState *result = state.get(); + clear_states[p_key] = std::move(state); + return result; +} + +MTL::RenderPipelineState *MDResourceCache::get_empty_draw_pipeline_state(ClearAttKey &p_key, NS::Error **p_error) { + HashMap::ConstIterator it = empty_draw_states.find(p_key); + if (it != empty_draw_states.end()) { + return it->value.get(); + } + + NS::SharedPtr state = resource_factory->new_empty_draw_pipeline_state(p_key, p_error); + MTL::RenderPipelineState *result = state.get(); + empty_draw_states[p_key] = std::move(state); + return result; +} + +MTL::DepthStencilState *MDResourceCache::get_depth_stencil_state(bool p_use_depth, bool p_use_stencil) { + if (p_use_depth && p_use_stencil) { + if (!clear_depth_stencil_state.all) { + clear_depth_stencil_state.all = resource_factory->new_depth_stencil_state(true, true); + } + return clear_depth_stencil_state.all.get(); + } else if (p_use_depth) { + if (!clear_depth_stencil_state.depth_only) { + clear_depth_stencil_state.depth_only = resource_factory->new_depth_stencil_state(true, false); + } + return clear_depth_stencil_state.depth_only.get(); + } else if (p_use_stencil) { + if (!clear_depth_stencil_state.stencil_only) { + clear_depth_stencil_state.stencil_only = resource_factory->new_depth_stencil_state(false, true); + } + return clear_depth_stencil_state.stencil_only.get(); + } else { + if (!clear_depth_stencil_state.none) { + clear_depth_stencil_state.none = resource_factory->new_depth_stencil_state(false, false); + } + return clear_depth_stencil_state.none.get(); + } +} + +#pragma mark - Render Pass Types + +MTLFmtCaps MDSubpass::getRequiredFmtCapsForAttachmentAt(uint32_t p_index) const { + MTLFmtCaps caps = kMTLFmtCapsNone; + + for (RDD::AttachmentReference const &ar : input_references) { + if (ar.attachment == p_index) { + flags::set(caps, kMTLFmtCapsRead); + break; + } + } + + for (RDD::AttachmentReference const &ar : color_references) { + if (ar.attachment == p_index) { + flags::set(caps, kMTLFmtCapsColorAtt); + break; + } + } + + for (RDD::AttachmentReference const &ar : resolve_references) { + if (ar.attachment == p_index) { + flags::set(caps, kMTLFmtCapsResolve); + break; + } + } + + if (depth_stencil_reference.attachment == p_index) { + flags::set(caps, kMTLFmtCapsDSAtt); + } + + return caps; +} + +void MDAttachment::linkToSubpass(const MDRenderPass &p_pass) { + firstUseSubpassIndex = UINT32_MAX; + lastUseSubpassIndex = 0; + + for (MDSubpass const &subpass : p_pass.subpasses) { + MTLFmtCaps reqCaps = subpass.getRequiredFmtCapsForAttachmentAt(index); + if (reqCaps) { + firstUseSubpassIndex = MIN(subpass.subpass_index, firstUseSubpassIndex); + lastUseSubpassIndex = MAX(subpass.subpass_index, lastUseSubpassIndex); + } + } +} + +MTL::StoreAction MDAttachment::getMTLStoreAction(MDSubpass const &p_subpass, + bool p_is_rendering_entire_area, + bool p_has_resolve, + bool p_can_resolve, + bool p_is_stencil) const { + if (!p_is_rendering_entire_area || !isLastUseOf(p_subpass)) { + return p_has_resolve && p_can_resolve ? MTL::StoreActionStoreAndMultisampleResolve : MTL::StoreActionStore; + } + + switch (p_is_stencil ? stencilStoreAction : storeAction) { + case MTL::StoreActionStore: + return p_has_resolve && p_can_resolve ? MTL::StoreActionStoreAndMultisampleResolve : MTL::StoreActionStore; + case MTL::StoreActionDontCare: + return p_has_resolve ? (p_can_resolve ? MTL::StoreActionMultisampleResolve : MTL::StoreActionStore) : MTL::StoreActionDontCare; + + default: + return MTL::StoreActionStore; + } +} + +bool MDAttachment::shouldClear(const MDSubpass &p_subpass, bool p_is_stencil) const { + // If the subpass is not the first subpass to use this attachment, don't clear this attachment. + if (p_subpass.subpass_index != firstUseSubpassIndex) { + return false; + } + return (p_is_stencil ? stencilLoadAction : loadAction) == MTL::LoadActionClear; +} + +MDRenderPass::MDRenderPass(Vector &p_attachments, Vector &p_subpasses) : + attachments(p_attachments), subpasses(p_subpasses) { + for (MDAttachment &att : attachments) { + att.linkToSubpass(*this); + } +} + +#pragma mark - Command Buffer Base + +void MDCommandBufferBase::retain_resource(CFTypeRef p_resource) { + CFRetain(p_resource); + _retained_resources.push_back(p_resource); +} + +void MDCommandBufferBase::release_resources() { + for (CFTypeRef r : _retained_resources) { + CFRelease(r); + } + _retained_resources.clear(); +} + +void MDCommandBufferBase::render_set_viewport(VectorView p_viewports) { + RenderStateBase &state = get_render_state_base(); + state.viewports.resize(p_viewports.size()); + for (uint32_t i = 0; i < p_viewports.size(); i += 1) { + Rect2i const &vp = p_viewports[i]; + state.viewports[i] = { + .originX = static_cast(vp.position.x), + .originY = static_cast(vp.position.y), + .width = static_cast(vp.size.width), + .height = static_cast(vp.size.height), + .znear = 0.0, + .zfar = 1.0, + }; + } + state.dirty.set_flag(RenderStateBase::DIRTY_VIEWPORT); +} + +void MDCommandBufferBase::render_set_scissor(VectorView p_scissors) { + RenderStateBase &state = get_render_state_base(); + state.scissors.resize(p_scissors.size()); + for (uint32_t i = 0; i < p_scissors.size(); i += 1) { + Rect2i const &vp = p_scissors[i]; + state.scissors[i] = { + .x = static_cast(vp.position.x), + .y = static_cast(vp.position.y), + .width = static_cast(vp.size.width), + .height = static_cast(vp.size.height), + }; + } + state.dirty.set_flag(RenderStateBase::DIRTY_SCISSOR); +} + +void MDCommandBufferBase::render_set_blend_constants(const Color &p_constants) { + DEV_ASSERT(type == MDCommandBufferStateType::Render); + RenderStateBase &state = get_render_state_base(); + if (state.blend_constants != p_constants) { + state.blend_constants = p_constants; + state.dirty.set_flag(RenderStateBase::DIRTY_BLEND); + } +} + +void MDCommandBufferBase::_populate_vertices(simd::float4 *p_vertices, Size2i p_fb_size, VectorView p_rects) { + uint32_t idx = 0; + for (uint32_t i = 0; i < p_rects.size(); i++) { + Rect2i const &rect = p_rects[i]; + idx = _populate_vertices(p_vertices, idx, rect, p_fb_size); + } +} + +uint32_t MDCommandBufferBase::_populate_vertices(simd::float4 *p_vertices, uint32_t p_index, Rect2i const &p_rect, Size2i p_fb_size) { + // Determine the positions of the four edges of the + // clear rectangle as a fraction of the attachment size. + float leftPos = (float)(p_rect.position.x) / (float)p_fb_size.width; + float rightPos = (float)(p_rect.size.width) / (float)p_fb_size.width + leftPos; + float bottomPos = (float)(p_rect.position.y) / (float)p_fb_size.height; + float topPos = (float)(p_rect.size.height) / (float)p_fb_size.height + bottomPos; + + // Transform to clip-space coordinates, which are bounded by (-1.0 < p < 1.0) in clip-space. + leftPos = (leftPos * 2.0f) - 1.0f; + rightPos = (rightPos * 2.0f) - 1.0f; + bottomPos = (bottomPos * 2.0f) - 1.0f; + topPos = (topPos * 2.0f) - 1.0f; + + simd::float4 vtx; + + uint32_t idx = p_index; + uint32_t endLayer = get_current_view_count(); + + for (uint32_t layer = 0; layer < endLayer; layer++) { + vtx.z = 0.0; + vtx.w = (float)layer; + + // Top left vertex - First triangle. + vtx.y = topPos; + vtx.x = leftPos; + p_vertices[idx++] = vtx; + + // Bottom left vertex. + vtx.y = bottomPos; + vtx.x = leftPos; + p_vertices[idx++] = vtx; + + // Bottom right vertex. + vtx.y = bottomPos; + vtx.x = rightPos; + p_vertices[idx++] = vtx; + + // Bottom right vertex - Second triangle. + p_vertices[idx++] = vtx; + + // Top right vertex. + vtx.y = topPos; + vtx.x = rightPos; + p_vertices[idx++] = vtx; + + // Top left vertex. + vtx.y = topPos; + vtx.x = leftPos; + p_vertices[idx++] = vtx; + } + + return idx; +} + +void MDCommandBufferBase::_end_render_pass() { + MDFrameBuffer const &fb_info = *get_frame_buffer(); + MDSubpass const &subpass = get_current_subpass(); + + PixelFormats &pf = device_driver->get_pixel_formats(); + + for (uint32_t i = 0; i < subpass.resolve_references.size(); i++) { + uint32_t color_index = subpass.color_references[i].attachment; + uint32_t resolve_index = subpass.resolve_references[i].attachment; + DEV_ASSERT((color_index == RDD::AttachmentReference::UNUSED) == (resolve_index == RDD::AttachmentReference::UNUSED)); + if (color_index == RDD::AttachmentReference::UNUSED || !fb_info.has_texture(color_index)) { + continue; + } + + MTL::Texture *resolve_tex = fb_info.get_texture(resolve_index); + + CRASH_COND_MSG(!flags::all(pf.getCapabilities(resolve_tex->pixelFormat()), kMTLFmtCapsResolve), "not implemented: unresolvable texture types"); + // see: https://github.com/KhronosGroup/MoltenVK/blob/d20d13fe2735adb845636a81522df1b9d89c0fba/MoltenVK/MoltenVK/GPUObjects/MVKRenderPass.mm#L407 + } + + end_render_encoding(); +} + +void MDCommandBufferBase::_render_clear_render_area() { + MDRenderPass const &pass = *get_render_pass(); + MDSubpass const &subpass = get_current_subpass(); + LocalVector &clear_values = get_clear_values(); + + uint32_t ds_index = subpass.depth_stencil_reference.attachment; + bool clear_depth = (ds_index != RDD::AttachmentReference::UNUSED && pass.attachments[ds_index].shouldClear(subpass, false)); + bool clear_stencil = (ds_index != RDD::AttachmentReference::UNUSED && pass.attachments[ds_index].shouldClear(subpass, true)); + + uint32_t color_count = subpass.color_references.size(); + uint32_t clears_size = color_count + (clear_depth || clear_stencil ? 1 : 0); + if (clears_size == 0) { + return; + } + + RDD::AttachmentClear *clears = ALLOCA_ARRAY(RDD::AttachmentClear, clears_size); + uint32_t clears_count = 0; + + for (uint32_t i = 0; i < color_count; i++) { + uint32_t idx = subpass.color_references[i].attachment; + if (idx != RDD::AttachmentReference::UNUSED && pass.attachments[idx].shouldClear(subpass, false)) { + clears[clears_count++] = { .aspect = RDD::TEXTURE_ASPECT_COLOR_BIT, .color_attachment = idx, .value = clear_values[idx] }; + } + } + + if (clear_depth || clear_stencil) { + MDAttachment const &attachment = pass.attachments[ds_index]; + BitField bits = {}; + if (clear_depth && attachment.type & MDAttachmentType::Depth) { + bits.set_flag(RDD::TEXTURE_ASPECT_DEPTH_BIT); + } + if (clear_stencil && attachment.type & MDAttachmentType::Stencil) { + bits.set_flag(RDD::TEXTURE_ASPECT_STENCIL_BIT); + } + + clears[clears_count++] = { .aspect = bits, .color_attachment = ds_index, .value = clear_values[ds_index] }; + } + + if (clears_count == 0) { + return; + } + + render_clear_attachments(VectorView(clears, clears_count), { get_render_area() }); +} + +void MDCommandBufferBase::encode_push_constant_data(RDD::ShaderID p_shader, VectorView p_data) { + switch (type) { + case MDCommandBufferStateType::Render: + case MDCommandBufferStateType::Compute: { + MDShader *shader = (MDShader *)(p_shader.id); + if (shader->push_constants.binding == UINT32_MAX) { + return; + } + push_constant_binding = shader->push_constants.binding; + void const *ptr = p_data.ptr(); + push_constant_data_len = p_data.size() * sizeof(uint32_t); + DEV_ASSERT(push_constant_data_len <= sizeof(push_constant_data)); + memcpy(push_constant_data, ptr, push_constant_data_len); + if (push_constant_data_len > 0) { + mark_push_constants_dirty(); + } + } break; + case MDCommandBufferStateType::Blit: + case MDCommandBufferStateType::None: + return; + } +} + +#pragma mark - Metal Library + +static const char *SHADER_STAGE_NAMES[] = { + [RD::SHADER_STAGE_VERTEX] = "vert", + [RD::SHADER_STAGE_FRAGMENT] = "frag", + [RD::SHADER_STAGE_TESSELATION_CONTROL] = "tess_ctrl", + [RD::SHADER_STAGE_TESSELATION_EVALUATION] = "tess_eval", + [RD::SHADER_STAGE_COMPUTE] = "comp", +}; + +void ShaderCacheEntry::notify_free() const { + owner.shader_cache_free_entry(key); +} + +#pragma mark - MDLibrary + +MDLibrary::MDLibrary(ShaderCacheEntry *p_entry +#ifdef DEV_ENABLED + , + NS::String *p_source +#endif + ) : + _entry(p_entry) { +#ifdef DEV_ENABLED + _original_source = NS::RetainPtr(p_source); +#endif +} + +MDLibrary::~MDLibrary() { + _entry->notify_free(); +} + +void MDLibrary::set_label(NS::String *p_label) { +} + +#pragma mark - MDLazyLibrary + +/// Loads the MTLLibrary when the library is first accessed. +class MDLazyLibrary final : public MDLibrary { + NS::SharedPtr _library; + NS::Error *_error = nullptr; + std::shared_mutex _mu; + bool _loaded = false; + MTL::Device *_device = nullptr; + NS::SharedPtr _source; + NS::SharedPtr _options; + + void _load(); + +public: + MDLazyLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options); + + MTL::Library *get_library() override; + NS::Error *get_error() override; +}; + +MDLazyLibrary::MDLazyLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options) : + MDLibrary(p_entry +#ifdef DEV_ENABLED + , + p_source +#endif + ), + _device(p_device), + _source(NS::RetainPtr(p_source)), + _options(NS::RetainPtr(p_options)) { +} + +void MDLazyLibrary::_load() { + { + std::shared_lock lock(_mu); + if (_loaded) { + return; + } + } + + std::unique_lock lock(_mu); + if (_loaded) { + return; + } + + os_signpost_id_t compile_id = (os_signpost_id_t)(uintptr_t)this; + os_signpost_interval_begin(LOG_INTERVALS, compile_id, "shader_compile", + "shader_name=%{public}s stage=%{public}s hash=%X", + _entry->name.get_data(), SHADER_STAGE_NAMES[_entry->stage], _entry->key.short_sha()); + NS::Error *error = nullptr; + _library = NS::TransferPtr(_device->newLibrary(_source.get(), _options.get(), &error)); + os_signpost_interval_end(LOG_INTERVALS, compile_id, "shader_compile"); + _error = error; + _device = nullptr; + _source.reset(); + _options.reset(); + _loaded = true; +} + +MTL::Library *MDLazyLibrary::get_library() { + _load(); + return _library.get(); +} + +NS::Error *MDLazyLibrary::get_error() { + _load(); + return _error; +} + +#pragma mark - MDImmediateLibrary + +/// Loads the MTLLibrary immediately on initialization, using Metal's async compilation API. +class MDImmediateLibrary final : public MDLibrary { + NS::SharedPtr _library; + NS::Error *_error = nullptr; + std::mutex _cv_mutex; + std::condition_variable _cv; + std::atomic _complete{ false }; + bool _ready = false; + +public: + MDImmediateLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options); + + MTL::Library *get_library() override; + NS::Error *get_error() override; +}; + +MDImmediateLibrary::MDImmediateLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options) : + MDLibrary(p_entry +#ifdef DEV_ENABLED + , + p_source +#endif + ) { + os_signpost_id_t compile_id = (os_signpost_id_t)(uintptr_t)this; + os_signpost_interval_begin(LOG_INTERVALS, compile_id, "shader_compile", + "shader_name=%{public}s stage=%{public}s hash=%X", + p_entry->name.get_data(), SHADER_STAGE_NAMES[p_entry->stage], p_entry->key.short_sha()); + + // Use Metal's async compilation API with std::function callback. + p_device->newLibrary(p_source, p_options, [this, compile_id, p_entry](MTL::Library *library, NS::Error *error) { + os_signpost_interval_end(LOG_INTERVALS, compile_id, "shader_compile"); + if (library) { + _library = NS::RetainPtr(library); + } + _error = error; + if (error) { + ERR_PRINT(vformat(U"Error compiling shader %s: %s", p_entry->name.get_data(), error->localizedDescription()->utf8String())); + } + + { + std::lock_guard lock(_cv_mutex); + _ready = true; + } + _cv.notify_all(); + _complete = true; + }); +} + +MTL::Library *MDImmediateLibrary::get_library() { + if (!_complete) { + std::unique_lock lock(_cv_mutex); + _cv.wait(lock, [this] { return _ready; }); + } + return _library.get(); +} + +NS::Error *MDImmediateLibrary::get_error() { + if (!_complete) { + std::unique_lock lock(_cv_mutex); + _cv.wait(lock, [this] { return _ready; }); + } + return _error; +} + +#pragma mark - MDBinaryLibrary + +/// Loads the MTLLibrary from pre-compiled binary data. +class MDBinaryLibrary final : public MDLibrary { + NS::SharedPtr _library; + NS::Error *_error = nullptr; + +public: + MDBinaryLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, +#ifdef DEV_ENABLED + NS::String *p_source, +#endif + dispatch_data_t p_data); + + MTL::Library *get_library() override; + NS::Error *get_error() override; +}; + +MDBinaryLibrary::MDBinaryLibrary(ShaderCacheEntry *p_entry, + MTL::Device *p_device, +#ifdef DEV_ENABLED + NS::String *p_source, +#endif + dispatch_data_t p_data) : + MDLibrary(p_entry +#ifdef DEV_ENABLED + , + p_source +#endif + ) { + NS::Error *error = nullptr; + _library = NS::TransferPtr(p_device->newLibrary(p_data, &error)); + if (error != nullptr) { + _error = error; + ERR_PRINT(vformat("Unable to load shader library: %s", error->localizedDescription()->utf8String())); + } +} + +MTL::Library *MDBinaryLibrary::get_library() { + return _library.get(); +} + +NS::Error *MDBinaryLibrary::get_error() { + return _error; +} + +#pragma mark - MDLibrary Factory Methods + +std::shared_ptr MDLibrary::create(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options, + ShaderLoadStrategy p_strategy) { + std::shared_ptr lib; + switch (p_strategy) { + case ShaderLoadStrategy::IMMEDIATE: + [[fallthrough]]; + default: + lib = std::make_shared(p_entry, p_device, p_source, p_options); + break; + case ShaderLoadStrategy::LAZY: + lib = std::make_shared(p_entry, p_device, p_source, p_options); + break; + } + p_entry->library = lib; + return lib; +} + +std::shared_ptr MDLibrary::create(ShaderCacheEntry *p_entry, + MTL::Device *p_device, +#ifdef DEV_ENABLED + NS::String *p_source, +#endif + dispatch_data_t p_data) { + std::shared_ptr lib = std::make_shared(p_entry, p_device, +#ifdef DEV_ENABLED + p_source, +#endif + p_data); + p_entry->library = lib; + return lib; +} diff --git a/drivers/metal/metal_objects_shared.h b/drivers/metal/metal_objects_shared.h index ce7993a6b8..62f3159b87 100644 --- a/drivers/metal/metal_objects_shared.h +++ b/drivers/metal/metal_objects_shared.h @@ -30,28 +30,19 @@ #pragma once -#import "metal_device_properties.h" -#import "metal_utils.h" +#include "metal_device_properties.h" +#include "metal_utils.h" +#include "pixel_formats.h" +#include "sha256_digest.h" + +#include +#include +#include + +class RenderingDeviceDriverMetal; using RDC = RenderingDeviceCommons; -// These types can be used in Vector and other containers that use -// pointer operations not supported by ARC. -namespace MTL { -#define MTL_CLASS(name) \ - class name { \ - public: \ - name(id obj = nil) : m_obj(obj) {} \ - operator id() const { \ - return m_obj; \ - } \ - id m_obj; \ - }; - -MTL_CLASS(Texture) - -} //namespace MTL - enum ShaderStageUsage : uint32_t { None = 0, Vertex = RDD::SHADER_STAGE_VERTEX_BIT, @@ -81,11 +72,11 @@ struct ClearAttKey { uint16_t sample_count = 0; uint16_t pixel_formats[ATTACHMENT_COUNT] = { 0 }; - _FORCE_INLINE_ void set_color_format(uint32_t p_idx, MTLPixelFormat p_fmt) { pixel_formats[p_idx] = p_fmt; } - _FORCE_INLINE_ void set_depth_format(MTLPixelFormat p_fmt) { pixel_formats[DEPTH_INDEX] = p_fmt; } - _FORCE_INLINE_ void set_stencil_format(MTLPixelFormat p_fmt) { pixel_formats[STENCIL_INDEX] = p_fmt; } - _FORCE_INLINE_ MTLPixelFormat depth_format() const { return (MTLPixelFormat)pixel_formats[DEPTH_INDEX]; } - _FORCE_INLINE_ MTLPixelFormat stencil_format() const { return (MTLPixelFormat)pixel_formats[STENCIL_INDEX]; } + _FORCE_INLINE_ void set_color_format(uint32_t p_idx, MTL::PixelFormat p_fmt) { pixel_formats[p_idx] = p_fmt; } + _FORCE_INLINE_ void set_depth_format(MTL::PixelFormat p_fmt) { pixel_formats[DEPTH_INDEX] = p_fmt; } + _FORCE_INLINE_ void set_stencil_format(MTL::PixelFormat p_fmt) { pixel_formats[STENCIL_INDEX] = p_fmt; } + _FORCE_INLINE_ MTL::PixelFormat depth_format() const { return (MTL::PixelFormat)pixel_formats[DEPTH_INDEX]; } + _FORCE_INLINE_ MTL::PixelFormat stencil_format() const { return (MTL::PixelFormat)pixel_formats[STENCIL_INDEX]; } _FORCE_INLINE_ void enable_layered_rendering() { flags::set(flags, CLEAR_FLAGS_LAYERED); } _FORCE_INLINE_ bool is_enabled(uint32_t p_idx) const { return pixel_formats[p_idx] != 0; } @@ -105,6 +96,175 @@ struct ClearAttKey { } }; +#pragma mark - Ring Buffer + +/// A ring buffer backed by MTLBuffer instances for transient GPU allocations. +/// Allocations are 16-byte aligned with a minimum size of 16 bytes. +/// When the current buffer is exhausted, a new buffer is allocated. +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDRingBuffer { +public: + static constexpr uint32_t DEFAULT_BUFFER_SIZE = 512 * 1024; + static constexpr uint32_t MIN_BLOCK_SIZE = 16; + static constexpr uint32_t ALIGNMENT = 16; + + struct Allocation { + void *ptr = nullptr; + MTL::Buffer *buffer = nullptr; + uint64_t gpu_address = 0; + uint32_t offset = 0; + + _FORCE_INLINE_ bool is_valid() const { return ptr != nullptr; } + }; + +private: + MTL::Device *device = nullptr; + LocalVector buffers; + LocalVector heads; + uint32_t current_segment = 0; + uint32_t buffer_size = DEFAULT_BUFFER_SIZE; + bool changed = false; + + _FORCE_INLINE_ uint32_t alloc_segment() { + MTL::Buffer *buffer = device->newBuffer(buffer_size, MTL::ResourceStorageModeShared | MTL::ResourceHazardTrackingModeUntracked); + buffers.push_back(buffer); + heads.push_back(0); + changed = true; + + return buffers.size() - 1; + } + +public: + MDRingBuffer() = default; + + MDRingBuffer(MTL::Device *p_device, uint32_t p_buffer_size = DEFAULT_BUFFER_SIZE) : + device(p_device), buffer_size(p_buffer_size) {} + + ~MDRingBuffer() { + for (MTL::Buffer *buffer : buffers) { + buffer->release(); + } + } + + /// Allocates a block of memory from the ring buffer. + /// Returns an Allocation with the pointer, buffer, and offset. + _FORCE_INLINE_ Allocation allocate(uint32_t p_size) { + p_size = MAX(p_size, MIN_BLOCK_SIZE); + p_size = (p_size + ALIGNMENT - 1) & ~(ALIGNMENT - 1); + + if (buffers.is_empty()) { + alloc_segment(); + } + + uint32_t aligned_head = (heads[current_segment] + ALIGNMENT - 1) & ~(ALIGNMENT - 1); + + if (aligned_head + p_size > buffer_size) { + // Current segment exhausted, try to find one with space or allocate new. + bool found = false; + for (uint32_t i = 0; i < buffers.size(); i++) { + uint32_t ah = (heads[i] + ALIGNMENT - 1) & ~(ALIGNMENT - 1); + if (ah + p_size <= buffer_size) { + current_segment = i; + aligned_head = ah; + found = true; + break; + } + } + + if (!found) { + current_segment = alloc_segment(); + aligned_head = 0; + } + } + + MTL::Buffer *buffer = buffers[current_segment]; + Allocation alloc; + alloc.buffer = buffer; + alloc.offset = aligned_head; + alloc.ptr = static_cast(buffer->contents()) + aligned_head; + if (__builtin_available(macOS 13.0, iOS 16.0, tvOS 16.0, *)) { + alloc.gpu_address = buffer->gpuAddress() + aligned_head; + } + heads[current_segment] = aligned_head + p_size; + + return alloc; + } + + /// Resets all segments for reuse. Call at frame boundaries when GPU work is complete. + _FORCE_INLINE_ void reset() { + for (uint32_t &head : heads) { + head = 0; + } + current_segment = 0; + } + + /// Returns true if buffers were added or removed since last clear_changed(). + _FORCE_INLINE_ bool is_changed() const { return changed; } + + /// Clears the changed flag. + _FORCE_INLINE_ void clear_changed() { changed = false; } + + /// Returns a Span of all backing buffers. + _FORCE_INLINE_ Span get_buffers() const { + return Span(buffers.ptr(), buffers.size()); + } + + /// Returns the number of buffer segments currently allocated. + _FORCE_INLINE_ uint32_t get_segment_count() const { + return buffers.size(); + } +}; + +#pragma mark - Resource Factory + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDResourceFactory { +private: + MTL::Device *device; + PixelFormats &pixel_formats; + uint32_t max_buffer_count; + + NS::SharedPtr new_func(NS::String *p_source, NS::String *p_name, NS::Error **p_error); + NS::SharedPtr new_clear_vert_func(ClearAttKey &p_key); + NS::SharedPtr new_clear_frag_func(ClearAttKey &p_key); + const char *get_format_type_string(MTL::PixelFormat p_fmt) const; + + _FORCE_INLINE_ uint32_t get_vertex_buffer_index(uint32_t p_binding) { + return (max_buffer_count - 1) - p_binding; + } + +public: + NS::SharedPtr new_clear_pipeline_state(ClearAttKey &p_key, NS::Error **p_error); + NS::SharedPtr new_empty_draw_pipeline_state(ClearAttKey &p_key, NS::Error **p_error); + NS::SharedPtr new_depth_stencil_state(bool p_use_depth, bool p_use_stencil); + + MDResourceFactory(MTL::Device *p_device, PixelFormats &p_pixel_formats, uint32_t p_max_buffer_count) : + device(p_device), pixel_formats(p_pixel_formats), max_buffer_count(p_max_buffer_count) {} + ~MDResourceFactory() = default; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDResourceCache { +private: + typedef HashMap> HashMap; + std::unique_ptr resource_factory; + HashMap clear_states; + HashMap empty_draw_states; + + struct { + NS::SharedPtr all; + NS::SharedPtr depth_only; + NS::SharedPtr stencil_only; + NS::SharedPtr none; + } clear_depth_stencil_state; + +public: + MTL::RenderPipelineState *get_clear_render_pipeline_state(ClearAttKey &p_key, NS::Error **p_error); + MTL::RenderPipelineState *get_empty_draw_pipeline_state(ClearAttKey &p_key, NS::Error **p_error); + MTL::DepthStencilState *get_depth_stencil_state(bool p_use_depth, bool p_use_stencil); + + explicit MDResourceCache(MTL::Device *p_device, PixelFormats &p_pixel_formats, uint32_t p_max_buffer_count) : + resource_factory(new MDResourceFactory(p_device, p_pixel_formats, p_max_buffer_count)) {} + ~MDResourceCache() = default; +}; + /** * Returns an index that can be used to map a shader stage to an index in a fixed-size array that is used for * a single pipeline type. @@ -122,33 +282,33 @@ _FORCE_INLINE_ static uint32_t to_index(RDD::ShaderStage p_s) { } } -class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MDFrameBuffer { - Vector textures; +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDFrameBuffer { + Vector textures; public: Size2i size; - MDFrameBuffer(Vector p_textures, Size2i p_size) : + MDFrameBuffer(Vector p_textures, Size2i p_size) : textures(p_textures), size(p_size) {} MDFrameBuffer() {} /// Returns the texture at the given index. - _ALWAYS_INLINE_ MTL::Texture get_texture(uint32_t p_idx) const { + _ALWAYS_INLINE_ MTL::Texture *get_texture(uint32_t p_idx) const { return textures[p_idx]; } /// Returns true if the texture at the given index is not nil. _ALWAYS_INLINE_ bool has_texture(uint32_t p_idx) const { - return textures[p_idx] != nil; + return textures[p_idx] != nullptr; } /// Set the texture at the given index. - _ALWAYS_INLINE_ void set_texture(uint32_t p_idx, MTL::Texture p_texture) { + _ALWAYS_INLINE_ void set_texture(uint32_t p_idx, MTL::Texture *p_texture) { textures.write[p_idx] = p_texture; } /// Unset or nil the texture at the given index. _ALWAYS_INLINE_ void unset_texture(uint32_t p_idx) { - textures.write[p_idx] = nil; + textures.write[p_idx] = nullptr; } /// Resizes buffers to the specified size. @@ -159,38 +319,771 @@ public: virtual ~MDFrameBuffer() = default; }; -// These functions are used to convert between Objective-C objects and -// the RIDs used by Godot, respecting automatic reference counting. +template <> +struct HashMapComparatorDefault { + static bool compare(const RDD::ShaderID &p_lhs, const RDD::ShaderID &p_rhs) { + return p_lhs.id == p_rhs.id; + } +}; + +template <> +struct HashMapComparatorDefault { + static bool compare(const RDD::BufferID &p_lhs, const RDD::BufferID &p_rhs) { + return p_lhs.id == p_rhs.id; + } +}; + +template <> +struct HashMapComparatorDefault { + static bool compare(const RDD::TextureID &p_lhs, const RDD::TextureID &p_rhs) { + return p_lhs.id == p_rhs.id; + } +}; + +template <> +struct HashMapHasherDefaultImpl { + static _FORCE_INLINE_ uint32_t hash(const RDD::BufferID &p_value) { + return HashMapHasherDefaultImpl::hash(p_value.id); + } +}; + +template <> +struct HashMapHasherDefaultImpl { + static _FORCE_INLINE_ uint32_t hash(const RDD::TextureID &p_value) { + return HashMapHasherDefaultImpl::hash(p_value.id); + } +}; + namespace rid { -// Converts an Objective-C object to a pointer, and incrementing the -// reference count. -_FORCE_INLINE_ void *owned(id p_id) { - return (__bridge_retained void *)p_id; +template +_FORCE_INLINE_ T *get(RDD::ID p_id) { + return reinterpret_cast(p_id.id); } -#define MAKE_ID(FROM, TO) \ - _FORCE_INLINE_ TO make(FROM p_obj) { \ - return TO(owned(p_obj)); \ - } - -// These are shared for Metal and Metal 4 drivers - -MAKE_ID(id, RDD::TextureID) -MAKE_ID(id, RDD::BufferID) -MAKE_ID(id, RDD::SamplerID) -MAKE_ID(MTLVertexDescriptor *, RDD::VertexFormatID) - -#undef MAKE_ID - -// Converts a pointer to an Objective-C object without changing the reference count. -_FORCE_INLINE_ auto get(RDD::ID p_id) { - return (p_id.id) ? (__bridge ::id)(void *)p_id.id : nil; -} - -// Converts a pointer to an Objective-C object, and decrements the reference count. -_FORCE_INLINE_ auto release(RDD::ID p_id) { - return (__bridge_transfer ::id)(void *)p_id.id; +template +_FORCE_INLINE_ T *get(uint64_t p_id) { + return reinterpret_cast(p_id); } } // namespace rid + +#pragma mark - Render Pass Types + +class MDRenderPass; + +enum class MDAttachmentType : uint8_t { + None = 0, + Color = 1 << 0, + Depth = 1 << 1, + Stencil = 1 << 2, +}; + +_FORCE_INLINE_ MDAttachmentType &operator|=(MDAttachmentType &p_a, MDAttachmentType p_b) { + flags::set(p_a, p_b); + return p_a; +} + +_FORCE_INLINE_ bool operator&(MDAttachmentType p_a, MDAttachmentType p_b) { + return uint8_t(p_a) & uint8_t(p_b); +} + +struct MDSubpass { + uint32_t subpass_index = 0; + uint32_t view_count = 0; + LocalVector input_references; + LocalVector color_references; + RDD::AttachmentReference depth_stencil_reference; + LocalVector resolve_references; + + MTLFmtCaps getRequiredFmtCapsForAttachmentAt(uint32_t p_index) const; +}; + +struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDAttachment { +private: + uint32_t index = 0; + uint32_t firstUseSubpassIndex = 0; + uint32_t lastUseSubpassIndex = 0; + +public: + MTL::PixelFormat format = MTL::PixelFormatInvalid; + MDAttachmentType type = MDAttachmentType::None; + MTL::LoadAction loadAction = MTL::LoadActionDontCare; + MTL::StoreAction storeAction = MTL::StoreActionDontCare; + MTL::LoadAction stencilLoadAction = MTL::LoadActionDontCare; + MTL::StoreAction stencilStoreAction = MTL::StoreActionDontCare; + uint32_t samples = 1; + + /*! + * @brief Returns true if this attachment is first used in the given subpass. + * @param p_subpass + * @return + */ + _FORCE_INLINE_ bool isFirstUseOf(MDSubpass const &p_subpass) const { + return p_subpass.subpass_index == firstUseSubpassIndex; + } + + /*! + * @brief Returns true if this attachment is last used in the given subpass. + * @param p_subpass + * @return + */ + _FORCE_INLINE_ bool isLastUseOf(MDSubpass const &p_subpass) const { + return p_subpass.subpass_index == lastUseSubpassIndex; + } + + void linkToSubpass(MDRenderPass const &p_pass); + + MTL::StoreAction getMTLStoreAction(MDSubpass const &p_subpass, + bool p_is_rendering_entire_area, + bool p_has_resolve, + bool p_can_resolve, + bool p_is_stencil) const; + bool configureDescriptor(MTL::RenderPassAttachmentDescriptor *p_desc, + PixelFormats &p_pf, + MDSubpass const &p_subpass, + MTL::Texture *p_attachment, + bool p_is_rendering_entire_area, + bool p_has_resolve, + bool p_can_resolve, + bool p_is_stencil) const { + p_desc->setTexture(p_attachment); + + MTL::LoadAction load; + if (!p_is_rendering_entire_area || !isFirstUseOf(p_subpass)) { + load = MTL::LoadActionLoad; + } else { + load = p_is_stencil ? (MTL::LoadAction)stencilLoadAction : (MTL::LoadAction)loadAction; + } + + p_desc->setLoadAction(load); + + MTL::PixelFormat mtlFmt = p_attachment->pixelFormat(); + bool isDepthFormat = p_pf.isDepthFormat(mtlFmt); + bool isStencilFormat = p_pf.isStencilFormat(mtlFmt); + if (isStencilFormat && !p_is_stencil && !isDepthFormat) { + p_desc->setStoreAction(MTL::StoreActionDontCare); + } else { + p_desc->setStoreAction(getMTLStoreAction(p_subpass, p_is_rendering_entire_area, p_has_resolve, p_can_resolve, p_is_stencil)); + } + + return load == MTL::LoadActionClear; + } + + /** Returns whether this attachment should be cleared in the subpass. */ + bool shouldClear(MDSubpass const &p_subpass, bool p_is_stencil) const; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDRenderPass { +public: + Vector attachments; + Vector subpasses; + + uint32_t get_sample_count() const { + return attachments.is_empty() ? 1 : attachments[0].samples; + } + + MDRenderPass(Vector &p_attachments, Vector &p_subpasses); +}; + +#pragma mark - Command Buffer Helpers + +_FORCE_INLINE_ static MTL::Size MTLSizeFromVector3i(Vector3i p_size) { + return MTL::Size{ (NS::UInteger)p_size.x, (NS::UInteger)p_size.y, (NS::UInteger)p_size.z }; +} + +_FORCE_INLINE_ static MTL::Origin MTLOriginFromVector3i(Vector3i p_origin) { + return MTL::Origin{ (NS::UInteger)p_origin.x, (NS::UInteger)p_origin.y, (NS::UInteger)p_origin.z }; +} + +// Clamps the size so that the sum of the origin and size do not exceed the maximum size. +_FORCE_INLINE_ static MTL::Size clampMTLSize(MTL::Size p_size, MTL::Origin p_origin, MTL::Size p_max_size) { + MTL::Size clamped; + clamped.width = MIN(p_size.width, p_max_size.width - p_origin.x); + clamped.height = MIN(p_size.height, p_max_size.height - p_origin.y); + clamped.depth = MIN(p_size.depth, p_max_size.depth - p_origin.z); + return clamped; +} + +API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) +_FORCE_INLINE_ static bool isArrayTexture(MTL::TextureType p_type) { + return (p_type == MTL::TextureType3D || + p_type == MTL::TextureType2DArray || + p_type == MTL::TextureType2DMultisampleArray || + p_type == MTL::TextureType1DArray); +} + +_FORCE_INLINE_ static bool operator==(MTL::Size p_a, MTL::Size p_b) { + return p_a.width == p_b.width && p_a.height == p_b.height && p_a.depth == p_b.depth; +} + +#pragma mark - Pipeline Stage Conversion + +GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") + +_FORCE_INLINE_ static MTL::Stages convert_src_pipeline_stages_to_metal(BitField p_stages) { + p_stages.clear_flag(RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT); + + // BOTTOM_OF_PIPE or ALL_COMMANDS means "all prior work must complete". + if (p_stages & (RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT | RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT)) { + return MTL::StageAll; + } + + MTL::Stages mtlStages = 0; + + // Vertex stage mappings. + if (p_stages & (RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT | RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT | RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | RDD::PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | RDD::PIPELINE_STAGE_GEOMETRY_SHADER_BIT)) { + mtlStages |= MTL::StageVertex; + } + + // Fragment stage mappings. + // Includes resolve and clear_storage, which on Metal use the render pipeline. + if (p_stages & (RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | RDD::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | RDD::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT | RDD::PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT | RDD::PIPELINE_STAGE_RESOLVE_BIT | RDD::PIPELINE_STAGE_CLEAR_STORAGE_BIT)) { + mtlStages |= MTL::StageFragment; + } + + // Compute stage. + if (p_stages & RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT) { + mtlStages |= MTL::StageDispatch; + } + + // Blit stage (transfer operations). + if (p_stages & RDD::PIPELINE_STAGE_COPY_BIT) { + mtlStages |= MTL::StageBlit; + } + + // ALL_GRAPHICS_BIT special case. + if (p_stages & RDD::PIPELINE_STAGE_ALL_GRAPHICS_BIT) { + mtlStages |= (MTL::StageVertex | MTL::StageFragment); + } + + return mtlStages; +} + +_FORCE_INLINE_ static MTL::Stages convert_dst_pipeline_stages_to_metal(BitField p_stages) { + p_stages.clear_flag(RDD::PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT); + + // TOP_OF_PIPE or ALL_COMMANDS means "wait before any work starts". + if (p_stages & (RDD::PIPELINE_STAGE_ALL_COMMANDS_BIT | RDD::PIPELINE_STAGE_TOP_OF_PIPE_BIT)) { + return MTL::StageAll; + } + + MTL::Stages mtlStages = 0; + + // Vertex stage mappings. + if (p_stages & (RDD::PIPELINE_STAGE_DRAW_INDIRECT_BIT | RDD::PIPELINE_STAGE_VERTEX_INPUT_BIT | RDD::PIPELINE_STAGE_VERTEX_SHADER_BIT | RDD::PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT | RDD::PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT | RDD::PIPELINE_STAGE_GEOMETRY_SHADER_BIT)) { + mtlStages |= MTL::StageVertex; + } + + // Fragment stage mappings. + // Includes resolve and clear_storage, which on Metal use the render pipeline. + if (p_stages & (RDD::PIPELINE_STAGE_FRAGMENT_SHADER_BIT | RDD::PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | RDD::PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | RDD::PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | RDD::PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT | RDD::PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT | RDD::PIPELINE_STAGE_RESOLVE_BIT | RDD::PIPELINE_STAGE_CLEAR_STORAGE_BIT)) { + mtlStages |= MTL::StageFragment; + } + + // Compute stage. + if (p_stages & RDD::PIPELINE_STAGE_COMPUTE_SHADER_BIT) { + mtlStages |= MTL::StageDispatch; + } + + // Blit stage (transfer operations). + if (p_stages & RDD::PIPELINE_STAGE_COPY_BIT) { + mtlStages |= MTL::StageBlit; + } + + // ALL_GRAPHICS_BIT special case. + if (p_stages & RDD::PIPELINE_STAGE_ALL_GRAPHICS_BIT) { + mtlStages |= (MTL::StageVertex | MTL::StageFragment); + } + + return mtlStages; +} + +GODOT_CLANG_WARNING_POP + +#pragma mark - Command Buffer Base + +enum class MDCommandBufferStateType { + None, + Render, + Compute, + Blit, // Only used by Metal 3 +}; + +/// Base struct for render state shared between MTL3 and MTL4 implementations. +struct RenderStateBase { + LocalVector viewports; + LocalVector scissors; + std::optional blend_constants; + + // clang-format off + enum DirtyFlag : uint16_t { + DIRTY_NONE = 0, + DIRTY_PIPELINE = 1 << 0, + DIRTY_UNIFORMS = 1 << 1, + DIRTY_PUSH = 1 << 2, + DIRTY_DEPTH = 1 << 3, + DIRTY_VERTEX = 1 << 4, + DIRTY_VIEWPORT = 1 << 5, + DIRTY_SCISSOR = 1 << 6, + DIRTY_BLEND = 1 << 7, + DIRTY_RASTER = 1 << 8, + DIRTY_ALL = (1 << 9) - 1, + }; + // clang-format on + BitField dirty = DIRTY_NONE; +}; + +/// Abstract base class for Metal command buffers, shared between MTL3 and MTL4 implementations. +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDCommandBufferBase { + LocalVector _retained_resources; + +protected: + // From RenderingDevice + static constexpr uint32_t MAX_PUSH_CONSTANT_SIZE = 128; + + MDCommandBufferStateType type = MDCommandBufferStateType::None; + + uint8_t push_constant_data[MAX_PUSH_CONSTANT_SIZE]; + uint32_t push_constant_data_len = 0; + uint32_t push_constant_binding = UINT32_MAX; + + ::RenderingDeviceDriverMetal *device_driver = nullptr; + + void release_resources(); + + /// Called when push constants are modified to mark the appropriate dirty flags. + virtual void mark_push_constants_dirty() = 0; + + /// Returns a reference to the render state base for viewport/scissor/blend operations. + virtual RenderStateBase &get_render_state_base() = 0; + + /// Returns the view count for the current subpass. + virtual uint32_t get_current_view_count() const = 0; + + /// Accessors for render pass state. + virtual MDRenderPass *get_render_pass() const = 0; + virtual MDFrameBuffer *get_frame_buffer() const = 0; + virtual const MDSubpass &get_current_subpass() const = 0; + virtual LocalVector &get_clear_values() = 0; + virtual const Rect2i &get_render_area() const = 0; + virtual void end_render_encoding() = 0; + + void _populate_vertices(simd::float4 *p_vertices, Size2i p_fb_size, VectorView p_rects); + uint32_t _populate_vertices(simd::float4 *p_vertices, uint32_t p_index, Rect2i const &p_rect, Size2i p_fb_size); + void _end_render_pass(); + void _render_clear_render_area(); + +public: + virtual ~MDCommandBufferBase() { release_resources(); } + + virtual void begin() = 0; + virtual void commit() = 0; + virtual void end() = 0; + + virtual void bind_pipeline(RDD::PipelineID p_pipeline) = 0; + void encode_push_constant_data(RDD::ShaderID p_shader, VectorView p_data); + + void retain_resource(CFTypeRef p_resource); + +#pragma mark - Render Commands + + virtual void render_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) = 0; + virtual void render_clear_attachments(VectorView p_attachment_clears, VectorView p_rects) = 0; + void render_set_viewport(VectorView p_viewports); + void render_set_scissor(VectorView p_scissors); + void render_set_blend_constants(const Color &p_constants); + virtual void render_begin_pass(RDD::RenderPassID p_render_pass, + RDD::FramebufferID p_frameBuffer, + RDD::CommandBufferType p_cmd_buffer_type, + const Rect2i &p_rect, + VectorView p_clear_values) = 0; + virtual void render_next_subpass() = 0; + virtual void render_draw(uint32_t p_vertex_count, + uint32_t p_instance_count, + uint32_t p_base_vertex, + uint32_t p_first_instance) = 0; + virtual void render_bind_vertex_buffers(uint32_t p_binding_count, const RDD::BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets) = 0; + virtual void render_bind_index_buffer(RDD::BufferID p_buffer, RDD::IndexBufferFormat p_format, uint64_t p_offset) = 0; + + virtual void render_draw_indexed(uint32_t p_index_count, + uint32_t p_instance_count, + uint32_t p_first_index, + int32_t p_vertex_offset, + uint32_t p_first_instance) = 0; + + virtual void render_draw_indexed_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) = 0; + virtual void render_draw_indexed_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) = 0; + virtual void render_draw_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) = 0; + virtual void render_draw_indirect_count(RDD::BufferID p_indirect_buffer, uint64_t p_offset, RDD::BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) = 0; + + virtual void render_end_pass() = 0; + +#pragma mark - Compute Commands + + virtual void compute_bind_uniform_sets(VectorView p_uniform_sets, RDD::ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) = 0; + virtual void compute_dispatch(uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) = 0; + virtual void compute_dispatch_indirect(RDD::BufferID p_indirect_buffer, uint64_t p_offset) = 0; + +#pragma mark - Transfer + + virtual void resolve_texture(RDD::TextureID p_src_texture, RDD::TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, RDD::TextureID p_dst_texture, RDD::TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap) = 0; + virtual void clear_color_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, const Color &p_color, const RDD::TextureSubresourceRange &p_subresources) = 0; + virtual void clear_depth_stencil_texture(RDD::TextureID p_texture, RDD::TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const RDD::TextureSubresourceRange &p_subresources) = 0; + virtual void clear_buffer(RDD::BufferID p_buffer, uint64_t p_offset, uint64_t p_size) = 0; + virtual void copy_buffer(RDD::BufferID p_src_buffer, RDD::BufferID p_dst_buffer, VectorView p_regions) = 0; + virtual void copy_texture(RDD::TextureID p_src_texture, RDD::TextureID p_dst_texture, VectorView p_regions) = 0; + virtual void copy_buffer_to_texture(RDD::BufferID p_src_buffer, RDD::TextureID p_dst_texture, VectorView p_regions) = 0; + virtual void copy_texture_to_buffer(RDD::TextureID p_src_texture, RDD::BufferID p_dst_buffer, VectorView p_regions) = 0; + +#pragma mark - Synchronization + + virtual void pipeline_barrier(BitField p_src_stages, + BitField p_dst_stages, + VectorView p_memory_barriers, + VectorView p_buffer_barriers, + VectorView p_texture_barriers, + VectorView p_acceleration_structure_barriers) = 0; + +#pragma mark - Debugging + + virtual void begin_label(const char *p_label_name, const Color &p_color) = 0; + virtual void end_label() = 0; +}; + +#pragma mark - Uniform Types + +struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) UniformInfo { + uint32_t binding; + BitField active_stages; + MTL::DataType dataType = MTL::DataTypeNone; + MTL::BindingAccess access = MTL::BindingAccessReadOnly; + MTL::ResourceUsage usage = 0; + MTL::TextureType textureType = MTL::TextureType2D; + uint32_t imageFormat = 0; + uint32_t arrayLength = 0; + bool isMultisampled = 0; + + struct Indexes { + uint32_t buffer = UINT32_MAX; + uint32_t texture = UINT32_MAX; + uint32_t sampler = UINT32_MAX; + }; + Indexes slot; + Indexes arg_buffer; + + enum class IndexType { + SLOT, + ARG, + }; + + _FORCE_INLINE_ Indexes &get_indexes(IndexType p_type) { + switch (p_type) { + case IndexType::SLOT: + return slot; + case IndexType::ARG: + return arg_buffer; + } + } +}; + +struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) UniformSet { + LocalVector uniforms; + LocalVector dynamic_uniforms; + uint32_t buffer_size = 0; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) DynamicOffsetLayout { + struct Data { + uint8_t offset : 4; + uint8_t count : 4; + }; + + union { + Data data[MAX_DYNAMIC_BUFFERS]; + uint64_t _val = 0; + }; + +public: + _FORCE_INLINE_ bool is_empty() const { return _val == 0; } + + _FORCE_INLINE_ uint32_t get_count(uint32_t p_set_index) const { + return data[p_set_index].count; + } + + _FORCE_INLINE_ uint32_t get_offset(uint32_t p_set_index) const { + return data[p_set_index].offset; + } + + _FORCE_INLINE_ void set_offset_count(uint32_t p_set_index, uint8_t p_offset, uint8_t p_count) { + data[p_set_index].offset = p_offset; + data[p_set_index].count = p_count; + } + + _FORCE_INLINE_ uint32_t get_offset_index_shift(uint32_t p_set_index, uint32_t p_dynamic_index = 0) const { + return (data[p_set_index].offset + p_dynamic_index) * 4u; + } +}; + +#pragma mark - Shader Types + +class MDLibrary; // Forward declaration for C++ code +struct ShaderCacheEntry; // Forward declaration for C++ code + +enum class ShaderLoadStrategy { + IMMEDIATE, + LAZY, + + /// The default strategy is to load the shader immediately. + DEFAULT = IMMEDIATE, +}; + +/// A Metal shader library. +class MDLibrary : public std::enable_shared_from_this { +protected: + ShaderCacheEntry *_entry = nullptr; +#ifdef DEV_ENABLED + NS::SharedPtr _original_source = nullptr; +#endif + + MDLibrary(ShaderCacheEntry *p_entry +#ifdef DEV_ENABLED + , + NS::String *p_source +#endif + ); + +public: + virtual ~MDLibrary(); + + virtual MTL::Library *get_library() = 0; + virtual NS::Error *get_error() = 0; + virtual void set_label(NS::String *p_label); +#ifdef DEV_ENABLED + NS::String *get_original_source() const { return _original_source.get(); } +#endif + + static std::shared_ptr create(ShaderCacheEntry *p_entry, + MTL::Device *p_device, + NS::String *p_source, + MTL::CompileOptions *p_options, + ShaderLoadStrategy p_strategy); + + static std::shared_ptr create(ShaderCacheEntry *p_entry, + MTL::Device *p_device, +#ifdef DEV_ENABLED + NS::String *p_source, +#endif + dispatch_data_t p_data); +}; + +/// A cache entry for a Metal shader library. +struct ShaderCacheEntry { + RenderingDeviceDriverMetal &owner; + /// A hash of the Metal shader source code. + SHA256Digest key; + CharString name; + RD::ShaderStage stage = RD::SHADER_STAGE_VERTEX; + /// Weak reference to the library; allows cache lookup without preventing cleanup. + std::weak_ptr library; + + /// Notify the cache that this entry is no longer needed. + void notify_free() const; + + ShaderCacheEntry(RenderingDeviceDriverMetal &p_owner, SHA256Digest p_key) : + owner(p_owner), key(p_key) { + } + ~ShaderCacheEntry() = default; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDShader { +public: + CharString name; + Vector sets; + struct { + BitField stages = {}; + uint32_t binding = UINT32_MAX; + uint32_t size = 0; + } push_constants; + DynamicOffsetLayout dynamic_offset_layout; + bool uses_argument_buffers = true; + + MDShader(CharString p_name, Vector p_sets, bool p_uses_argument_buffers) : + name(p_name), sets(p_sets), uses_argument_buffers(p_uses_argument_buffers) {} + virtual ~MDShader() = default; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDComputeShader final : public MDShader { +public: + MTL::Size local = {}; + + std::shared_ptr kernel; + + MDComputeShader(CharString p_name, Vector p_sets, bool p_uses_argument_buffers, std::shared_ptr p_kernel); +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDRenderShader final : public MDShader { +public: + bool needs_view_mask_buffer = false; + + std::shared_ptr vert; + std::shared_ptr frag; + + MDRenderShader(CharString p_name, + Vector p_sets, + bool p_needs_view_mask_buffer, + bool p_uses_argument_buffers, + std::shared_ptr p_vert, std::shared_ptr p_frag); +}; + +#pragma mark - Uniform Set + +enum StageResourceUsage : uint32_t { + ResourceUnused = 0, + VertexRead = (MTL::ResourceUsageRead << RDD::SHADER_STAGE_VERTEX * 2), + VertexWrite = (MTL::ResourceUsageWrite << RDD::SHADER_STAGE_VERTEX * 2), + FragmentRead = (MTL::ResourceUsageRead << RDD::SHADER_STAGE_FRAGMENT * 2), + FragmentWrite = (MTL::ResourceUsageWrite << RDD::SHADER_STAGE_FRAGMENT * 2), + TesselationControlRead = (MTL::ResourceUsageRead << RDD::SHADER_STAGE_TESSELATION_CONTROL * 2), + TesselationControlWrite = (MTL::ResourceUsageWrite << RDD::SHADER_STAGE_TESSELATION_CONTROL * 2), + TesselationEvaluationRead = (MTL::ResourceUsageRead << RDD::SHADER_STAGE_TESSELATION_EVALUATION * 2), + TesselationEvaluationWrite = (MTL::ResourceUsageWrite << RDD::SHADER_STAGE_TESSELATION_EVALUATION * 2), + ComputeRead = (MTL::ResourceUsageRead << RDD::SHADER_STAGE_COMPUTE * 2), + ComputeWrite = (MTL::ResourceUsageWrite << RDD::SHADER_STAGE_COMPUTE * 2), +}; + +typedef LocalVector ResourceVector; +typedef HashMap ResourceUsageMap; + +_FORCE_INLINE_ StageResourceUsage &operator|=(StageResourceUsage &p_a, uint32_t p_b) { + p_a = StageResourceUsage(uint32_t(p_a) | p_b); + return p_a; +} + +_FORCE_INLINE_ StageResourceUsage stage_resource_usage(RDC::ShaderStage p_stage, MTL::ResourceUsage p_usage) { + return StageResourceUsage(p_usage << (p_stage * 2)); +} + +_FORCE_INLINE_ MTL::ResourceUsage resource_usage_for_stage(StageResourceUsage p_usage, RDC::ShaderStage p_stage) { + return MTL::ResourceUsage((p_usage >> (p_stage * 2)) & 0b11); +} + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDUniformSet { +public: + NS::SharedPtr arg_buffer; + Vector arg_buffer_data; // Stored for dynamic uniform sets. + ResourceUsageMap usage_to_resources; // Used by Metal 3 for resource tracking. + Vector uniforms; +}; + +#pragma mark - Pipeline Types + +enum class MDPipelineType { + None, + Render, + Compute, +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDPipeline { +public: + MDPipelineType type; + + explicit MDPipeline(MDPipelineType p_type) : + type(p_type) {} + virtual ~MDPipeline() = default; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDRenderPipeline final : public MDPipeline { +public: + NS::SharedPtr state; + NS::SharedPtr depth_stencil; + uint32_t push_constant_size = 0; + uint32_t push_constant_stages_mask = 0; + SampleCount sample_count = SampleCount1; + + struct { + MTL::CullMode cull_mode = MTL::CullModeNone; + MTL::TriangleFillMode fill_mode = MTL::TriangleFillModeFill; + MTL::DepthClipMode clip_mode = MTL::DepthClipModeClip; + MTL::Winding winding = MTL::WindingClockwise; + MTL::PrimitiveType render_primitive = MTL::PrimitiveTypePoint; + + struct { + bool enabled = false; + } depth_test; + + struct { + bool enabled = false; + float depth_bias = 0.0; + float slope_scale = 0.0; + float clamp = 0.0; + + template + _FORCE_INLINE_ void apply(T *p_enc) const { + if (!enabled) { + return; + } + p_enc->setDepthBias(depth_bias, slope_scale, clamp); + } + } depth_bias; + + struct { + bool enabled = false; + uint32_t front_reference = 0; + uint32_t back_reference = 0; + + template + _FORCE_INLINE_ void apply(T *p_enc) const { + if (!enabled) { + return; + } + p_enc->setStencilReferenceValues(front_reference, back_reference); + } + } stencil; + + struct { + bool enabled = false; + float r = 0.0; + float g = 0.0; + float b = 0.0; + float a = 0.0; + + template + _FORCE_INLINE_ void apply(T *p_enc) const { + p_enc->setBlendColor(r, g, b, a); + } + } blend; + + template + _FORCE_INLINE_ void apply(T *p_enc) const { + p_enc->setCullMode(cull_mode); + p_enc->setTriangleFillMode(fill_mode); + p_enc->setDepthClipMode(clip_mode); + p_enc->setFrontFacingWinding(winding); + depth_bias.apply(p_enc); + stencil.apply(p_enc); + blend.apply(p_enc); + } + + } raster_state; + + MDRenderShader *shader = nullptr; + + MDRenderPipeline() : + MDPipeline(MDPipelineType::Render) {} + ~MDRenderPipeline() final = default; +}; + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0), visionos(2.0)) MDComputePipeline final : public MDPipeline { +public: + NS::SharedPtr state; + struct { + MTL::Size local = {}; + } compute_state; + + MDComputeShader *shader = nullptr; + + explicit MDComputePipeline(NS::SharedPtr p_state) : + MDPipeline(MDPipelineType::Compute), state(std::move(p_state)) {} + ~MDComputePipeline() final = default; +}; diff --git a/drivers/metal/metal_utils.h b/drivers/metal/metal_utils.h index 54c3509984..33a31aec4e 100644 --- a/drivers/metal/metal_utils.h +++ b/drivers/metal/metal_utils.h @@ -30,9 +30,9 @@ #pragma once -#import +#include -#import +#include /// Godot limits the number of dynamic buffers to 8. /// @@ -93,19 +93,32 @@ static constexpr uint64_t round_up_to_alignment(uint64_t p_value, uint64_t p_ali return aligned_value; } +template class Defer { public: - Defer(std::function func) : - func_(func) {} + explicit Defer(F &&f) : + func_(std::forward(f)) {} ~Defer() { func_(); } + // Non-copyable (correct RAII semantics) + Defer(const Defer &) = delete; + Defer &operator=(const Defer &) = delete; + + // Movable + Defer(Defer &&) = default; + Defer &operator=(Defer &&) = default; + private: - std::function func_; + F func_; }; +// C++17 class template argument deduction. +template +Defer(F &&) -> Defer>; + #define CONCAT_INTERNAL(x, y) x##y #define CONCAT(x, y) CONCAT_INTERNAL(x, y) -#define DEFER const Defer &CONCAT(defer__, __LINE__) = Defer +#define DEFER const auto &CONCAT(defer__, __LINE__) = Defer extern os_log_t LOG_DRIVER; // Used for dynamic tracing. diff --git a/drivers/metal/pixel_formats.mm b/drivers/metal/pixel_formats.cpp similarity index 89% rename from drivers/metal/pixel_formats.mm rename to drivers/metal/pixel_formats.cpp index 386f109040..ae1f0cf97c 100644 --- a/drivers/metal/pixel_formats.mm +++ b/drivers/metal/pixel_formats.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* pixel_formats.mm */ +/* pixel_formats.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -48,53 +48,53 @@ /* permissions and limitations under the License. */ /**************************************************************************/ -#import "pixel_formats.h" +#include "pixel_formats.h" -#import "metal_utils.h" +#include "metal_utils.h" #if TARGET_OS_IPHONE || TARGET_OS_TV #if !(__IPHONE_OS_VERSION_MAX_ALLOWED >= 160400) // iOS/tvOS 16.4 -#define MTLPixelFormatBC1_RGBA MTLPixelFormatInvalid -#define MTLPixelFormatBC1_RGBA_sRGB MTLPixelFormatInvalid -#define MTLPixelFormatBC2_RGBA MTLPixelFormatInvalid -#define MTLPixelFormatBC2_RGBA_sRGB MTLPixelFormatInvalid -#define MTLPixelFormatBC3_RGBA MTLPixelFormatInvalid -#define MTLPixelFormatBC3_RGBA_sRGB MTLPixelFormatInvalid -#define MTLPixelFormatBC4_RUnorm MTLPixelFormatInvalid -#define MTLPixelFormatBC4_RSnorm MTLPixelFormatInvalid -#define MTLPixelFormatBC5_RGUnorm MTLPixelFormatInvalid -#define MTLPixelFormatBC5_RGSnorm MTLPixelFormatInvalid -#define MTLPixelFormatBC6H_RGBUfloat MTLPixelFormatInvalid -#define MTLPixelFormatBC6H_RGBFloat MTLPixelFormatInvalid -#define MTLPixelFormatBC7_RGBAUnorm MTLPixelFormatInvalid -#define MTLPixelFormatBC7_RGBAUnorm_sRGB MTLPixelFormatInvalid +#define PixelFormatBC1_RGBA PixelFormatInvalid +#define PixelFormatBC1_RGBA_sRGB PixelFormatInvalid +#define PixelFormatBC2_RGBA PixelFormatInvalid +#define PixelFormatBC2_RGBA_sRGB PixelFormatInvalid +#define PixelFormatBC3_RGBA PixelFormatInvalid +#define PixelFormatBC3_RGBA_sRGB PixelFormatInvalid +#define PixelFormatBC4_RUnorm PixelFormatInvalid +#define PixelFormatBC4_RSnorm PixelFormatInvalid +#define PixelFormatBC5_RGUnorm PixelFormatInvalid +#define PixelFormatBC5_RGSnorm PixelFormatInvalid +#define PixelFormatBC6H_RGBUfloat PixelFormatInvalid +#define PixelFormatBC6H_RGBFloat PixelFormatInvalid +#define PixelFormatBC7_RGBAUnorm PixelFormatInvalid +#define PixelFormatBC7_RGBAUnorm_sRGB PixelFormatInvalid #endif -#define MTLPixelFormatDepth16Unorm_Stencil8 MTLPixelFormatDepth32Float_Stencil8 -#define MTLPixelFormatDepth24Unorm_Stencil8 MTLPixelFormatInvalid -#define MTLPixelFormatX24_Stencil8 MTLPixelFormatInvalid +#define PixelFormatDepth16Unorm_Stencil8 PixelFormatDepth32Float_Stencil8 +#define PixelFormatDepth24Unorm_Stencil8 PixelFormatInvalid +#define PixelFormatX24_Stencil8 PixelFormatInvalid #endif #if TARGET_OS_TV -#define MTLPixelFormatASTC_4x4_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_5x4_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_5x5_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_6x5_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_6x6_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_8x5_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_8x6_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_8x8_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_10x5_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_10x6_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_10x8_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_10x10_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_12x10_HDR MTLPixelFormatInvalid -#define MTLPixelFormatASTC_12x12_HDR MTLPixelFormatInvalid +#define PixelFormatASTC_4x4_HDR PixelFormatInvalid +#define PixelFormatASTC_5x4_HDR PixelFormatInvalid +#define PixelFormatASTC_5x5_HDR PixelFormatInvalid +#define PixelFormatASTC_6x5_HDR PixelFormatInvalid +#define PixelFormatASTC_6x6_HDR PixelFormatInvalid +#define PixelFormatASTC_8x5_HDR PixelFormatInvalid +#define PixelFormatASTC_8x6_HDR PixelFormatInvalid +#define PixelFormatASTC_8x8_HDR PixelFormatInvalid +#define PixelFormatASTC_10x5_HDR PixelFormatInvalid +#define PixelFormatASTC_10x6_HDR PixelFormatInvalid +#define PixelFormatASTC_10x8_HDR PixelFormatInvalid +#define PixelFormatASTC_10x10_HDR PixelFormatInvalid +#define PixelFormatASTC_12x10_HDR PixelFormatInvalid +#define PixelFormatASTC_12x12_HDR PixelFormatInvalid #endif #if !((__MAC_OS_X_VERSION_MAX_ALLOWED >= 140000) || (__IPHONE_OS_VERSION_MAX_ALLOWED >= 170000)) // Xcode 15 -#define MTLVertexFormatFloatRG11B10 MTLVertexFormatInvalid -#define MTLVertexFormatFloatRGB9E5 MTLVertexFormatInvalid +#define VertexFormatFloatRG11B10 VertexFormatInvalid +#define VertexFormatFloatRGB9E5 VertexFormatInvalid #endif template @@ -113,21 +113,21 @@ bool PixelFormats::isSupportedOrSubstitutable(DataFormat p_format) { return getDataFormatDesc(p_format).isSupportedOrSubstitutable(); } -bool PixelFormats::isPVRTCFormat(MTLPixelFormat p_format) { +bool PixelFormats::isPVRTCFormat(MTL::PixelFormat p_format) { #if defined(VISIONOS_ENABLED) return false; #else // Deprecated in SDK 26.0 GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations") switch (p_format) { - case MTLPixelFormatPVRTC_RGBA_2BPP: - case MTLPixelFormatPVRTC_RGBA_2BPP_sRGB: - case MTLPixelFormatPVRTC_RGBA_4BPP: - case MTLPixelFormatPVRTC_RGBA_4BPP_sRGB: - case MTLPixelFormatPVRTC_RGB_2BPP: - case MTLPixelFormatPVRTC_RGB_2BPP_sRGB: - case MTLPixelFormatPVRTC_RGB_4BPP: - case MTLPixelFormatPVRTC_RGB_4BPP_sRGB: + case MTL::PixelFormatPVRTC_RGBA_2BPP: + case MTL::PixelFormatPVRTC_RGBA_2BPP_sRGB: + case MTL::PixelFormatPVRTC_RGBA_4BPP: + case MTL::PixelFormatPVRTC_RGBA_4BPP_sRGB: + case MTL::PixelFormatPVRTC_RGB_2BPP: + case MTL::PixelFormatPVRTC_RGB_2BPP_sRGB: + case MTL::PixelFormatPVRTC_RGB_4BPP: + case MTL::PixelFormatPVRTC_RGB_4BPP_sRGB: return true; default: return false; @@ -140,24 +140,24 @@ MTLFormatType PixelFormats::getFormatType(DataFormat p_format) { return getDataFormatDesc(p_format).formatType; } -MTLFormatType PixelFormats::getFormatType(MTLPixelFormat p_format) { +MTLFormatType PixelFormats::getFormatType(MTL::PixelFormat p_format) { return getDataFormatDesc(p_format).formatType; } -MTLPixelFormat PixelFormats::getMTLPixelFormat(DataFormat p_format) { +MTL::PixelFormat PixelFormats::getMTLPixelFormat(DataFormat p_format) { DataFormatDesc &dfDesc = getDataFormatDesc(p_format); - MTLPixelFormat mtlPixFmt = dfDesc.mtlPixelFormat; + MTL::PixelFormat mtlPixFmt = dfDesc.mtlPixelFormat; - // If the MTLPixelFormat is not supported but DataFormat is valid, + // If the MTL::PixelFormat is not supported but DataFormat is valid, // attempt to substitute a different format. - if (mtlPixFmt == MTLPixelFormatInvalid && p_format != RD::DATA_FORMAT_MAX && dfDesc.chromaSubsamplingPlaneCount <= 1) { + if (mtlPixFmt == MTL::PixelFormatInvalid && p_format != RD::DATA_FORMAT_MAX && dfDesc.chromaSubsamplingPlaneCount <= 1) { mtlPixFmt = dfDesc.mtlPixelFormatSubstitute; } return mtlPixFmt; } -RD::DataFormat PixelFormats::getDataFormat(MTLPixelFormat p_format) { +RD::DataFormat PixelFormats::getDataFormat(MTL::PixelFormat p_format) { return getMTLPixelFormatDesc(p_format).dataFormat; } @@ -165,7 +165,7 @@ uint32_t PixelFormats::getBytesPerBlock(DataFormat p_format) { return getDataFormatDesc(p_format).bytesPerBlock; } -uint32_t PixelFormats::getBytesPerBlock(MTLPixelFormat p_format) { +uint32_t PixelFormats::getBytesPerBlock(MTL::PixelFormat p_format) { return getDataFormatDesc(p_format).bytesPerBlock; } @@ -181,7 +181,7 @@ float PixelFormats::getBytesPerTexel(DataFormat p_format) { return getDataFormatDesc(p_format).bytesPerTexel(); } -float PixelFormats::getBytesPerTexel(MTLPixelFormat p_format) { +float PixelFormats::getBytesPerTexel(MTL::PixelFormat p_format) { return getDataFormatDesc(p_format).bytesPerTexel(); } @@ -190,7 +190,7 @@ size_t PixelFormats::getBytesPerRow(DataFormat p_format, uint32_t p_texels_per_r return Math::division_round_up(p_texels_per_row, dfDesc.blockTexelSize.width) * dfDesc.bytesPerBlock; } -size_t PixelFormats::getBytesPerRow(MTLPixelFormat p_format, uint32_t p_texels_per_row) { +size_t PixelFormats::getBytesPerRow(MTL::PixelFormat p_format, uint32_t p_texels_per_row) { DataFormatDesc &dfDesc = getDataFormatDesc(p_format); return Math::division_round_up(p_texels_per_row, dfDesc.blockTexelSize.width) * dfDesc.bytesPerBlock; } @@ -199,7 +199,7 @@ size_t PixelFormats::getBytesPerLayer(DataFormat p_format, size_t p_bytes_per_ro return Math::division_round_up(p_texel_rows_per_layer, getDataFormatDesc(p_format).blockTexelSize.height) * p_bytes_per_row; } -size_t PixelFormats::getBytesPerLayer(MTLPixelFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer) { +size_t PixelFormats::getBytesPerLayer(MTL::PixelFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer) { return Math::division_round_up(p_texel_rows_per_layer, getDataFormatDesc(p_format).blockTexelSize.height) * p_bytes_per_row; } @@ -211,7 +211,7 @@ MTLFmtCaps PixelFormats::getCapabilities(DataFormat p_format, bool p_extended) { return getCapabilities(getDataFormatDesc(p_format).mtlPixelFormat, p_extended); } -MTLFmtCaps PixelFormats::getCapabilities(MTLPixelFormat p_format, bool p_extended) { +MTLFmtCaps PixelFormats::getCapabilities(MTL::PixelFormat p_format, bool p_extended) { MTLFormatDesc &mtlDesc = getMTLPixelFormatDesc(p_format); MTLFmtCaps caps = mtlDesc.mtlFmtCaps; if (!p_extended || mtlDesc.mtlViewClass == MTLViewClass::None) { @@ -226,11 +226,11 @@ MTLFmtCaps PixelFormats::getCapabilities(MTLPixelFormat p_format, bool p_extende return caps; } -MTLVertexFormat PixelFormats::getMTLVertexFormat(DataFormat p_format) { +MTL::VertexFormat PixelFormats::getMTLVertexFormat(DataFormat p_format) { DataFormatDesc &dfDesc = getDataFormatDesc(p_format); - MTLVertexFormat format = dfDesc.mtlVertexFormat; + MTL::VertexFormat format = dfDesc.mtlVertexFormat; - if (format == MTLVertexFormatInvalid) { + if (format == MTL::VertexFormatInvalid) { String errMsg; errMsg += "DataFormat "; errMsg += dfDesc.name; @@ -254,22 +254,22 @@ DataFormatDesc &PixelFormats::getDataFormatDesc(DataFormat p_format) { return _data_format_descs[p_format]; } -DataFormatDesc &PixelFormats::getDataFormatDesc(MTLPixelFormat p_format) { +DataFormatDesc &PixelFormats::getDataFormatDesc(MTL::PixelFormat p_format) { return getDataFormatDesc(getMTLPixelFormatDesc(p_format).dataFormat); } -// Return a reference to the Metal format descriptor corresponding to the MTLPixelFormat. -MTLFormatDesc &PixelFormats::getMTLPixelFormatDesc(MTLPixelFormat p_format) { +// Return a reference to the Metal format descriptor corresponding to the MTL::PixelFormat. +MTLFormatDesc &PixelFormats::getMTLPixelFormatDesc(MTL::PixelFormat p_format) { return _mtl_pixel_format_descs[p_format]; } -// Return a reference to the Metal format descriptor corresponding to the MTLVertexFormat. -MTLFormatDesc &PixelFormats::getMTLVertexFormatDesc(MTLVertexFormat p_format) { +// Return a reference to the Metal format descriptor corresponding to the MTL::VertexFormat. +MTLFormatDesc &PixelFormats::getMTLVertexFormatDesc(MTL::VertexFormat p_format) { return _mtl_vertex_format_descs[p_format]; } -PixelFormats::PixelFormats(id p_device, const MetalFeatures &p_feat) : - device(p_device) { +PixelFormats::PixelFormats(MTL::Device *p_device, const MetalFeatures &p_feat) : + device(p_device->retain()) { initMTLPixelFormatCapabilities(); initMTLVertexFormatCapabilities(p_feat); modifyMTLFormatCapabilities(p_feat); @@ -278,9 +278,13 @@ PixelFormats::PixelFormats(id p_device, const MetalFeatures &p_feat) buildDFFormatMaps(); } +PixelFormats::~PixelFormats() { + device->release(); +} + #define addDataFormatDescFull(DATA_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, CSPC, CSCB, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE, SWIZ_R, SWIZ_G, SWIZ_B, SWIZ_A) \ dfFmt = RD::DATA_FORMAT_##DATA_FMT; \ - _data_format_descs[dfFmt] = { dfFmt, MTLPixelFormat##MTL_FMT, MTLPixelFormat##MTL_FMT_ALT, MTLVertexFormat##MTL_VTX_FMT, MTLVertexFormat##MTL_VTX_FMT_ALT, \ + _data_format_descs[dfFmt] = { dfFmt, MTL::PixelFormat##MTL_FMT, MTL::PixelFormat##MTL_FMT_ALT, MTL::VertexFormat##MTL_VTX_FMT, MTL::VertexFormat##MTL_VTX_FMT_ALT, \ CSPC, CSCB, { BLK_W, BLK_H }, BLK_BYTE_CNT, MTLFormatType::MVK_FMT_TYPE, \ { RD::TEXTURE_SWIZZLE_##SWIZ_R, RD::TEXTURE_SWIZZLE_##SWIZ_G, RD::TEXTURE_SWIZZLE_##SWIZ_B, RD::TEXTURE_SWIZZLE_##SWIZ_A }, \ "DATA_FORMAT_" #DATA_FMT, false } @@ -577,14 +581,14 @@ void PixelFormats::initDataFormatCapabilities() { addDfFormatDescChromaSubsampling(G16_B16_R16_3PLANE_444_UNORM, Invalid, 3, 16, 1, 1, 6); } -void PixelFormats::addMTLPixelFormatDescImpl(MTLPixelFormat p_pix_fmt, MTLPixelFormat p_pix_fmt_linear, +void PixelFormats::addMTLPixelFormatDescImpl(MTL::PixelFormat p_pix_fmt, MTL::PixelFormat p_pix_fmt_linear, MTLViewClass p_view_class, MTLFmtCaps p_fmt_caps, const char *p_name) { _mtl_pixel_format_descs[p_pix_fmt] = { .mtlPixelFormat = p_pix_fmt, DataFormat::DATA_FORMAT_MAX, p_fmt_caps, p_view_class, p_pix_fmt_linear, p_name }; } #define addMTLPixelFormatDescFull(mtlFmt, mtlFmtLinear, viewClass, appleGPUCaps) \ - addMTLPixelFormatDescImpl(MTLPixelFormat##mtlFmt, MTLPixelFormat##mtlFmtLinear, MTLViewClass::viewClass, \ - appleGPUCaps, "MTLPixelFormat" #mtlFmt) + addMTLPixelFormatDescImpl(MTL::PixelFormat##mtlFmt, MTL::PixelFormat##mtlFmtLinear, MTLViewClass::viewClass, \ + appleGPUCaps, "MTL::PixelFormat" #mtlFmt) #define addMTLPixelFormatDesc(mtlFmt, viewClass, appleGPUCaps) \ addMTLPixelFormatDescFull(mtlFmt, mtlFmt, viewClass, kMTLFmtCaps##appleGPUCaps) @@ -602,8 +606,8 @@ void PixelFormats::addMTLPixelFormatDescImpl(MTLPixelFormat p_pix_fmt, MTLPixelF void PixelFormats::initMTLPixelFormatCapabilities() { _mtl_pixel_format_descs.reserve(1024); - // MTLPixelFormatInvalid must come first. Use addMTLPixelFormatDescImpl to avoid guard code. - addMTLPixelFormatDescImpl(MTLPixelFormatInvalid, MTLPixelFormatInvalid, MTLViewClass::None, kMTLFmtCapsNone, "MTLPixelFormatInvalid"); + // MTL::PixelFormatInvalid must come first. Use addMTLPixelFormatDescImpl to avoid guard code. + addMTLPixelFormatDescImpl(MTL::PixelFormatInvalid, MTL::PixelFormatInvalid, MTLViewClass::None, kMTLFmtCapsNone, "MTL::PixelFormatInvalid"); // Ordinary 8-bit pixel formats. addMTLPixelFormatDesc(A8Unorm, Color8, All); @@ -779,23 +783,23 @@ void PixelFormats::initMTLPixelFormatCapabilities() { } // If necessary, resize vector with empty elements. -void PixelFormats::addMTLVertexFormatDescImpl(MTLVertexFormat mtlVtxFmt, MTLFmtCaps vtxCap, const char *name) { +void PixelFormats::addMTLVertexFormatDescImpl(MTL::VertexFormat mtlVtxFmt, MTLFmtCaps vtxCap, const char *name) { if (mtlVtxFmt >= _mtl_vertex_format_descs.size()) { _mtl_vertex_format_descs.resize(mtlVtxFmt + 1); } - _mtl_vertex_format_descs[mtlVtxFmt] = { .mtlVertexFormat = mtlVtxFmt, RD::DATA_FORMAT_MAX, vtxCap, MTLViewClass::None, MTLPixelFormatInvalid, name }; + _mtl_vertex_format_descs[mtlVtxFmt] = { .mtlVertexFormat = mtlVtxFmt, RD::DATA_FORMAT_MAX, vtxCap, MTLViewClass::None, MTL::PixelFormatInvalid, name }; } -// Check mtlVtx exists on platform, to avoid overwriting the MTLVertexFormatInvalid entry. +// Check mtlVtx exists on platform, to avoid overwriting the MTL::VertexFormatInvalid entry. #define addMTLVertexFormatDesc(mtlVtx) \ - if (MTLVertexFormat##mtlVtx) { \ - addMTLVertexFormatDescImpl(MTLVertexFormat##mtlVtx, kMTLFmtCapsVertex, "MTLVertexFormat" #mtlVtx); \ + if (MTL::VertexFormat##mtlVtx) { \ + addMTLVertexFormatDescImpl(MTL::VertexFormat##mtlVtx, kMTLFmtCapsVertex, "MTL::VertexFormat" #mtlVtx); \ } void PixelFormats::initMTLVertexFormatCapabilities(const MetalFeatures &p_feat) { - _mtl_vertex_format_descs.resize(MTLVertexFormatHalf + 3); - // MTLVertexFormatInvalid must come first. Use addMTLVertexFormatDescImpl to avoid guard code. - addMTLVertexFormatDescImpl(MTLVertexFormatInvalid, kMTLFmtCapsNone, "MTLVertexFormatInvalid"); + _mtl_vertex_format_descs.resize(MTL::VertexFormatHalf + 3); + // MTL::VertexFormatInvalid must come first. Use addMTLVertexFormatDescImpl to avoid guard code. + addMTLVertexFormatDescImpl(MTL::VertexFormatInvalid, kMTLFmtCapsNone, "MTL::VertexFormatInvalid"); addMTLVertexFormatDesc(UChar2Normalized); addMTLVertexFormatDesc(Char2Normalized); @@ -862,8 +866,8 @@ void PixelFormats::initMTLVertexFormatCapabilities(const MetalFeatures &p_feat) addMTLVertexFormatDesc(UChar4Normalized_BGRA); - if (@available(macos 14.0, ios 17.0, tvos 17.0, *)) { - if (p_feat.highestFamily >= MTLGPUFamilyApple5) { + if (__builtin_available(macos 14.0, ios 17.0, tvos 17.0, *)) { + if (p_feat.highestFamily >= MTL::GPUFamilyApple5) { addMTLVertexFormatDesc(FloatRG11B10); addMTLVertexFormatDesc(FloatRGB9E5); } @@ -871,9 +875,9 @@ void PixelFormats::initMTLVertexFormatCapabilities(const MetalFeatures &p_feat) } // Return a reference to the format capabilities, so the caller can manipulate them. -// Check mtlPixFmt exists on platform, to avoid overwriting the MTLPixelFormatInvalid entry. +// Check mtlPixFmt exists on platform, to avoid overwriting the MTL::PixelFormatInvalid entry. // When returning the dummy, reset it on each access because it can be written to by caller. -MTLFmtCaps &PixelFormats::getMTLPixelFormatCapsIf(MTLPixelFormat mtlPixFmt, bool cond) { +MTLFmtCaps &PixelFormats::getMTLPixelFormatCapsIf(MTL::PixelFormat mtlPixFmt, bool cond) { static MTLFmtCaps dummyFmtCaps; if (mtlPixFmt && cond) { return getMTLPixelFormatDesc(mtlPixFmt).mtlFmtCaps; @@ -883,22 +887,22 @@ MTLFmtCaps &PixelFormats::getMTLPixelFormatCapsIf(MTLPixelFormat mtlPixFmt, bool } } -#define setMTLPixFmtCapsIf(cond, mtlFmt, caps) getMTLPixelFormatCapsIf(MTLPixelFormat##mtlFmt, cond) = kMTLFmtCaps##caps; +#define setMTLPixFmtCapsIf(cond, mtlFmt, caps) getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond) = kMTLFmtCaps##caps; #define setMTLPixFmtCapsIfGPU(gpuFam, mtlFmt, caps) setMTLPixFmtCapsIf(gpuCaps.supports##gpuFam, mtlFmt, caps) -#define enableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::set(getMTLPixelFormatCapsIf(MTLPixelFormat##mtlFmt, cond), kMTLFmtCaps##caps); -#define enableMTLPixFmtCapsIfGPU(gpuFam, mtlFmt, caps) enableMTLPixFmtCapsIf(p_feat.highestFamily >= MTLGPUFamily##gpuFam, mtlFmt, caps) +#define enableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::set(getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond), kMTLFmtCaps##caps); +#define enableMTLPixFmtCapsIfGPU(gpuFam, mtlFmt, caps) enableMTLPixFmtCapsIf(p_feat.highestFamily >= MTL::GPUFamily##gpuFam, mtlFmt, caps) -#define disableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::clear(getMTLPixelFormatCapsIf(MTLPixelFormat##mtlFmt, cond), kMTLFmtCaps##caps); +#define disableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::clear(getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond), kMTLFmtCaps##caps); // Modifies the format capability tables based on the capabilities of the specific MTLDevice. void PixelFormats::modifyMTLFormatCapabilities(const MetalFeatures &p_feat) { bool noVulkanSupport = false; // Indicated supported in Metal but not Vulkan or SPIR-V. bool notMac = !p_feat.supportsMac; - bool iosOnly1 = notMac && p_feat.highestFamily < MTLGPUFamilyApple2; - bool iosOnly2 = notMac && p_feat.highestFamily < MTLGPUFamilyApple3; - bool iosOnly6 = notMac && p_feat.highestFamily < MTLGPUFamilyApple7; - bool iosOnly8 = notMac && p_feat.highestFamily < MTLGPUFamilyApple9; + bool iosOnly1 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple2; + bool iosOnly2 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple3; + bool iosOnly6 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple7; + bool iosOnly8 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple9; setMTLPixFmtCapsIf(iosOnly2, A8Unorm, RF); setMTLPixFmtCapsIf(iosOnly1, R8Unorm_sRGB, RFCMRB); @@ -934,7 +938,7 @@ void PixelFormats::modifyMTLFormatCapabilities(const MetalFeatures &p_feat) { // Metal supports reading both R&G into as one 64-bit atomic operation, but Vulkan and SPIR-V do not. // Including this here so we remember to update this if support is added to Vulkan in the future. - bool atomic64 = noVulkanSupport && (p_feat.highestFamily >= MTLGPUFamilyApple9 || (p_feat.highestFamily >= MTLGPUFamilyApple8 && p_feat.supportsMac)); + bool atomic64 = noVulkanSupport && (p_feat.highestFamily >= MTL::GPUFamilyApple9 || (p_feat.highestFamily >= MTL::GPUFamilyApple8 && p_feat.supportsMac)); enableMTLPixFmtCapsIf(atomic64, RG32Uint, Atomic); enableMTLPixFmtCapsIf(atomic64, RG32Sint, Atomic); @@ -961,7 +965,7 @@ void PixelFormats::modifyMTLFormatCapabilities(const MetalFeatures &p_feat) { enableMTLPixFmtCapsIf(floatFB, RGBA32Float, Filter); enableMTLPixFmtCapsIf(floatFB, RGBA32Float, Blend); // Undocumented by confirmed through testing. - bool noHDR_ASTC = p_feat.highestFamily < MTLGPUFamilyApple6; + bool noHDR_ASTC = p_feat.highestFamily < MTL::GPUFamilyApple6; setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_4x4_HDR, None); setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_5x4_HDR, None); setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_5x5_HDR, None); @@ -1021,13 +1025,13 @@ void PixelFormats::buildDFFormatMaps() { mtlDesc.dataFormat = dfDesc.dataFormat; } if (!mtlDesc.isSupported()) { - dfDesc.mtlPixelFormat = MTLPixelFormatInvalid; + dfDesc.mtlPixelFormat = MTL::PixelFormatInvalid; } } if (dfDesc.mtlPixelFormatSubstitute) { MTLFormatDesc &mtlDesc = getMTLPixelFormatDesc(dfDesc.mtlPixelFormatSubstitute); if (!mtlDesc.isSupported()) { - dfDesc.mtlPixelFormatSubstitute = MTLPixelFormatInvalid; + dfDesc.mtlPixelFormatSubstitute = MTL::PixelFormatInvalid; } } if (dfDesc.mtlVertexFormat) { @@ -1036,13 +1040,13 @@ void PixelFormats::buildDFFormatMaps() { mtlDesc.dataFormat = dfDesc.dataFormat; } if (!mtlDesc.isSupported()) { - dfDesc.mtlVertexFormat = MTLVertexFormatInvalid; + dfDesc.mtlVertexFormat = MTL::VertexFormatInvalid; } } if (dfDesc.mtlVertexFormatSubstitute) { MTLFormatDesc &mtlDesc = getMTLVertexFormatDesc(dfDesc.mtlVertexFormatSubstitute); if (!mtlDesc.isSupported()) { - dfDesc.mtlVertexFormatSubstitute = MTLVertexFormatInvalid; + dfDesc.mtlVertexFormatSubstitute = MTL::VertexFormatInvalid; } } } diff --git a/drivers/metal/pixel_formats.h b/drivers/metal/pixel_formats.h index 04f1d9350d..0f1fb19d1d 100644 --- a/drivers/metal/pixel_formats.h +++ b/drivers/metal/pixel_formats.h @@ -54,12 +54,15 @@ GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations") -#import "inflection_map.h" -#import "metal_device_properties.h" +#include "inflection_map.h" +#include "metal_device_properties.h" #include "servers/rendering/rendering_device.h" -#import +#ifdef __OBJC__ +#include +#endif +#include #include #pragma mark - @@ -197,10 +200,10 @@ struct ComponentMapping { /** Describes the properties of a DataFormat, including the corresponding Metal pixel and vertex format. */ struct DataFormatDesc { RD::DataFormat dataFormat; - MTLPixelFormat mtlPixelFormat; - MTLPixelFormat mtlPixelFormatSubstitute; - MTLVertexFormat mtlVertexFormat; - MTLVertexFormat mtlVertexFormatSubstitute; + MTL::PixelFormat mtlPixelFormat; + MTL::PixelFormat mtlPixelFormatSubstitute; + MTL::VertexFormat mtlVertexFormat; + MTL::VertexFormat mtlVertexFormatSubstitute; uint8_t chromaSubsamplingPlaneCount; uint8_t chromaSubsamplingComponentBits; Extent2D blockTexelSize; @@ -212,11 +215,11 @@ struct DataFormatDesc { inline double bytesPerTexel() const { return (double)bytesPerBlock / (double)(blockTexelSize.width * blockTexelSize.height); } - inline bool isSupported() const { return (mtlPixelFormat != MTLPixelFormatInvalid || chromaSubsamplingPlaneCount > 1); } - inline bool isSupportedOrSubstitutable() const { return isSupported() || (mtlPixelFormatSubstitute != MTLPixelFormatInvalid); } + inline bool isSupported() const { return (mtlPixelFormat != MTL::PixelFormatInvalid || chromaSubsamplingPlaneCount > 1); } + inline bool isSupportedOrSubstitutable() const { return isSupported() || (mtlPixelFormatSubstitute != MTL::PixelFormatInvalid); } - inline bool vertexIsSupported() const { return (mtlVertexFormat != MTLVertexFormatInvalid); } - inline bool vertexIsSupportedOrSubstitutable() const { return vertexIsSupported() || (mtlVertexFormatSubstitute != MTLVertexFormatInvalid); } + inline bool vertexIsSupported() const { return (mtlVertexFormat != MTL::VertexFormatInvalid); } + inline bool vertexIsSupportedOrSubstitutable() const { return vertexIsSupported() || (mtlVertexFormatSubstitute != MTL::VertexFormatInvalid); } bool needsSwizzle() const { return (componentMapping.r != RD::TEXTURE_SWIZZLE_IDENTITY || @@ -226,19 +229,19 @@ struct DataFormatDesc { } }; -/** Describes the properties of a MTLPixelFormat or MTLVertexFormat. */ +/** Describes the properties of a MTL::PixelFormat or MTL::VertexFormat. */ struct MTLFormatDesc { union { - MTLPixelFormat mtlPixelFormat; - MTLVertexFormat mtlVertexFormat; + MTL::PixelFormat mtlPixelFormat; + MTL::VertexFormat mtlVertexFormat; }; RD::DataFormat dataFormat = RD::DATA_FORMAT_MAX; MTLFmtCaps mtlFmtCaps; MTLViewClass mtlViewClass; - MTLPixelFormat mtlPixelFormatLinear; + MTL::PixelFormat mtlPixelFormatLinear; const char *name = nullptr; - inline bool isSupported() const { return (mtlPixelFormat != MTLPixelFormatInvalid) && (mtlFmtCaps != kMTLFmtCapsNone); } + inline bool isSupported() const { return (mtlPixelFormat != MTL::PixelFormatInvalid) && (mtlFmtCaps != kMTLFmtCapsNone); } }; class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) PixelFormats { @@ -251,14 +254,14 @@ public: /** Returns whether the DataFormat is supported by this implementation, or can be substituted by one that is. */ bool isSupportedOrSubstitutable(DataFormat p_format); - /** Returns whether the specified Metal MTLPixelFormat can be used as a depth format. */ - _FORCE_INLINE_ bool isDepthFormat(MTLPixelFormat p_format) { + /** Returns whether the specified Metal MTL::PixelFormat can be used as a depth format. */ + _FORCE_INLINE_ bool isDepthFormat(MTL::PixelFormat p_format) { switch (p_format) { - case MTLPixelFormatDepth32Float: - case MTLPixelFormatDepth16Unorm: - case MTLPixelFormatDepth32Float_Stencil8: + case MTL::PixelFormatDepth32Float: + case MTL::PixelFormatDepth16Unorm: + case MTL::PixelFormatDepth32Float_Stencil8: #if TARGET_OS_OSX - case MTLPixelFormatDepth24Unorm_Stencil8: + case MTL::PixelFormatDepth24Unorm_Stencil8: #endif return true; default: @@ -266,42 +269,42 @@ public: } } - /** Returns whether the specified Metal MTLPixelFormat can be used as a stencil format. */ - _FORCE_INLINE_ bool isStencilFormat(MTLPixelFormat p_format) { + /** Returns whether the specified Metal MTL::PixelFormat can be used as a stencil format. */ + _FORCE_INLINE_ bool isStencilFormat(MTL::PixelFormat p_format) { switch (p_format) { - case MTLPixelFormatStencil8: + case MTL::PixelFormatStencil8: #if TARGET_OS_OSX - case MTLPixelFormatDepth24Unorm_Stencil8: - case MTLPixelFormatX24_Stencil8: + case MTL::PixelFormatDepth24Unorm_Stencil8: + case MTL::PixelFormatX24_Stencil8: #endif - case MTLPixelFormatDepth32Float_Stencil8: - case MTLPixelFormatX32_Stencil8: + case MTL::PixelFormatDepth32Float_Stencil8: + case MTL::PixelFormatX32_Stencil8: return true; default: return false; } } - /** Returns whether the specified Metal MTLPixelFormat is a PVRTC format. */ - bool isPVRTCFormat(MTLPixelFormat p_format); + /** Returns whether the specified Metal MTL::PixelFormat is a PVRTC format. */ + bool isPVRTCFormat(MTL::PixelFormat p_format); /** Returns the format type corresponding to the specified Godot pixel format, */ MTLFormatType getFormatType(DataFormat p_format); - /** Returns the format type corresponding to the specified Metal MTLPixelFormat, */ - MTLFormatType getFormatType(MTLPixelFormat p_format); + /** Returns the format type corresponding to the specified Metal MTL::PixelFormat, */ + MTLFormatType getFormatType(MTL::PixelFormat p_format); /** - * Returns the Metal MTLPixelFormat corresponding to the specified Godot pixel - * or returns MTLPixelFormatInvalid if no corresponding MTLPixelFormat exists. + * Returns the Metal MTL::PixelFormat corresponding to the specified Godot pixel + * or returns MTL::PixelFormatInvalid if no corresponding MTL::PixelFormat exists. */ - MTLPixelFormat getMTLPixelFormat(DataFormat p_format); + MTL::PixelFormat getMTLPixelFormat(DataFormat p_format); /** - * Returns the DataFormat corresponding to the specified Metal MTLPixelFormat, + * Returns the DataFormat corresponding to the specified Metal MTL::PixelFormat, * or returns DATA_FORMAT_MAX if no corresponding DataFormat exists. */ - DataFormat getDataFormat(MTLPixelFormat p_format); + DataFormat getDataFormat(MTL::PixelFormat p_format); /** * Returns the size, in bytes, of a texel block of the specified Godot pixel. @@ -313,7 +316,7 @@ public: * Returns the size, in bytes, of a texel block of the specified Metal format. * For uncompressed formats, the returned value corresponds to the size in bytes of a single texel. */ - uint32_t getBytesPerBlock(MTLPixelFormat p_format); + uint32_t getBytesPerBlock(MTL::PixelFormat p_format); /** Returns the number of planes of the specified chroma-subsampling (YCbCr) DataFormat */ uint8_t getChromaSubsamplingPlaneCount(DataFormat p_format); @@ -331,7 +334,7 @@ public: * Returns the size, in bytes, of a texel of the specified Metal format. * The returned value may be fractional for certain compressed formats. */ - float getBytesPerTexel(MTLPixelFormat p_format); + float getBytesPerTexel(MTL::PixelFormat p_format); /** * Returns the size, in bytes, of a row of texels of the specified Godot pixel format. @@ -349,7 +352,7 @@ public: * and texelsPerRow should specify the width in texels, not blocks. The result is rounded * up if texelsPerRow is not an integer multiple of the compression block width. */ - size_t getBytesPerRow(MTLPixelFormat p_format, uint32_t p_texels_per_row); + size_t getBytesPerRow(MTL::PixelFormat p_format, uint32_t p_texels_per_row); /** * Returns the size, in bytes, of a texture layer of the specified Godot pixel format. @@ -366,7 +369,7 @@ public: * and p_texel_rows_per_layer should specify the height in texels, not blocks. The result is * rounded up if p_texel_rows_per_layer is not an integer multiple of the compression block height. */ - size_t getBytesPerLayer(MTLPixelFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer); + size_t getBytesPerLayer(MTL::PixelFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer); /** Returns whether or not the specified Godot format requires swizzling to use with Metal. */ bool needsSwizzle(DataFormat p_format); @@ -375,37 +378,38 @@ public: MTLFmtCaps getCapabilities(DataFormat p_format, bool p_extended = false); /** Returns the Metal format capabilities supported by the specified Metal format. */ - MTLFmtCaps getCapabilities(MTLPixelFormat p_format, bool p_extended = false); + MTLFmtCaps getCapabilities(MTL::PixelFormat p_format, bool p_extended = false); /** - * Returns the Metal MTLVertexFormat corresponding to the specified + * Returns the Metal MTL::VertexFormat corresponding to the specified * DataFormat as used as a vertex attribute format. */ - MTLVertexFormat getMTLVertexFormat(DataFormat p_format); + MTL::VertexFormat getMTLVertexFormat(DataFormat p_format); #pragma mark Construction - explicit PixelFormats(id p_device, const MetalFeatures &p_feat); + explicit PixelFormats(MTL::Device *p_device, const MetalFeatures &p_feat); + ~PixelFormats(); protected: DataFormatDesc &getDataFormatDesc(DataFormat p_format); - DataFormatDesc &getDataFormatDesc(MTLPixelFormat p_format); - MTLFormatDesc &getMTLPixelFormatDesc(MTLPixelFormat p_format); - MTLFmtCaps &getMTLPixelFormatCapsIf(MTLPixelFormat mtlPixFmt, bool cond); - MTLFormatDesc &getMTLVertexFormatDesc(MTLVertexFormat p_format); + DataFormatDesc &getDataFormatDesc(MTL::PixelFormat p_format); + MTLFormatDesc &getMTLPixelFormatDesc(MTL::PixelFormat p_format); + MTLFmtCaps &getMTLPixelFormatCapsIf(MTL::PixelFormat mtlPixFmt, bool cond); + MTLFormatDesc &getMTLVertexFormatDesc(MTL::VertexFormat p_format); void initDataFormatCapabilities(); void initMTLPixelFormatCapabilities(); void initMTLVertexFormatCapabilities(const MetalFeatures &p_feat); void modifyMTLFormatCapabilities(const MetalFeatures &p_feat); void buildDFFormatMaps(); - void addMTLPixelFormatDescImpl(MTLPixelFormat p_pix_fmt, MTLPixelFormat p_pix_fmt_linear, + void addMTLPixelFormatDescImpl(MTL::PixelFormat p_pix_fmt, MTL::PixelFormat p_pix_fmt_linear, MTLViewClass p_view_class, MTLFmtCaps p_fmt_caps, const char *p_name); - void addMTLVertexFormatDescImpl(MTLVertexFormat p_vert_fmt, MTLFmtCaps p_vert_caps, const char *name); + void addMTLVertexFormatDescImpl(MTL::VertexFormat p_vert_fmt, MTLFmtCaps p_vert_caps, const char *name); - id device; + MTL::Device *device; InflectionMap _data_format_descs; - InflectionMap _mtl_pixel_format_descs; // The actual last enum value is not available on iOS. + InflectionMap _mtl_pixel_format_descs; // The actual last enum value is not available on iOS. TightLocalVector _mtl_vertex_format_descs; }; diff --git a/drivers/metal/rendering_context_driver_metal.mm b/drivers/metal/rendering_context_driver_metal.cpp similarity index 65% rename from drivers/metal/rendering_context_driver_metal.mm rename to drivers/metal/rendering_context_driver_metal.cpp index 51b752f2a0..2f2769fe31 100644 --- a/drivers/metal/rendering_context_driver_metal.mm +++ b/drivers/metal/rendering_context_driver_metal.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* rendering_context_driver_metal.mm */ +/* rendering_context_driver_metal.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -28,14 +28,35 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ -#import "rendering_context_driver_metal.h" +#include "rendering_context_driver_metal.h" -#import "rendering_device_driver_metal.h" +#include "metal3_objects.h" +#include "metal_objects_shared.h" +#include "rendering_device_driver_metal3.h" #include "core/templates/sort_array.h" -#import -#import +#include +#include + +#include + +// Selector helper for calling ObjC methods from C++ +#define _APPLE_PRIVATE_DEF_SEL(accessor, symbol) static SEL s_k##accessor = sel_registerName(symbol) +#define _APPLE_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor) + +namespace Private::Selector { + +_APPLE_PRIVATE_DEF_SEL(setOpaque_, "setOpaque:"); + +template +_NS_INLINE _Ret sendMessage(const void *pObj, SEL selector, _Args... args) { + using SendMessageProc = _Ret (*)(const void *, SEL, _Args...); + const SendMessageProc pProc = reinterpret_cast(&objc_msgSend); + return (*pProc)(pObj, selector, args...); +} + +} // namespace Private::Selector #pragma mark - Logging @@ -48,12 +69,6 @@ __attribute__((constructor)) static void InitializeLogging(void) { LOG_INTERVALS = os_log_create("org.godotengine.godot.metal", "events"); } -@protocol MTLDeviceEx -#if TARGET_OS_OSX && __MAC_OS_X_VERSION_MAX_ALLOWED < 130300 -- (void)setShouldMaximizeConcurrentCompilation:(BOOL)v; -#endif -@end - RenderingContextDriverMetal::RenderingContextDriverMetal() { } @@ -61,14 +76,14 @@ RenderingContextDriverMetal::~RenderingContextDriverMetal() { } Error RenderingContextDriverMetal::initialize() { - if (OS::get_singleton()->get_environment("MTL_CAPTURE_ENABLED") == "1") { + if (OS::get_singleton()->get_environment("MTL_CAPTURE_ENABLED") == "1" || OS::get_singleton()->get_environment("MTLCAPTURE_DESTINATION_DEVELOPER_TOOLS_ENABLE") == "1") { capture_available = true; } - metal_device = MTLCreateSystemDefaultDevice(); + metal_device = MTL::CreateSystemDefaultDevice(); #if TARGET_OS_OSX - if (@available(macOS 13.3, *)) { - [id(metal_device) setShouldMaximizeConcurrentCompilation:YES]; + if (__builtin_available(macOS 13.3, *)) { + metal_device->setShouldMaximizeConcurrentCompilation(true); } #endif device.type = DEVICE_TYPE_INTEGRATED_GPU; @@ -76,8 +91,8 @@ Error RenderingContextDriverMetal::initialize() { device.workarounds = Workarounds(); MetalDeviceProperties props(metal_device); - int version = (int)props.features.highestFamily - (int)MTLGPUFamilyApple1 + 1; - device.name = vformat("%s (Apple%d)", metal_device.name.UTF8String, version); + int version = (int)props.features.highestFamily - (int)MTL::GPUFamilyApple1 + 1; + device.name = vformat("%s (Apple%d)", metal_device->name()->utf8String(), version); return OK; } @@ -92,7 +107,7 @@ uint32_t RenderingContextDriverMetal::device_get_count() const { } RenderingDeviceDriver *RenderingContextDriverMetal::driver_create() { - return memnew(RenderingDeviceDriverMetal(this)); + return memnew(MTL3::RenderingDeviceDriverMetal(this)); } void RenderingContextDriverMetal::driver_free(RenderingDeviceDriver *p_driver) { @@ -100,25 +115,25 @@ void RenderingContextDriverMetal::driver_free(RenderingDeviceDriver *p_driver) { } class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) SurfaceLayer : public RenderingContextDriverMetal::Surface { - CAMetalLayer *__unsafe_unretained layer = nil; + CA::MetalLayer *layer = nullptr; LocalVector frame_buffers; - LocalVector> drawables; + LocalVector drawables; uint32_t rear = -1; uint32_t front = 0; uint32_t count = 0; public: - SurfaceLayer(CAMetalLayer *p_layer, id p_device) : + SurfaceLayer(CA::MetalLayer *p_layer, MTL::Device *p_device) : Surface(p_device), layer(p_layer) { - layer.allowsNextDrawableTimeout = YES; - layer.framebufferOnly = YES; - layer.opaque = OS::get_singleton()->is_layered_allowed() ? NO : YES; - layer.pixelFormat = get_pixel_format(); - layer.device = p_device; + layer->setAllowsNextDrawableTimeout(true); + layer->setFramebufferOnly(true); + Private::Selector::sendMessage(layer, _APPLE_PRIVATE_SEL(setOpaque_), !OS::get_singleton()->is_layered_allowed()); + layer->setPixelFormat(get_pixel_format()); + layer->setDevice(p_device); } ~SurfaceLayer() override { - layer = nil; + layer = nullptr; } Error resize(uint32_t p_desired_framebuffer_count) override final { @@ -128,14 +143,14 @@ public: } CGSize drawableSize = CGSizeMake(width, height); - CGSize current = layer.drawableSize; + CGSize current = layer->drawableSize(); if (!CGSizeEqualToSize(current, drawableSize)) { - layer.drawableSize = drawableSize; + layer->setDrawableSize(drawableSize); } // Metal supports a maximum of 3 drawables. p_desired_framebuffer_count = MIN(3U, p_desired_framebuffer_count); - layer.maximumDrawableCount = p_desired_framebuffer_count; + layer->setMaximumDrawableCount(p_desired_framebuffer_count); #if TARGET_OS_OSX // Display sync is only supported on macOS. @@ -143,10 +158,10 @@ public: case DisplayServer::VSYNC_MAILBOX: case DisplayServer::VSYNC_ADAPTIVE: case DisplayServer::VSYNC_ENABLED: - layer.displaySyncEnabled = YES; + layer->setDisplaySyncEnabled(true); break; case DisplayServer::VSYNC_DISABLED: - layer.displaySyncEnabled = NO; + layer->setDisplaySyncEnabled(false); break; } #endif @@ -171,56 +186,77 @@ public: MDFrameBuffer &frame_buffer = frame_buffers[rear]; frame_buffer.size = Size2i(width, height); - id drawable = layer.nextDrawable; + CA::MetalDrawable *drawable = layer->nextDrawable(); ERR_FAIL_NULL_V_MSG(drawable, RDD::FramebufferID(), "no drawable available"); drawables[rear] = drawable; - frame_buffer.set_texture(0, drawable.texture); + frame_buffer.set_texture(0, drawable->texture()); return RDD::FramebufferID(&frame_buffer); } - void present(MDCommandBuffer *p_cmd_buffer) override final { + void present(MTL3::MDCommandBuffer *p_cmd_buffer) override final { if (count == 0) { return; } // Release texture and drawable. frame_buffers[front].unset_texture(0); - id drawable = drawables[front]; - drawables[front] = nil; + MTL::Drawable *drawable = drawables[front]; + drawables[front] = nullptr; count--; front = (front + 1) % frame_buffers.size(); if (vsync_mode != DisplayServer::VSYNC_DISABLED) { - [p_cmd_buffer->get_command_buffer() presentDrawable:drawable afterMinimumDuration:present_minimum_duration]; + p_cmd_buffer->get_command_buffer()->presentDrawableAfterMinimumDuration(drawable, present_minimum_duration); } else { - [p_cmd_buffer->get_command_buffer() presentDrawable:drawable]; + p_cmd_buffer->get_command_buffer()->presentDrawable(drawable); } } + + MTL::Drawable *next_drawable() override final { + if (count == 0) { + return nullptr; + } + + // Release texture and drawable. + frame_buffers[front].unset_texture(0); + MTL::Drawable *drawable = drawables[front]; + drawables[front] = nullptr; + + count--; + front = (front + 1) % frame_buffers.size(); + + return drawable; + } + + API_AVAILABLE(macos(26.0), ios(26.0)) + MTL::ResidencySet *get_residency_set() const override final { + return layer->residencySet(); + } }; class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) SurfaceOffscreen : public RenderingContextDriverMetal::Surface { int frame_buffer_size = 3; MDFrameBuffer *frame_buffers; - LocalVector> textures; - LocalVector> drawables; + LocalVector textures; + LocalVector drawables; int32_t rear = -1; std::atomic_int count; uint64_t target_time = 0; - CAMetalLayer *layer; + CA::MetalLayer *layer; public: - SurfaceOffscreen(CAMetalLayer *p_layer, id p_device) : + SurfaceOffscreen(CA::MetalLayer *p_layer, MTL::Device *p_device) : Surface(p_device), layer(p_layer) { - layer.allowsNextDrawableTimeout = YES; - layer.framebufferOnly = YES; - layer.opaque = OS::get_singleton()->is_layered_allowed() ? NO : YES; - layer.pixelFormat = get_pixel_format(); - layer.device = p_device; + layer->setAllowsNextDrawableTimeout(true); + layer->setFramebufferOnly(true); + Private::Selector::sendMessage(layer, _APPLE_PRIVATE_SEL(setOpaque_), !OS::get_singleton()->is_layered_allowed()); + layer->setPixelFormat(get_pixel_format()); + layer->setDevice(p_device); #if TARGET_OS_OSX - layer.displaySyncEnabled = NO; + layer->setDisplaySyncEnabled(false); #endif target_time = OS::get_singleton()->get_ticks_usec(); @@ -244,9 +280,9 @@ public: } CGSize drawableSize = CGSizeMake(width, height); - CGSize current = layer.drawableSize; + CGSize current = layer->drawableSize(); if (!CGSizeEqualToSize(current, drawableSize)) { - layer.drawableSize = drawableSize; + layer->setDrawableSize(drawableSize); } return OK; @@ -263,22 +299,22 @@ public: MDFrameBuffer &frame_buffer = frame_buffers[rear]; - if (textures[rear] == nil || textures[rear].width != width || textures[rear].height != height) { - MTLTextureDescriptor *texture_descriptor = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:get_pixel_format() width:width height:height mipmapped:NO]; - texture_descriptor.usage = MTLTextureUsageRenderTarget; - texture_descriptor.hazardTrackingMode = MTLHazardTrackingModeUntracked; - texture_descriptor.storageMode = MTLStorageModePrivate; - textures[rear] = [device newTextureWithDescriptor:texture_descriptor]; + if (textures[rear] == nullptr || textures[rear]->width() != width || textures[rear]->height() != height) { + MTL::TextureDescriptor *texture_descriptor = MTL::TextureDescriptor::texture2DDescriptor(get_pixel_format(), width, height, false); + texture_descriptor->setUsage(MTL::TextureUsageRenderTarget); + texture_descriptor->setHazardTrackingMode(MTL::HazardTrackingModeUntracked); + texture_descriptor->setStorageMode(MTL::StorageModePrivate); + textures[rear] = device->newTexture(texture_descriptor); } frame_buffer.size = Size2i(width, height); uint64_t now = OS::get_singleton()->get_ticks_usec(); if (now >= target_time) { target_time = now + 1'000'000; // 1 second into the future. - id drawable = layer.nextDrawable; + CA::MetalDrawable *drawable = layer->nextDrawable(); ERR_FAIL_NULL_V_MSG(drawable, RDD::FramebufferID(), "no drawable available"); drawables[rear] = drawable; - frame_buffer.set_texture(0, drawable.texture); + frame_buffer.set_texture(0, drawable->texture()); } else { frame_buffer.set_texture(0, textures[rear]); } @@ -286,18 +322,39 @@ public: return RDD::FramebufferID(&frame_buffers[rear]); } - void present(MDCommandBuffer *p_cmd_buffer) override final { + void present(MTL3::MDCommandBuffer *p_cmd_buffer) override final { MDFrameBuffer *frame_buffer = &frame_buffers[rear]; - if (drawables[rear] != nil) { - [p_cmd_buffer->get_command_buffer() presentDrawable:drawables[rear]]; - drawables[rear] = nil; + if (drawables[rear] != nullptr) { + p_cmd_buffer->get_command_buffer()->presentDrawable(drawables[rear]); + drawables[rear] = nullptr; } - [p_cmd_buffer->get_command_buffer() addScheduledHandler:^(id p_command_buffer) { + p_cmd_buffer->get_command_buffer()->addScheduledHandler([frame_buffer, this](MTL::CommandBuffer *) { frame_buffer->unset_texture(0); count.fetch_add(-1, std::memory_order_relaxed); - }]; + }); + } + + MTL::Drawable *next_drawable() override final { + if (count == 0) { + return nullptr; + } + + MDFrameBuffer *frame_buffer = &frame_buffers[rear]; + + MTL::Drawable *next = drawables[rear]; + drawables[rear] = nullptr; + + frame_buffer->unset_texture(0); + count--; + + return next; + } + + API_AVAILABLE(macos(26.0), ios(26.0)) + MTL::ResidencySet *get_residency_set() const override final { + return layer->residencySet(); } }; diff --git a/drivers/metal/rendering_context_driver_metal.h b/drivers/metal/rendering_context_driver_metal.h index 8e313d81f1..513b8d18f0 100644 --- a/drivers/metal/rendering_context_driver_metal.h +++ b/drivers/metal/rendering_context_driver_metal.h @@ -35,42 +35,18 @@ #include "servers/rendering/rendering_context_driver.h" #include "servers/rendering/rendering_device_driver.h" -#import +#include +#include -#ifdef __OBJC__ -#import "metal_objects.h" - -#import -#import - -@class CAMetalLayer; -@protocol CAMetalDrawable; -#else -typedef enum MTLPixelFormat { - MTLPixelFormatBGRA8Unorm = 80, -} MTLPixelFormat; +namespace MTL3 { class MDCommandBuffer; -#endif - -class PixelFormats; - -#ifdef __OBJC__ -#define METAL_DEVICE id -#define METAL_DRAWABLE id -#define METAL_LAYER CAMetalLayer *__unsafe_unretained -#define METAL_RESIDENCY_SET id -#else -#define METAL_DEVICE void * -#define METAL_DRAWABLE void * -#define METAL_LAYER void * -#define METAL_RESIDENCY_SET void * -#endif +} class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingContextDriverMetal : public RenderingContextDriver { bool capture_available = false; protected: - METAL_DEVICE metal_device = nullptr; + MTL::Device *metal_device = nullptr; Device device; // There is only one device on Apple Silicon. public: @@ -95,12 +71,12 @@ public: // Platform-specific data for the Windows embedded in this driver. struct WindowPlatformData { - METAL_LAYER layer; + CA::MetalLayer *layer; }; class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) Surface { protected: - METAL_DEVICE device; + MTL::Device *device; public: uint32_t width = 0; @@ -109,18 +85,21 @@ public: bool needs_resize = false; double present_minimum_duration = 0.0; - Surface(METAL_DEVICE p_device) : + Surface(MTL::Device *p_device) : device(p_device) {} virtual ~Surface() = default; - MTLPixelFormat get_pixel_format() const { return MTLPixelFormatBGRA8Unorm; } + MTL::PixelFormat get_pixel_format() const { return MTL::PixelFormatBGRA8Unorm; } virtual Error resize(uint32_t p_desired_framebuffer_count) = 0; virtual RDD::FramebufferID acquire_next_frame_buffer() = 0; - virtual void present(MDCommandBuffer *p_cmd_buffer) = 0; + virtual void present(MTL3::MDCommandBuffer *p_cmd_buffer) = 0; + virtual MTL::Drawable *next_drawable() = 0; + API_AVAILABLE(macos(26.0), ios(26.0)) + virtual MTL::ResidencySet *get_residency_set() const = 0; void set_max_fps(int p_max_fps) { present_minimum_duration = p_max_fps ? 1.0 / p_max_fps : 0.0; } }; - METAL_DEVICE get_metal_device() const { + MTL::Device *get_metal_device() const { return metal_device; } diff --git a/drivers/metal/rendering_device_driver_metal.mm b/drivers/metal/rendering_device_driver_metal.cpp similarity index 65% rename from drivers/metal/rendering_device_driver_metal.mm rename to drivers/metal/rendering_device_driver_metal.cpp index 654196d943..0dc7915d48 100644 --- a/drivers/metal/rendering_device_driver_metal.mm +++ b/drivers/metal/rendering_device_driver_metal.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* rendering_device_driver_metal.mm */ +/* rendering_device_driver_metal.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -48,21 +48,21 @@ /* permissions and limitations under the License. */ /**************************************************************************/ -#import "rendering_device_driver_metal.h" +#include "rendering_device_driver_metal.h" -#import "pixel_formats.h" -#import "rendering_context_driver_metal.h" -#import "rendering_shader_container_metal.h" +#include "pixel_formats.h" +#include "rendering_context_driver_metal.h" +#include "rendering_shader_container_metal.h" +#include "core/config/project_settings.h" #include "core/io/marshalls.h" #include "core/string/ustring.h" #include "core/templates/hash_map.h" #include "drivers/apple/foundation_helpers.h" -#import -#import -#import -#import +#include +#include +#include #include #ifndef MTLGPUAddress @@ -80,26 +80,14 @@ extern os_log_t LOG_INTERVALS; /*****************/ // RDD::CompareOperator == VkCompareOp. -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_NEVER, MTLCompareFunctionNever)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_LESS, MTLCompareFunctionLess)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_EQUAL, MTLCompareFunctionEqual)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_LESS_OR_EQUAL, MTLCompareFunctionLessEqual)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_GREATER, MTLCompareFunctionGreater)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_NOT_EQUAL, MTLCompareFunctionNotEqual)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_GREATER_OR_EQUAL, MTLCompareFunctionGreaterEqual)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_ALWAYS, MTLCompareFunctionAlways)); - -_FORCE_INLINE_ MTLSize mipmapLevelSizeFromSize(MTLSize p_size, NSUInteger p_level) { - if (p_level == 0) { - return p_size; - } - - MTLSize lvlSize; - lvlSize.width = MAX(p_size.width >> p_level, 1UL); - lvlSize.height = MAX(p_size.height >> p_level, 1UL); - lvlSize.depth = MAX(p_size.depth >> p_level, 1UL); - return lvlSize; -} +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_NEVER, MTL::CompareFunctionNever)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_LESS, MTL::CompareFunctionLess)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_EQUAL, MTL::CompareFunctionEqual)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_LESS_OR_EQUAL, MTL::CompareFunctionLessEqual)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_GREATER, MTL::CompareFunctionGreater)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_NOT_EQUAL, MTL::CompareFunctionNotEqual)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_GREATER_OR_EQUAL, MTL::CompareFunctionGreaterEqual)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::COMPARE_OP_ALWAYS, MTL::CompareFunctionAlways)); /*****************/ /**** BUFFERS ****/ @@ -111,21 +99,21 @@ RDD::BufferID RenderingDeviceDriverMetal::buffer_create(uint64_t p_size, BitFiel p_size = round_up_to_alignment(p_size, 16u) * _frame_count; } - MTLResourceOptions options = 0; + MTL::ResourceOptions options = 0; switch (p_allocation_type) { case MEMORY_ALLOCATION_TYPE_CPU: - options = MTLResourceHazardTrackingModeTracked | MTLResourceStorageModeShared; + options = base_hazard_tracking | MTL::ResourceStorageModeShared; break; case MEMORY_ALLOCATION_TYPE_GPU: if (p_usage.has_flag(BUFFER_USAGE_DYNAMIC_PERSISTENT_BIT)) { - options = MTLResourceHazardTrackingModeUntracked | MTLResourceStorageModeShared | MTLResourceCPUCacheModeWriteCombined; + options = MTL::ResourceHazardTrackingModeUntracked | MTL::ResourceStorageModeShared | MTL::ResourceCPUCacheModeWriteCombined; } else { - options = MTLResourceHazardTrackingModeTracked | MTLResourceStorageModePrivate; + options = base_hazard_tracking | MTL::ResourceStorageModePrivate; } break; } - id obj = [device newBufferWithLength:p_size options:options]; + MTL::Buffer *obj = device->newBuffer(p_size, options); ERR_FAIL_NULL_V_MSG(obj, BufferID(), "Can't create buffer of size: " + itos(p_size)); BufferInfo *buf_info; @@ -140,7 +128,9 @@ RDD::BufferID RenderingDeviceDriverMetal::buffer_create(uint64_t p_size, BitFiel } else { buf_info = memnew(BufferInfo); } - buf_info->metal_buffer = obj; + buf_info->metal_buffer = NS::TransferPtr(obj); + + _track_resource(buf_info->metal_buffer.get()); return BufferID(buf_info); } @@ -152,7 +142,8 @@ bool RenderingDeviceDriverMetal::buffer_set_texel_format(BufferID p_buffer, Data void RenderingDeviceDriverMetal::buffer_free(BufferID p_buffer) { BufferInfo *buf_info = (BufferInfo *)p_buffer.id; - buf_info->metal_buffer = nil; // Tell ARC to release. + + _untrack_resource(buf_info->metal_buffer.get()); if (buf_info->is_dynamic()) { memdelete((MetalBufferDynamicInfo *)buf_info); @@ -163,13 +154,13 @@ void RenderingDeviceDriverMetal::buffer_free(BufferID p_buffer) { uint64_t RenderingDeviceDriverMetal::buffer_get_allocation_size(BufferID p_buffer) { const BufferInfo *buf_info = (const BufferInfo *)p_buffer.id; - return buf_info->metal_buffer.allocatedSize; + return buf_info->metal_buffer.get()->allocatedSize(); } uint8_t *RenderingDeviceDriverMetal::buffer_map(BufferID p_buffer) { const BufferInfo *buf_info = (const BufferInfo *)p_buffer.id; - ERR_FAIL_COND_V_MSG(buf_info->metal_buffer.storageMode != MTLStorageModeShared, nullptr, "Unable to map private buffers"); - return (uint8_t *)buf_info->metal_buffer.contents; + ERR_FAIL_COND_V_MSG(buf_info->metal_buffer.get()->storageMode() != MTL::StorageModeShared, nullptr, "Unable to map private buffers"); + return (uint8_t *)buf_info->metal_buffer.get()->contents(); } void RenderingDeviceDriverMetal::buffer_unmap(BufferID p_buffer) { @@ -183,7 +174,7 @@ uint8_t *RenderingDeviceDriverMetal::buffer_persistent_map_advance(BufferID p_bu ERR_FAIL_COND_V_MSG(buf_info->last_frame_mapped == p_frames_drawn, nullptr, "Buffers with BUFFER_USAGE_DYNAMIC_PERSISTENT_BIT must only be mapped once per frame. Otherwise there could be race conditions with the GPU. Amalgamate all data uploading into one map(), use an extra buffer or remove the bit."); buf_info->last_frame_mapped = p_frames_drawn; #endif - return (uint8_t *)buf_info->metal_buffer.contents + buf_info->next_frame_index(_frame_count) * buf_info->size_bytes; + return (uint8_t *)buf_info->metal_buffer.get()->contents() + buf_info->next_frame_index(_frame_count) * buf_info->size_bytes; } uint64_t RenderingDeviceDriverMetal::buffer_get_dynamic_offsets(Span p_buffers) { @@ -203,14 +194,10 @@ uint64_t RenderingDeviceDriverMetal::buffer_get_dynamic_offsets(Span p return mask; } -void RenderingDeviceDriverMetal::buffer_flush(BufferID p_buffer) { - // Nothing to do. -} - uint64_t RenderingDeviceDriverMetal::buffer_get_device_address(BufferID p_buffer) { - if (@available(iOS 16.0, macOS 13.0, *)) { + if (__builtin_available(iOS 16.0, macOS 13.0, *)) { const BufferInfo *buf_info = (const BufferInfo *)p_buffer.id; - return buf_info->metal_buffer.gpuAddress; + return buf_info->metal_buffer.get()->gpuAddress(); } else { #if DEV_ENABLED WARN_PRINT_ONCE("buffer_get_device_address is not supported on this OS version."); @@ -223,14 +210,14 @@ uint64_t RenderingDeviceDriverMetal::buffer_get_device_address(BufferID p_buffer #pragma mark - Format Conversions -static const MTLTextureType TEXTURE_TYPE[RD::TEXTURE_TYPE_MAX] = { - MTLTextureType1D, - MTLTextureType2D, - MTLTextureType3D, - MTLTextureTypeCube, - MTLTextureType1DArray, - MTLTextureType2DArray, - MTLTextureTypeCubeArray, +static const MTL::TextureType TEXTURE_TYPE[RD::TEXTURE_TYPE_MAX] = { + MTL::TextureType1D, + MTL::TextureType2D, + MTL::TextureType3D, + MTL::TextureTypeCube, + MTL::TextureType1DArray, + MTL::TextureType2DArray, + MTL::TextureTypeCubeArray, }; bool RenderingDeviceDriverMetal::is_valid_linear(TextureFormat const &p_format) const { @@ -244,28 +231,28 @@ bool RenderingDeviceDriverMetal::is_valid_linear(TextureFormat const &p_format) } RDD::TextureID RenderingDeviceDriverMetal::texture_create(const TextureFormat &p_format, const TextureView &p_view) { - MTLTextureDescriptor *desc = [MTLTextureDescriptor new]; - desc.textureType = TEXTURE_TYPE[p_format.texture_type]; + NS::SharedPtr desc = NS::TransferPtr(MTL::TextureDescriptor::alloc()->init()); + desc->setTextureType(TEXTURE_TYPE[p_format.texture_type]); PixelFormats &formats = *pixel_formats; - desc.pixelFormat = formats.getMTLPixelFormat(p_format.format); - MTLFmtCaps format_caps = formats.getCapabilities(desc.pixelFormat); + desc->setPixelFormat((MTL::PixelFormat)formats.getMTLPixelFormat(p_format.format)); + MTLFmtCaps format_caps = formats.getCapabilities(desc->pixelFormat()); - desc.width = p_format.width; - desc.height = p_format.height; - desc.depth = p_format.depth; - desc.mipmapLevelCount = p_format.mipmaps; + desc->setWidth(p_format.width); + desc->setHeight(p_format.height); + desc->setDepth(p_format.depth); + desc->setMipmapLevelCount(p_format.mipmaps); if (p_format.texture_type == TEXTURE_TYPE_1D_ARRAY || p_format.texture_type == TEXTURE_TYPE_2D_ARRAY) { - desc.arrayLength = p_format.array_layers; + desc->setArrayLength(p_format.array_layers); } else if (p_format.texture_type == TEXTURE_TYPE_CUBE_ARRAY) { - desc.arrayLength = p_format.array_layers / 6; + desc->setArrayLength(p_format.array_layers / 6); } // TODO(sgc): Evaluate lossy texture support (perhaps as a project option?) // https://developer.apple.com/videos/play/tech-talks/10876?time=459 - // desc.compressionType = MTLTextureCompressionTypeLossy; + // desc->setCompressionType(MTL::TextureCompressionTypeLossy); if (p_format.samples > TEXTURE_SAMPLES_1) { SampleCount supported = (*device_properties).find_nearest_supported_sample_count(p_format.samples); @@ -275,19 +262,19 @@ RDD::TextureID RenderingDeviceDriverMetal::texture_create(const TextureFormat &p if (ok) { switch (p_format.texture_type) { case TEXTURE_TYPE_2D: - desc.textureType = MTLTextureType2DMultisample; + desc->setTextureType(MTL::TextureType2DMultisample); break; case TEXTURE_TYPE_2D_ARRAY: - desc.textureType = MTLTextureType2DMultisampleArray; + desc->setTextureType(MTL::TextureType2DMultisampleArray); break; default: break; } - desc.sampleCount = (NSUInteger)supported; + desc->setSampleCount((NS::UInteger)supported); if (p_format.mipmaps > 1) { // For a buffer-backed or multi-sample texture, the value must be 1. WARN_PRINT("mipmaps == 1 for multi-sample textures"); - desc.mipmapLevelCount = 1; + desc->setMipmapLevelCount(1); } } else { WARN_PRINT("Unsupported multi-sample texture type; disabling multi-sample"); @@ -295,89 +282,85 @@ RDD::TextureID RenderingDeviceDriverMetal::texture_create(const TextureFormat &p } } - static const MTLTextureSwizzle COMPONENT_SWIZZLE[TEXTURE_SWIZZLE_MAX] = { - static_cast(255), // IDENTITY - MTLTextureSwizzleZero, - MTLTextureSwizzleOne, - MTLTextureSwizzleRed, - MTLTextureSwizzleGreen, - MTLTextureSwizzleBlue, - MTLTextureSwizzleAlpha, + static const MTL::TextureSwizzle COMPONENT_SWIZZLE[TEXTURE_SWIZZLE_MAX] = { + static_cast(255), // IDENTITY + MTL::TextureSwizzleZero, + MTL::TextureSwizzleOne, + MTL::TextureSwizzleRed, + MTL::TextureSwizzleGreen, + MTL::TextureSwizzleBlue, + MTL::TextureSwizzleAlpha, }; - MTLTextureSwizzleChannels swizzle = MTLTextureSwizzleChannelsMake( - p_view.swizzle_r != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_r] : MTLTextureSwizzleRed, - p_view.swizzle_g != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_g] : MTLTextureSwizzleGreen, - p_view.swizzle_b != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_b] : MTLTextureSwizzleBlue, - p_view.swizzle_a != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_a] : MTLTextureSwizzleAlpha); + MTL::TextureSwizzleChannels swizzle = MTL::TextureSwizzleChannels::Make( + p_view.swizzle_r != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_r] : MTL::TextureSwizzleRed, + p_view.swizzle_g != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_g] : MTL::TextureSwizzleGreen, + p_view.swizzle_b != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_b] : MTL::TextureSwizzleBlue, + p_view.swizzle_a != TEXTURE_SWIZZLE_IDENTITY ? COMPONENT_SWIZZLE[p_view.swizzle_a] : MTL::TextureSwizzleAlpha); // Represents a swizzle operation that is a no-op. - static MTLTextureSwizzleChannels IDENTITY_SWIZZLE = { - .red = MTLTextureSwizzleRed, - .green = MTLTextureSwizzleGreen, - .blue = MTLTextureSwizzleBlue, - .alpha = MTLTextureSwizzleAlpha, - }; + static MTL::TextureSwizzleChannels IDENTITY_SWIZZLE = MTL::TextureSwizzleChannels::Default(); - bool no_swizzle = memcmp(&IDENTITY_SWIZZLE, &swizzle, sizeof(MTLTextureSwizzleChannels)) == 0; + bool no_swizzle = memcmp(&IDENTITY_SWIZZLE, &swizzle, sizeof(MTL::TextureSwizzleChannels)) == 0; if (!no_swizzle) { - desc.swizzle = swizzle; + desc->setSwizzle(swizzle); } // Usage. - MTLResourceOptions options = 0; + MTL::ResourceOptions options = 0; bool is_linear = false; #if defined(VISIONOS_ENABLED) const bool supports_memoryless = true; #else GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations") - const bool supports_memoryless = (*device_properties).features.highestFamily >= MTLGPUFamilyApple2 && (*device_properties).features.highestFamily < MTLGPUFamilyMac1; + const bool supports_memoryless = (*device_properties).features.highestFamily >= MTL::GPUFamilyApple2 && (*device_properties).features.highestFamily < MTL::GPUFamilyMac1; GODOT_CLANG_WARNING_POP #endif if (supports_memoryless && p_format.usage_bits & TEXTURE_USAGE_TRANSIENT_BIT) { - options = MTLResourceStorageModeMemoryless | MTLResourceHazardTrackingModeTracked; - desc.storageMode = MTLStorageModeMemoryless; + options = base_hazard_tracking | MTL::ResourceStorageModeMemoryless; + desc->setStorageMode(MTL::StorageModeMemoryless); } else { - options = MTLResourceCPUCacheModeDefaultCache | MTLResourceHazardTrackingModeTracked; + options = base_hazard_tracking | MTL::ResourceCPUCacheModeDefaultCache; if (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) { - options |= MTLResourceStorageModeShared; + options |= MTL::ResourceStorageModeShared; // The user has indicated they want to read from the texture on the CPU, // so we'll see if we can use a linear format. // A linear format is a texture that is backed by a buffer, // which allows for CPU access to the texture data via a pointer. is_linear = is_valid_linear(p_format); } else { - options |= MTLResourceStorageModePrivate; + options |= MTL::ResourceStorageModePrivate; } } - desc.resourceOptions = options; + desc->setResourceOptions(options); + MTL::TextureUsage usage = desc->usage(); if (p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) { - desc.usage |= MTLTextureUsageShaderRead; + usage |= MTL::TextureUsageShaderRead; } if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_BIT) { - desc.usage |= MTLTextureUsageShaderWrite; + usage |= MTL::TextureUsageShaderWrite; } bool can_be_attachment = flags::any(format_caps, (kMTLFmtCapsColorAtt | kMTLFmtCapsDSAtt)); if (flags::any(p_format.usage_bits, TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) && can_be_attachment) { - desc.usage |= MTLTextureUsageRenderTarget; + usage |= MTL::TextureUsageRenderTarget; } if (p_format.usage_bits & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT) { - desc.usage |= MTLTextureUsageShaderRead; + usage |= MTL::TextureUsageShaderRead; } if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_ATOMIC_BIT) { ERR_FAIL_COND_V_MSG((format_caps & kMTLFmtCapsAtomic) == 0, RDD::TextureID(), "Atomic operations on this texture format are not supported."); ERR_FAIL_COND_V_MSG(!device_properties->features.supports_native_image_atomics, RDD::TextureID(), "Atomic operations on textures are not supported on this OS version. Check SUPPORTS_IMAGE_ATOMIC_32_BIT."); // If supports_native_image_atomics is true, this condition should always succeed, as it is set the same. - if (@available(macOS 14.0, iOS 17.0, tvOS 17.0, *)) { - desc.usage |= MTLTextureUsageShaderAtomic; + if (__builtin_available(macOS 14.0, iOS 17.0, tvOS 17.0, *)) { + usage |= MTL::TextureUsageShaderAtomic; } } @@ -388,7 +371,7 @@ RDD::TextureID RenderingDeviceDriverMetal::texture_create(const TextureFormat &p if (flags::any(p_format.usage_bits, TEXTURE_USAGE_CAN_UPDATE_BIT | TEXTURE_USAGE_CAN_COPY_TO_BIT) && can_be_attachment && no_swizzle) { // Per MoltenVK, can be cleared as a render attachment. - desc.usage |= MTLTextureUsageRenderTarget; + usage |= MTL::TextureUsageRenderTarget; } if (p_format.usage_bits & TEXTURE_USAGE_CAN_COPY_FROM_BIT) { // Covered by blits. @@ -396,180 +379,169 @@ RDD::TextureID RenderingDeviceDriverMetal::texture_create(const TextureFormat &p // Create texture views with a different component layout. if (!p_format.shareable_formats.is_empty()) { - desc.usage |= MTLTextureUsagePixelFormatView; + usage |= MTL::TextureUsagePixelFormatView; } + desc->setUsage(usage); + // Allocate memory. - id obj = nil; + MTL::Texture *obj = nullptr; if (is_linear) { // Linear textures are restricted to 2D textures, a single mipmap level and a single array layer. - MTLPixelFormat pixel_format = desc.pixelFormat; + MTL::PixelFormat pixel_format = desc->pixelFormat(); size_t row_alignment = get_texel_buffer_alignment_for_format(p_format.format); size_t bytes_per_row = formats.getBytesPerRow(pixel_format, p_format.width); bytes_per_row = round_up_to_alignment(bytes_per_row, row_alignment); size_t bytes_per_layer = formats.getBytesPerLayer(pixel_format, bytes_per_row, p_format.height); size_t byte_count = bytes_per_layer * p_format.depth * p_format.array_layers; - id buf = [device newBufferWithLength:byte_count options:options]; - obj = [buf newTextureWithDescriptor:desc offset:0 bytesPerRow:bytes_per_row]; + MTL::Buffer *buf = device->newBuffer(byte_count, options); + obj = buf->newTexture(desc.get(), 0, bytes_per_row); + buf->release(); + + _track_resource(buf); } else { - obj = [device newTextureWithDescriptor:desc]; + obj = device->newTexture(desc.get()); } ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create texture."); - return rid::make(obj); + _track_resource(obj); + + return TextureID(reinterpret_cast(obj)); } RDD::TextureID RenderingDeviceDriverMetal::texture_create_from_extension(uint64_t p_native_texture, TextureType p_type, DataFormat p_format, uint32_t p_array_layers, bool p_depth_stencil, uint32_t p_mipmaps) { - id res = (__bridge id)(void *)(uintptr_t)p_native_texture; + MTL::Texture *res = reinterpret_cast(p_native_texture); // If the requested format is different, we need to create a view. - MTLPixelFormat format = pixel_formats->getMTLPixelFormat(p_format); - if (res.pixelFormat != format) { - MTLTextureSwizzleChannels swizzle = MTLTextureSwizzleChannelsMake( - MTLTextureSwizzleRed, - MTLTextureSwizzleGreen, - MTLTextureSwizzleBlue, - MTLTextureSwizzleAlpha); - res = [res newTextureViewWithPixelFormat:format - textureType:res.textureType - levels:NSMakeRange(0, res.mipmapLevelCount) - slices:NSMakeRange(0, p_array_layers) - swizzle:swizzle]; + MTL::PixelFormat format = (MTL::PixelFormat)pixel_formats->getMTLPixelFormat(p_format); + if (res->pixelFormat() != format) { + MTL::TextureSwizzleChannels swizzle = MTL::TextureSwizzleChannels::Default(); + res = res->newTextureView(format, res->textureType(), NS::Range::Make(0, res->mipmapLevelCount()), NS::Range::Make(0, p_array_layers), swizzle); ERR_FAIL_NULL_V_MSG(res, TextureID(), "Unable to create texture view."); } - return rid::make(res); + _track_resource(res); + + return TextureID(reinterpret_cast(res)); } RDD::TextureID RenderingDeviceDriverMetal::texture_create_shared(TextureID p_original_texture, const TextureView &p_view) { - id src_texture = rid::get(p_original_texture); + MTL::Texture *src_texture = reinterpret_cast(p_original_texture.id); - NSUInteger slices = src_texture.arrayLength; - if (src_texture.textureType == MTLTextureTypeCube) { + NS::UInteger slices = src_texture->arrayLength(); + if (src_texture->textureType() == MTL::TextureTypeCube) { // Metal expects Cube textures to have a slice count of 6. slices = 6; - } else if (src_texture.textureType == MTLTextureTypeCubeArray) { + } else if (src_texture->textureType() == MTL::TextureTypeCubeArray) { // Metal expects Cube Array textures to have 6 slices per layer. slices *= 6; } #if DEV_ENABLED - if (src_texture.sampleCount > 1) { + if (src_texture->sampleCount() > 1) { // TODO(sgc): is it ok to create a shared texture from a multi-sample texture? WARN_PRINT("Is it safe to create a shared texture from multi-sample texture?"); } #endif - MTLPixelFormat format = pixel_formats->getMTLPixelFormat(p_view.format); + MTL::PixelFormat format = (MTL::PixelFormat)pixel_formats->getMTLPixelFormat(p_view.format); - static const MTLTextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { - static_cast(255), // IDENTITY - MTLTextureSwizzleZero, - MTLTextureSwizzleOne, - MTLTextureSwizzleRed, - MTLTextureSwizzleGreen, - MTLTextureSwizzleBlue, - MTLTextureSwizzleAlpha, + static const MTL::TextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { + static_cast(255), // IDENTITY + MTL::TextureSwizzleZero, + MTL::TextureSwizzleOne, + MTL::TextureSwizzleRed, + MTL::TextureSwizzleGreen, + MTL::TextureSwizzleBlue, + MTL::TextureSwizzleAlpha, }; -#define SWIZZLE(C, CHAN) (p_view.swizzle_##C != TEXTURE_SWIZZLE_IDENTITY ? component_swizzle[p_view.swizzle_##C] : MTLTextureSwizzle##CHAN) - MTLTextureSwizzleChannels swizzle = MTLTextureSwizzleChannelsMake( - SWIZZLE(r, Red), - SWIZZLE(g, Green), - SWIZZLE(b, Blue), - SWIZZLE(a, Alpha)); +#define SWIZZLE(C, CHAN) (p_view.swizzle_##C != TEXTURE_SWIZZLE_IDENTITY ? component_swizzle[p_view.swizzle_##C] : MTL::TextureSwizzle##CHAN) + MTL::TextureSwizzleChannels swizzle = MTL::TextureSwizzleChannels::Make(SWIZZLE(r, Red), SWIZZLE(g, Green), SWIZZLE(b, Blue), SWIZZLE(a, Alpha)); #undef SWIZZLE - id obj = [src_texture newTextureViewWithPixelFormat:format - textureType:src_texture.textureType - levels:NSMakeRange(0, src_texture.mipmapLevelCount) - slices:NSMakeRange(0, slices) - swizzle:swizzle]; + MTL::Texture *obj = src_texture->newTextureView(format, src_texture->textureType(), NS::Range::Make(0, src_texture->mipmapLevelCount()), NS::Range::Make(0, slices), swizzle); ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create shared texture"); - return rid::make(obj); + _track_resource(obj); + return TextureID(reinterpret_cast(obj)); } RDD::TextureID RenderingDeviceDriverMetal::texture_create_shared_from_slice(TextureID p_original_texture, const TextureView &p_view, TextureSliceType p_slice_type, uint32_t p_layer, uint32_t p_layers, uint32_t p_mipmap, uint32_t p_mipmaps) { - id src_texture = rid::get(p_original_texture); + MTL::Texture *src_texture = reinterpret_cast(p_original_texture.id); - static const MTLTextureType VIEW_TYPES[] = { - MTLTextureType1D, // MTLTextureType1D - MTLTextureType1D, // MTLTextureType1DArray - MTLTextureType2D, // MTLTextureType2D - MTLTextureType2D, // MTLTextureType2DArray - MTLTextureType2D, // MTLTextureType2DMultisample - MTLTextureType2D, // MTLTextureTypeCube - MTLTextureType2D, // MTLTextureTypeCubeArray - MTLTextureType2D, // MTLTextureType3D - MTLTextureType2D, // MTLTextureType2DMultisampleArray + static const MTL::TextureType VIEW_TYPES[] = { + MTL::TextureType1D, // MTLTextureType1D + MTL::TextureType1D, // MTLTextureType1DArray + MTL::TextureType2D, // MTLTextureType2D + MTL::TextureType2D, // MTLTextureType2DArray + MTL::TextureType2D, // MTLTextureType2DMultisample + MTL::TextureType2D, // MTLTextureTypeCube + MTL::TextureType2D, // MTLTextureTypeCubeArray + MTL::TextureType2D, // MTLTextureType3D + MTL::TextureType2D, // MTLTextureType2DMultisampleArray }; - MTLTextureType textureType = VIEW_TYPES[src_texture.textureType]; + MTL::TextureType textureType = VIEW_TYPES[src_texture->textureType()]; switch (p_slice_type) { case TEXTURE_SLICE_2D: { - textureType = MTLTextureType2D; + textureType = MTL::TextureType2D; } break; case TEXTURE_SLICE_3D: { - textureType = MTLTextureType3D; + textureType = MTL::TextureType3D; } break; case TEXTURE_SLICE_CUBEMAP: { - textureType = MTLTextureTypeCube; + textureType = MTL::TextureTypeCube; } break; case TEXTURE_SLICE_2D_ARRAY: { - textureType = MTLTextureType2DArray; + textureType = MTL::TextureType2DArray; } break; case TEXTURE_SLICE_MAX: { ERR_FAIL_V_MSG(TextureID(), "Invalid texture slice type"); } break; } - MTLPixelFormat format = pixel_formats->getMTLPixelFormat(p_view.format); + MTL::PixelFormat format = (MTL::PixelFormat)pixel_formats->getMTLPixelFormat(p_view.format); - static const MTLTextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { - static_cast(255), // IDENTITY - MTLTextureSwizzleZero, - MTLTextureSwizzleOne, - MTLTextureSwizzleRed, - MTLTextureSwizzleGreen, - MTLTextureSwizzleBlue, - MTLTextureSwizzleAlpha, + static const MTL::TextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { + static_cast(255), // IDENTITY + MTL::TextureSwizzleZero, + MTL::TextureSwizzleOne, + MTL::TextureSwizzleRed, + MTL::TextureSwizzleGreen, + MTL::TextureSwizzleBlue, + MTL::TextureSwizzleAlpha, }; -#define SWIZZLE(C, CHAN) (p_view.swizzle_##C != TEXTURE_SWIZZLE_IDENTITY ? component_swizzle[p_view.swizzle_##C] : MTLTextureSwizzle##CHAN) - MTLTextureSwizzleChannels swizzle = MTLTextureSwizzleChannelsMake( - SWIZZLE(r, Red), - SWIZZLE(g, Green), - SWIZZLE(b, Blue), - SWIZZLE(a, Alpha)); +#define SWIZZLE(C, CHAN) (p_view.swizzle_##C != TEXTURE_SWIZZLE_IDENTITY ? component_swizzle[p_view.swizzle_##C] : MTL::TextureSwizzle##CHAN) + MTL::TextureSwizzleChannels swizzle = MTL::TextureSwizzleChannels::Make(SWIZZLE(r, Red), SWIZZLE(g, Green), SWIZZLE(b, Blue), SWIZZLE(a, Alpha)); #undef SWIZZLE - id obj = [src_texture newTextureViewWithPixelFormat:format - textureType:textureType - levels:NSMakeRange(p_mipmap, p_mipmaps) - slices:NSMakeRange(p_layer, p_layers) - swizzle:swizzle]; + MTL::Texture *obj = src_texture->newTextureView(format, textureType, NS::Range::Make(p_mipmap, p_mipmaps), NS::Range::Make(p_layer, p_layers), swizzle); ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create shared texture"); - return rid::make(obj); + _track_resource(obj); + return TextureID(reinterpret_cast(obj)); } void RenderingDeviceDriverMetal::texture_free(TextureID p_texture) { - rid::release(p_texture); + MTL::Texture *obj = reinterpret_cast(p_texture.id); + _untrack_resource(obj); + obj->release(); } uint64_t RenderingDeviceDriverMetal::texture_get_allocation_size(TextureID p_texture) { - id __unsafe_unretained obj = rid::get(p_texture); - return obj.allocatedSize; + MTL::Texture *obj = reinterpret_cast(p_texture.id); + return obj->allocatedSize(); } void RenderingDeviceDriverMetal::texture_get_copyable_layout(TextureID p_texture, const TextureSubresource &p_subresource, TextureCopyableLayout *r_layout) { - id __unsafe_unretained obj = rid::get(p_texture); + MTL::Texture *obj = reinterpret_cast(p_texture.id); PixelFormats &pf = *pixel_formats; - DataFormat format = pf.getDataFormat(obj.pixelFormat); + DataFormat format = pf.getDataFormat(obj->pixelFormat()); - uint32_t w = MAX(1u, obj.width >> p_subresource.mipmap); - uint32_t h = MAX(1u, obj.height >> p_subresource.mipmap); - uint32_t d = MAX(1u, obj.depth >> p_subresource.mipmap); + uint32_t w = MAX(1u, obj->width() >> p_subresource.mipmap); + uint32_t h = MAX(1u, obj->height() >> p_subresource.mipmap); + uint32_t d = MAX(1u, obj->depth() >> p_subresource.mipmap); uint32_t bw = 0, bh = 0; get_compressed_image_format_block_dimensions(format, bw, bh); @@ -581,23 +553,24 @@ void RenderingDeviceDriverMetal::texture_get_copyable_layout(TextureID p_texture } Vector RenderingDeviceDriverMetal::texture_get_data(TextureID p_texture, uint32_t p_layer) { - id obj = rid::get(p_texture); - ERR_FAIL_COND_V_MSG(obj.storageMode != MTLStorageModeShared, Vector(), "Texture must be created with TEXTURE_USAGE_CPU_READ_BIT set."); + MTL::Texture *obj = reinterpret_cast(p_texture.id); + ERR_FAIL_COND_V_MSG(obj->storageMode() != MTL::StorageModeShared, Vector(), "Texture must be created with TEXTURE_USAGE_CPU_READ_BIT set."); - if (obj.buffer) { + MTL::Buffer *buf = obj->buffer(); + if (buf) { ERR_FAIL_COND_V_MSG(p_layer > 0, Vector(), "A linear texture has a single layer."); - ERR_FAIL_COND_V_MSG(obj.mipmapLevelCount > 1, Vector(), "A linear texture has a single mipmap level."); + ERR_FAIL_COND_V_MSG(obj->mipmapLevelCount() > 1, Vector(), "A linear texture has a single mipmap level."); Vector image_data; - image_data.resize_uninitialized(obj.buffer.length); - memcpy(image_data.ptrw(), obj.buffer.contents, obj.buffer.length); + image_data.resize_uninitialized(buf->length()); + memcpy(image_data.ptrw(), buf->contents(), buf->length()); return image_data; } - DataFormat tex_format = pixel_formats->getDataFormat(obj.pixelFormat); - uint32_t tex_w = obj.width; - uint32_t tex_h = obj.height; - uint32_t tex_d = obj.depth; - uint32_t tex_mipmaps = obj.mipmapLevelCount; + DataFormat tex_format = pixel_formats->getDataFormat(obj->pixelFormat()); + uint32_t tex_w = obj->width(); + uint32_t tex_h = obj->height(); + uint32_t tex_d = obj->depth(); + uint32_t tex_mipmaps = obj->mipmapLevelCount(); // Must iteratively copy the texture data to a buffer. @@ -621,12 +594,7 @@ Vector RenderingDeviceDriverMetal::texture_get_data(TextureID p_texture uint32_t bytes_per_img = bytes_per_row * bh; uint32_t mip_size = bytes_per_img * tex_d; - [obj getBytes:(void *)dest_ptr - bytesPerRow:bytes_per_row - bytesPerImage:bytes_per_img - fromRegion:MTLRegionMake3D(0, 0, 0, bw, bh, tex_d) - mipmapLevel:mm_i - slice:p_layer]; + obj->getBytes(dest_ptr, bytes_per_row, bytes_per_img, MTL::Region(0, 0, 0, bw, bh, tex_d), mm_i, p_layer); dest_ptr += mip_size; @@ -644,7 +612,7 @@ Vector RenderingDeviceDriverMetal::texture_get_data(TextureID p_texture BitField RenderingDeviceDriverMetal::texture_get_usages_supported_by_format(DataFormat p_format, bool p_cpu_readable) { PixelFormats &pf = *pixel_formats; - if (pf.getMTLPixelFormat(p_format) == MTLPixelFormatInvalid) { + if (pf.getMTLPixelFormat(p_format) == MTL::PixelFormatInvalid) { return 0; } @@ -677,114 +645,115 @@ bool RenderingDeviceDriverMetal::texture_can_make_shared_with_format(TextureID p #pragma mark - Sampler -static const MTLCompareFunction COMPARE_OPERATORS[RD::COMPARE_OP_MAX] = { - MTLCompareFunctionNever, - MTLCompareFunctionLess, - MTLCompareFunctionEqual, - MTLCompareFunctionLessEqual, - MTLCompareFunctionGreater, - MTLCompareFunctionNotEqual, - MTLCompareFunctionGreaterEqual, - MTLCompareFunctionAlways, +static const MTL::CompareFunction COMPARE_OPERATORS[RD::COMPARE_OP_MAX] = { + MTL::CompareFunctionNever, + MTL::CompareFunctionLess, + MTL::CompareFunctionEqual, + MTL::CompareFunctionLessEqual, + MTL::CompareFunctionGreater, + MTL::CompareFunctionNotEqual, + MTL::CompareFunctionGreaterEqual, + MTL::CompareFunctionAlways, }; -static const MTLStencilOperation STENCIL_OPERATIONS[RD::STENCIL_OP_MAX] = { - MTLStencilOperationKeep, - MTLStencilOperationZero, - MTLStencilOperationReplace, - MTLStencilOperationIncrementClamp, - MTLStencilOperationDecrementClamp, - MTLStencilOperationInvert, - MTLStencilOperationIncrementWrap, - MTLStencilOperationDecrementWrap, +static const MTL::StencilOperation STENCIL_OPERATIONS[RD::STENCIL_OP_MAX] = { + MTL::StencilOperationKeep, + MTL::StencilOperationZero, + MTL::StencilOperationReplace, + MTL::StencilOperationIncrementClamp, + MTL::StencilOperationDecrementClamp, + MTL::StencilOperationInvert, + MTL::StencilOperationIncrementWrap, + MTL::StencilOperationDecrementWrap, }; -static const MTLBlendFactor BLEND_FACTORS[RD::BLEND_FACTOR_MAX] = { - MTLBlendFactorZero, - MTLBlendFactorOne, - MTLBlendFactorSourceColor, - MTLBlendFactorOneMinusSourceColor, - MTLBlendFactorDestinationColor, - MTLBlendFactorOneMinusDestinationColor, - MTLBlendFactorSourceAlpha, - MTLBlendFactorOneMinusSourceAlpha, - MTLBlendFactorDestinationAlpha, - MTLBlendFactorOneMinusDestinationAlpha, - MTLBlendFactorBlendColor, - MTLBlendFactorOneMinusBlendColor, - MTLBlendFactorBlendAlpha, - MTLBlendFactorOneMinusBlendAlpha, - MTLBlendFactorSourceAlphaSaturated, - MTLBlendFactorSource1Color, - MTLBlendFactorOneMinusSource1Color, - MTLBlendFactorSource1Alpha, - MTLBlendFactorOneMinusSource1Alpha, +static const MTL::BlendFactor BLEND_FACTORS[RD::BLEND_FACTOR_MAX] = { + MTL::BlendFactorZero, + MTL::BlendFactorOne, + MTL::BlendFactorSourceColor, + MTL::BlendFactorOneMinusSourceColor, + MTL::BlendFactorDestinationColor, + MTL::BlendFactorOneMinusDestinationColor, + MTL::BlendFactorSourceAlpha, + MTL::BlendFactorOneMinusSourceAlpha, + MTL::BlendFactorDestinationAlpha, + MTL::BlendFactorOneMinusDestinationAlpha, + MTL::BlendFactorBlendColor, + MTL::BlendFactorOneMinusBlendColor, + MTL::BlendFactorBlendAlpha, + MTL::BlendFactorOneMinusBlendAlpha, + MTL::BlendFactorSourceAlphaSaturated, + MTL::BlendFactorSource1Color, + MTL::BlendFactorOneMinusSource1Color, + MTL::BlendFactorSource1Alpha, + MTL::BlendFactorOneMinusSource1Alpha, }; -static const MTLBlendOperation BLEND_OPERATIONS[RD::BLEND_OP_MAX] = { - MTLBlendOperationAdd, - MTLBlendOperationSubtract, - MTLBlendOperationReverseSubtract, - MTLBlendOperationMin, - MTLBlendOperationMax, +static const MTL::BlendOperation BLEND_OPERATIONS[RD::BLEND_OP_MAX] = { + MTL::BlendOperationAdd, + MTL::BlendOperationSubtract, + MTL::BlendOperationReverseSubtract, + MTL::BlendOperationMin, + MTL::BlendOperationMax, }; -static const API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MTLSamplerAddressMode ADDRESS_MODES[RD::SAMPLER_REPEAT_MODE_MAX] = { - MTLSamplerAddressModeRepeat, - MTLSamplerAddressModeMirrorRepeat, - MTLSamplerAddressModeClampToEdge, - MTLSamplerAddressModeClampToBorderColor, - MTLSamplerAddressModeMirrorClampToEdge, +static const MTL::SamplerAddressMode ADDRESS_MODES[RD::SAMPLER_REPEAT_MODE_MAX] = { + MTL::SamplerAddressModeRepeat, + MTL::SamplerAddressModeMirrorRepeat, + MTL::SamplerAddressModeClampToEdge, + MTL::SamplerAddressModeClampToBorderColor, + MTL::SamplerAddressModeMirrorClampToEdge, }; -static const API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MTLSamplerBorderColor SAMPLER_BORDER_COLORS[RD::SAMPLER_BORDER_COLOR_MAX] = { - MTLSamplerBorderColorTransparentBlack, - MTLSamplerBorderColorTransparentBlack, - MTLSamplerBorderColorOpaqueBlack, - MTLSamplerBorderColorOpaqueBlack, - MTLSamplerBorderColorOpaqueWhite, - MTLSamplerBorderColorOpaqueWhite, +static const MTL::SamplerBorderColor SAMPLER_BORDER_COLORS[RD::SAMPLER_BORDER_COLOR_MAX] = { + MTL::SamplerBorderColorTransparentBlack, + MTL::SamplerBorderColorTransparentBlack, + MTL::SamplerBorderColorOpaqueBlack, + MTL::SamplerBorderColorOpaqueBlack, + MTL::SamplerBorderColorOpaqueWhite, + MTL::SamplerBorderColorOpaqueWhite, }; RDD::SamplerID RenderingDeviceDriverMetal::sampler_create(const SamplerState &p_state) { - MTLSamplerDescriptor *desc = [MTLSamplerDescriptor new]; - desc.supportArgumentBuffers = YES; + NS::SharedPtr desc = NS::TransferPtr(MTL::SamplerDescriptor::alloc()->init()); + desc->setSupportArgumentBuffers(true); - desc.magFilter = p_state.mag_filter == SAMPLER_FILTER_LINEAR ? MTLSamplerMinMagFilterLinear : MTLSamplerMinMagFilterNearest; - desc.minFilter = p_state.min_filter == SAMPLER_FILTER_LINEAR ? MTLSamplerMinMagFilterLinear : MTLSamplerMinMagFilterNearest; - desc.mipFilter = p_state.mip_filter == SAMPLER_FILTER_LINEAR ? MTLSamplerMipFilterLinear : MTLSamplerMipFilterNearest; + desc->setMagFilter(p_state.mag_filter == SAMPLER_FILTER_LINEAR ? MTL::SamplerMinMagFilterLinear : MTL::SamplerMinMagFilterNearest); + desc->setMinFilter(p_state.min_filter == SAMPLER_FILTER_LINEAR ? MTL::SamplerMinMagFilterLinear : MTL::SamplerMinMagFilterNearest); + desc->setMipFilter(p_state.mip_filter == SAMPLER_FILTER_LINEAR ? MTL::SamplerMipFilterLinear : MTL::SamplerMipFilterNearest); - desc.sAddressMode = ADDRESS_MODES[p_state.repeat_u]; - desc.tAddressMode = ADDRESS_MODES[p_state.repeat_v]; - desc.rAddressMode = ADDRESS_MODES[p_state.repeat_w]; + desc->setSAddressMode(ADDRESS_MODES[p_state.repeat_u]); + desc->setTAddressMode(ADDRESS_MODES[p_state.repeat_v]); + desc->setRAddressMode(ADDRESS_MODES[p_state.repeat_w]); if (p_state.use_anisotropy) { - desc.maxAnisotropy = p_state.anisotropy_max; + desc->setMaxAnisotropy(p_state.anisotropy_max); } - desc.compareFunction = COMPARE_OPERATORS[p_state.compare_op]; + desc->setCompareFunction(COMPARE_OPERATORS[p_state.compare_op]); - desc.lodMinClamp = p_state.min_lod; - desc.lodMaxClamp = p_state.max_lod; + desc->setLodMinClamp(p_state.min_lod); + desc->setLodMaxClamp(p_state.max_lod); - desc.borderColor = SAMPLER_BORDER_COLORS[p_state.border_color]; + desc->setBorderColor(SAMPLER_BORDER_COLORS[p_state.border_color]); - desc.normalizedCoordinates = !p_state.unnormalized_uvw; + desc->setNormalizedCoordinates(!p_state.unnormalized_uvw); #if __MAC_OS_X_VERSION_MAX_ALLOWED >= 260000 || __IPHONE_OS_VERSION_MAX_ALLOWED >= 260000 || __TV_OS_VERSION_MAX_ALLOWED >= 260000 || __VISION_OS_VERSION_MAX_ALLOWED >= 260000 if (p_state.lod_bias != 0.0) { - if (@available(macOS 26.0, iOS 26.0, tvOS 26.0, visionOS 26.0, *)) { - desc.lodBias = p_state.lod_bias; + if (__builtin_available(macOS 26.0, iOS 26.0, tvOS 26.0, visionOS 26.0, *)) { + desc->setLodBias(p_state.lod_bias); } } #endif - id obj = [device newSamplerStateWithDescriptor:desc]; - ERR_FAIL_NULL_V_MSG(obj, SamplerID(), "newSamplerStateWithDescriptor failed"); - return rid::make(obj); + MTL::SamplerState *obj = device->newSamplerState(desc.get()); + ERR_FAIL_NULL_V_MSG(obj, SamplerID(), "newSamplerState failed"); + return SamplerID(reinterpret_cast(obj)); } void RenderingDeviceDriverMetal::sampler_free(SamplerID p_sampler) { - rid::release(p_sampler); + MTL::SamplerState *obj = reinterpret_cast(p_sampler.id); + obj->release(); } bool RenderingDeviceDriverMetal::sampler_is_format_supported_for_filter(DataFormat p_format, SamplerFilter p_filter) { @@ -801,40 +770,43 @@ bool RenderingDeviceDriverMetal::sampler_is_format_supported_for_filter(DataForm #pragma mark - Vertex Array RDD::VertexFormatID RenderingDeviceDriverMetal::vertex_format_create(Span p_vertex_attribs, const VertexAttributeBindingsMap &p_vertex_bindings) { - MTLVertexDescriptor *desc = MTLVertexDescriptor.vertexDescriptor; + MTL::VertexDescriptor *desc = MTL::VertexDescriptor::vertexDescriptor(); for (const VertexAttributeBindingsMap::KV &kv : p_vertex_bindings) { uint32_t idx = get_metal_buffer_index_for_vertex_attribute_binding(kv.key); - MTLVertexBufferLayoutDescriptor *ld = desc.layouts[idx]; + MTL::VertexBufferLayoutDescriptor *ld = desc->layouts()->object(idx); if (kv.value.stride != 0) { - ld.stepFunction = kv.value.frequency == VERTEX_FREQUENCY_VERTEX ? MTLVertexStepFunctionPerVertex : MTLVertexStepFunctionPerInstance; - ld.stepRate = 1; - ld.stride = kv.value.stride; + ld->setStepFunction(kv.value.frequency == VERTEX_FREQUENCY_VERTEX ? MTL::VertexStepFunctionPerVertex : MTL::VertexStepFunctionPerInstance); + ld->setStepRate(1); + ld->setStride(kv.value.stride); } else { - ld.stepFunction = MTLVertexStepFunctionConstant; - ld.stepRate = 0; - ld.stride = 0; + ld->setStepFunction(MTL::VertexStepFunctionConstant); + ld->setStepRate(0); + ld->setStride(0); } - DEV_ASSERT(ld.stride == desc.layouts[idx].stride); + DEV_ASSERT(ld->stride() == desc->layouts()->object(idx)->stride()); } for (const VertexAttribute &vf : p_vertex_attribs) { - desc.attributes[vf.location].format = pixel_formats->getMTLVertexFormat(vf.format); - desc.attributes[vf.location].offset = vf.offset; + MTL::VertexAttributeDescriptor *attr = desc->attributes()->object(vf.location); + attr->setFormat((MTL::VertexFormat)pixel_formats->getMTLVertexFormat(vf.format)); + attr->setOffset(vf.offset); uint32_t idx = get_metal_buffer_index_for_vertex_attribute_binding(vf.binding); - desc.attributes[vf.location].bufferIndex = idx; + attr->setBufferIndex(idx); if (vf.stride == 0) { // Constant attribute, so we must determine the stride to satisfy Metal API. - uint32_t stride = desc.layouts[idx].stride; - desc.layouts[idx].stride = std::max(stride, vf.offset + pixel_formats->getBytesPerBlock(vf.format)); + uint32_t stride = desc->layouts()->object(idx)->stride(); + desc->layouts()->object(idx)->setStride(std::max(stride, vf.offset + pixel_formats->getBytesPerBlock(vf.format))); } } - return rid::make(desc); + desc->retain(); + return VertexFormatID(reinterpret_cast(desc)); } void RenderingDeviceDriverMetal::vertex_format_free(VertexFormatID p_vertex_format) { - rid::release(p_vertex_format); + MTL::VertexDescriptor *obj = reinterpret_cast(p_vertex_format.id); + obj->release(); } #pragma mark - Barriers @@ -847,39 +819,8 @@ void RenderingDeviceDriverMetal::command_pipeline_barrier( VectorView p_buffer_barriers, VectorView p_texture_barriers, VectorView p_acceleration_structure_barriers) { - WARN_PRINT_ONCE("not implemented"); -} - -#pragma mark - Fences - -RDD::FenceID RenderingDeviceDriverMetal::fence_create() { - Fence *fence = nullptr; - if (@available(macOS 10.14, iOS 12.0, tvOS 12.0, visionOS 1.0, *)) { - fence = memnew(FenceEvent([device newSharedEvent])); - } else { - fence = memnew(FenceSemaphore()); - } - return FenceID(fence); -} - -Error RenderingDeviceDriverMetal::fence_wait(FenceID p_fence) { - Fence *fence = (Fence *)(p_fence.id); - return fence->wait(1000); -} - -void RenderingDeviceDriverMetal::fence_free(FenceID p_fence) { - Fence *fence = (Fence *)(p_fence.id); - memdelete(fence); -} - -#pragma mark - Semaphores - -RDD::SemaphoreID RenderingDeviceDriverMetal::semaphore_create() { - // Metal doesn't use semaphores, as their purpose within Godot is to ensure ordering of command buffer execution. - return SemaphoreID(1); -} - -void RenderingDeviceDriverMetal::semaphore_free(SemaphoreID p_semaphore) { + MDCommandBufferBase *obj = (MDCommandBufferBase *)(p_cmd_buffer.id); + obj->pipeline_barrier(p_src_stages, p_dst_stages, p_memory_barriers, p_buffer_barriers, p_texture_barriers, p_acceleration_structure_barriers); } #pragma mark - Queues @@ -896,78 +837,10 @@ RDD::CommandQueueFamilyID RenderingDeviceDriverMetal::command_queue_family_get(B } } -RDD::CommandQueueID RenderingDeviceDriverMetal::command_queue_create(CommandQueueFamilyID p_cmd_queue_family, bool p_identify_as_main_queue) { - return CommandQueueID(1); -} - -Error RenderingDeviceDriverMetal::command_queue_execute_and_present(CommandQueueID p_cmd_queue, VectorView, VectorView p_cmd_buffers, VectorView, FenceID p_cmd_fence, VectorView p_swap_chains) { - uint32_t size = p_cmd_buffers.size(); - if (size == 0) { - return OK; - } - - for (uint32_t i = 0; i < size - 1; i++) { - MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[i].id); - cmd_buffer->commit(); - } - - // The last command buffer will signal the fence and semaphores. - MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[size - 1].id); - Fence *fence = (Fence *)(p_cmd_fence.id); - if (fence != nullptr) { - cmd_buffer->end(); - id cb = cmd_buffer->get_command_buffer(); - fence->signal(cb); - } - - for (uint32_t i = 0; i < p_swap_chains.size(); i++) { - SwapChain *swap_chain = (SwapChain *)(p_swap_chains[i].id); - RenderingContextDriverMetal::Surface *metal_surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); - metal_surface->present(cmd_buffer); - } - - cmd_buffer->commit(); - - if (p_swap_chains.size() > 0) { - // Used as a signal that we're presenting, so this is the end of a frame. - [device_scope endScope]; - [device_scope beginScope]; - } - - return OK; -} - -void RenderingDeviceDriverMetal::command_queue_free(CommandQueueID p_cmd_queue) { -} - #pragma mark - Command Buffers -// ----- POOL ----- - -RDD::CommandPoolID RenderingDeviceDriverMetal::command_pool_create(CommandQueueFamilyID p_cmd_queue_family, CommandBufferType p_cmd_buffer_type) { - DEV_ASSERT(p_cmd_buffer_type == COMMAND_BUFFER_TYPE_PRIMARY); - return rid::make(device_queue); -} - -bool RenderingDeviceDriverMetal::command_pool_reset(CommandPoolID p_cmd_pool) { - return true; -} - -void RenderingDeviceDriverMetal::command_pool_free(CommandPoolID p_cmd_pool) { - rid::release(p_cmd_pool); -} - -// ----- BUFFER ----- - -RDD::CommandBufferID RenderingDeviceDriverMetal::command_buffer_create(CommandPoolID p_cmd_pool) { - id queue = rid::get(p_cmd_pool); - MDCommandBuffer *obj = new MDCommandBuffer(queue, this); - command_buffers.push_back(obj); - return CommandBufferID(obj); -} - bool RenderingDeviceDriverMetal::command_buffer_begin(CommandBufferID p_cmd_buffer) { - MDCommandBuffer *obj = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *obj = (MDCommandBufferBase *)(p_cmd_buffer.id); obj->begin(); return true; } @@ -977,7 +850,7 @@ bool RenderingDeviceDriverMetal::command_buffer_begin_secondary(CommandBufferID } void RenderingDeviceDriverMetal::command_buffer_end(CommandBufferID p_cmd_buffer) { - MDCommandBuffer *obj = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *obj = (MDCommandBufferBase *)(p_cmd_buffer.id); obj->end(); } @@ -996,6 +869,11 @@ void RenderingDeviceDriverMetal::_swap_chain_release_buffers(SwapChain *p_swap_c RDD::SwapChainID RenderingDeviceDriverMetal::swap_chain_create(RenderingContextDriver::SurfaceID p_surface) { RenderingContextDriverMetal::Surface const *surface = (RenderingContextDriverMetal::Surface *)(p_surface); + if (use_barriers) { + GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") + add_residency_set_to_main_queue(surface->get_residency_set()); + GODOT_CLANG_WARNING_POP + } // Create the render pass that will be used to draw to the swap chain's framebuffers. RDD::Attachment attachment; @@ -1067,6 +945,12 @@ void RenderingDeviceDriverMetal::swap_chain_set_max_fps(SwapChainID p_swap_chain void RenderingDeviceDriverMetal::swap_chain_free(SwapChainID p_swap_chain) { SwapChain *swap_chain = (SwapChain *)(p_swap_chain.id); + if (use_barriers) { + GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") + RenderingContextDriverMetal::Surface *surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); + remove_residency_set_to_main_queue(surface->get_residency_set()); + GODOT_CLANG_WARNING_POP + } _swap_chain_release(swap_chain); render_pass_free(swap_chain->render_pass); memdelete(swap_chain); @@ -1077,34 +961,34 @@ void RenderingDeviceDriverMetal::swap_chain_free(SwapChainID p_swap_chain) { RDD::FramebufferID RenderingDeviceDriverMetal::framebuffer_create(RenderPassID p_render_pass, VectorView p_attachments, uint32_t p_width, uint32_t p_height) { MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); - Vector textures; + Vector textures; textures.resize(p_attachments.size()); for (uint32_t i = 0; i < p_attachments.size(); i += 1) { MDAttachment const &a = pass->attachments[i]; - id tex = rid::get(p_attachments[i]); - if (tex == nil) { + MTL::Texture *tex = reinterpret_cast(p_attachments[i].id); + if (tex == nullptr) { #if DEV_ENABLED WARN_PRINT("Invalid texture for attachment " + itos(i)); #endif } if (a.samples > 1) { - if (tex.sampleCount != a.samples) { + if (tex->sampleCount() != a.samples) { #if DEV_ENABLED - WARN_PRINT("Mismatched sample count for attachment " + itos(i) + "; expected " + itos(a.samples) + ", got " + itos(tex.sampleCount)); + WARN_PRINT("Mismatched sample count for attachment " + itos(i) + "; expected " + itos(a.samples) + ", got " + itos(tex->sampleCount())); #endif } } textures.write[i] = tex; } - MDFrameBuffer *fb = new MDFrameBuffer(textures, Size2i(p_width, p_height)); + MDFrameBuffer *fb = memnew(MDFrameBuffer(textures, Size2i(p_width, p_height))); return FramebufferID(fb); } void RenderingDeviceDriverMetal::framebuffer_free(FramebufferID p_framebuffer) { MDFrameBuffer *obj = (MDFrameBuffer *)(p_framebuffer.id); - delete obj; + memdelete(obj); } #pragma mark - Shader @@ -1113,7 +997,7 @@ void RenderingDeviceDriverMetal::shader_cache_free_entry(const SHA256Digest &key if (ShaderCacheEntry **pentry = _shader_cache.getptr(key); pentry != nullptr) { ShaderCacheEntry *entry = *pentry; _shader_cache.erase(key); - entry->library = nil; + entry->library.reset(); memdelete(entry); } } @@ -1130,12 +1014,12 @@ static_assert(is_layout_compatible(p_data.data_type); + r_ui.dataType = static_cast(p_data.data_type); memcpy(&r_ui.slot, &p_data.slot, sizeof(UniformInfo::Indexes)); memcpy(&r_ui.arg_buffer, &p_data.arg_buffer, sizeof(UniformInfo::Indexes)); - r_ui.access = static_cast(p_data.access); - r_ui.usage = static_cast(p_data.usage); - r_ui.textureType = static_cast(p_data.texture_type); + r_ui.access = static_cast(p_data.access); + r_ui.usage = static_cast(p_data.usage); + r_ui.textureType = static_cast(p_data.texture_type); r_ui.imageFormat = p_data.image_format; r_ui.arrayLength = p_data.array_length; r_ui.isMultisampled = p_data.is_multisampled; @@ -1159,20 +1043,20 @@ RDD::ShaderID RenderingDeviceDriverMetal::shader_create_from_container(const Ref RDD::ShaderID(), "Shader was compiled for a newer version of Metal"); - MTLGPUFamily compiled_gpu_family = static_cast(mtl_reflection_data.profile.gpu); + MTL::GPUFamily compiled_gpu_family = static_cast(mtl_reflection_data.profile.gpu); ERR_FAIL_COND_V_MSG(device_properties->features.highestFamily < compiled_gpu_family, RDD::ShaderID(), "Shader was generated for a newer Apple GPU"); - MTLCompileOptions *options = [MTLCompileOptions new]; + NS::SharedPtr options = NS::TransferPtr(MTL::CompileOptions::alloc()->init()); uint32_t major = mtl_reflection_data.msl_version / 10000; uint32_t minor = (mtl_reflection_data.msl_version / 100) % 100; - options.languageVersion = MTLLanguageVersion((major << 0x10) + minor); - if (@available(macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 2.0, *)) { - options.enableLogging = mtl_reflection_data.needs_debug_logging(); + options->setLanguageVersion(MTL::LanguageVersion((major << 0x10) + minor)); + if (__builtin_available(macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 2.0, *)) { + options->setEnableLogging(mtl_reflection_data.needs_debug_logging()); } - HashMap libraries; + HashMap> libraries; PipelineType pipeline_type = PIPELINE_TYPE_RASTERIZATION; Vector decompressed_code; @@ -1185,8 +1069,12 @@ RDD::ShaderID RenderingDeviceDriverMetal::shader_create_from_container(const Ref } if (ShaderCacheEntry **p = _shader_cache.getptr(shader_data.hash); p != nullptr) { - libraries[shader.shader_stage] = (*p)->library; - continue; + if (std::shared_ptr lib = (*p)->library.lock()) { + libraries[shader.shader_stage] = lib; + continue; + } + // Library was released; remove stale cache entry and recreate. + _shader_cache.erase(shader_data.hash); } if (shader.code_decompressed_size > 0) { @@ -1201,34 +1089,27 @@ RDD::ShaderID RenderingDeviceDriverMetal::shader_create_from_container(const Ref cd->name = shader_name; cd->stage = shader.shader_stage; - NSString *source = [[NSString alloc] initWithBytes:(void *)decompressed_code.ptr() - length:shader_data.source_size - encoding:NSUTF8StringEncoding]; + NS::SharedPtr source = NS::TransferPtr(NS::String::alloc()->init((void *)decompressed_code.ptr(), shader_data.source_size, NS::UTF8StringEncoding)); - MDLibrary *library = nil; + std::shared_ptr library; if (shader_data.library_size > 0) { ERR_FAIL_COND_V_MSG(mtl_reflection_data.os_min_version > device_properties->os_version, RDD::ShaderID(), "Metal shader binary was generated for a newer target OS"); dispatch_data_t binary = dispatch_data_create(decompressed_code.ptr() + shader_data.source_size, shader_data.library_size, dispatch_get_main_queue(), DISPATCH_DATA_DESTRUCTOR_DEFAULT); - library = [MDLibrary newLibraryWithCacheEntry:cd - device:device + library = MDLibrary::create(cd, device, #if DEV_ENABLED - source:source + source.get(), #endif - data:binary]; + binary); } else { - options.preserveInvariance = shader_data.is_position_invariant; + options->setPreserveInvariance(shader_data.is_position_invariant); #if __MAC_OS_X_VERSION_MIN_REQUIRED >= 150000 || __IPHONE_OS_VERSION_MIN_REQUIRED >= 180000 || __TV_OS_VERSION_MIN_REQUIRED >= 180000 || defined(VISIONOS_ENABLED) - options.mathMode = MTLMathModeFast; + options->setMathMode(MTL::MathModeFast); #else - options.fastMathEnabled = YES; + options->setFastMathEnabled(true); #endif - library = [MDLibrary newLibraryWithCacheEntry:cd - device:device - source:source - options:options - strategy:_shader_load_strategy]; + library = MDLibrary::create(cd, device, source.get(), options.get(), _shader_load_strategy); } _shader_cache[shader_data.hash] = cd; @@ -1300,7 +1181,7 @@ RDD::ShaderID RenderingDeviceDriverMetal::shader_create_from_container(const Ref mtl_reflection_data.uses_argument_buffers(), libraries[RD::ShaderStage::SHADER_STAGE_COMPUTE]); - cs->local = MTLSizeMake(refl.compute_local_size[0], refl.compute_local_size[1], refl.compute_local_size[2]); + cs->local = MTL::Size(refl.compute_local_size[0], refl.compute_local_size[1], refl.compute_local_size[2]); shader = cs; } else { MDRenderShader *rs = new MDRenderShader( @@ -1341,16 +1222,20 @@ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorViewsets.size(), UniformSetID(), "Set index out of range"); const UniformSet &shader_set = shader->sets.get(p_set_index); MDUniformSet *set = memnew(MDUniformSet); + // Determine if there are any dynamic uniforms in this set. + bool is_dynamic = !shader_set.dynamic_uniforms.is_empty(); + + Vector arg_buffer_data; if (device_properties->features.argument_buffers_supported()) { + arg_buffer_data.resize(shader_set.buffer_size); + // If argument buffers are enabled, we have already verified availability, so we can skip the runtime check. GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability-new") + uint64_t *ptr = (uint64_t *)arg_buffer_data.ptrw(); - set->arg_buffer = [device newBufferWithLength:shader_set.buffer_size options:MTLResourceStorageModeShared]; - uint64_t *ptr = (uint64_t *)set->arg_buffer.contents; - - HashMap bound_resources; - auto add_usage = [&bound_resources](MTLResourceUnsafe res, BitField stage, MTLResourceUsage usage) { + HashMap bound_resources; + auto add_usage = [&bound_resources](MTL::Resource *res, BitField stage, MTL::ResourceUsage usage) { StageResourceUsage *sru = bound_resources.getptr(res); if (sru == nullptr) { sru = &bound_resources.insert(res, ResourceUnused)->value; @@ -1365,6 +1250,10 @@ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorView sampler = rid::get(uniform.ids[j]); - *(MTLResourceID *)(ptr + idx.sampler + j) = sampler.gpuResourceID; + MTL::SamplerState *sampler = reinterpret_cast(uniform.ids[j].id); + *(MTL::ResourceID *)(ptr + idx.sampler + j) = sampler->gpuResourceID(); } } break; case UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: { uint32_t count = uniform.ids.size() / 2; for (uint32_t j = 0; j < count; j += 1) { - id sampler = rid::get(uniform.ids[j * 2 + 0]); - id texture = rid::get(uniform.ids[j * 2 + 1]); - *(MTLResourceID *)(ptr + idx.texture + j) = texture.gpuResourceID; - *(MTLResourceID *)(ptr + idx.sampler + j) = sampler.gpuResourceID; + MTL::SamplerState *sampler = reinterpret_cast(uniform.ids[j * 2 + 0].id); + MTL::Texture *texture = reinterpret_cast(uniform.ids[j * 2 + 1].id); + *(MTL::ResourceID *)(ptr + idx.texture + j) = texture->gpuResourceID(); + *(MTL::ResourceID *)(ptr + idx.sampler + j) = sampler->gpuResourceID(); - add_usage(texture, ui.active_stages, ui.usage); + ADD_USAGE(texture, ui.active_stages, ui.usage); } } break; case UNIFORM_TYPE_TEXTURE: { size_t count = uniform.ids.size(); for (size_t j = 0; j < count; j += 1) { - id texture = rid::get(uniform.ids[j]); - *(MTLResourceID *)(ptr + idx.texture + j) = texture.gpuResourceID; + MTL::Texture *texture = reinterpret_cast(uniform.ids[j].id); + *(MTL::ResourceID *)(ptr + idx.texture + j) = texture->gpuResourceID(); - add_usage(texture, ui.active_stages, ui.usage); + ADD_USAGE(texture, ui.active_stages, ui.usage); } } break; case UNIFORM_TYPE_IMAGE: { size_t count = uniform.ids.size(); for (size_t j = 0; j < count; j += 1) { - id texture = rid::get(uniform.ids[j]); - *(MTLResourceID *)(ptr + idx.texture + j) = texture.gpuResourceID; - add_usage(texture, ui.active_stages, ui.usage); + MTL::Texture *texture = reinterpret_cast(uniform.ids[j].id); + *(MTL::ResourceID *)(ptr + idx.texture + j) = texture->gpuResourceID(); + ADD_USAGE(texture, ui.active_stages, ui.usage); if (idx.buffer != UINT32_MAX) { // Emulated atomic image access. - id buffer = (texture.parentTexture ? texture.parentTexture : texture).buffer; - *(MTLGPUAddress *)(ptr + idx.buffer + j) = buffer.gpuAddress; + MTL::Texture *parent = texture->parentTexture(); + MTL::Buffer *buffer = (parent ? parent : texture)->buffer(); + *(MTLGPUAddress *)(ptr + idx.buffer + j) = buffer->gpuAddress(); - add_usage(buffer, ui.active_stages, ui.usage); + ADD_USAGE(buffer, ui.active_stages, ui.usage); } } } break; @@ -1429,23 +1319,26 @@ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorViewmetal_buffer.gpuAddress; + *(MTLGPUAddress *)(ptr + idx.buffer) = buffer->metal_buffer.get()->gpuAddress(); - add_usage(buffer->metal_buffer, ui.active_stages, ui.usage); + ADD_USAGE(buffer->metal_buffer.get(), ui.active_stages, ui.usage); } break; case UNIFORM_TYPE_INPUT_ATTACHMENT: { size_t count = uniform.ids.size(); for (size_t j = 0; j < count; j += 1) { - id texture = rid::get(uniform.ids[j]); - *(MTLResourceID *)(ptr + idx.texture + j) = texture.gpuResourceID; + MTL::Texture *texture = reinterpret_cast(uniform.ids[j].id); + *(MTL::ResourceID *)(ptr + idx.texture + j) = texture->gpuResourceID(); - add_usage(texture, ui.active_stages, ui.usage); + ADD_USAGE(texture, ui.active_stages, ui.usage); } } break; case UNIFORM_TYPE_UNIFORM_BUFFER_DYNAMIC: case UNIFORM_TYPE_STORAGE_BUFFER_DYNAMIC: { - // Dynamic buffers are not supported by argument buffers currently. - // so we do not encode them, as there shouldn't be any runtime shaders that used them. + // Encode the base GPU address (frame 0); it will be updated at bind time. + const MetalBufferDynamicInfo *buffer = (const MetalBufferDynamicInfo *)uniform.ids[0].id; + *(MTLGPUAddress *)(ptr + idx.buffer) = buffer->metal_buffer.get()->gpuAddress(); + + ADD_USAGE(buffer->metal_buffer.get(), ui.active_stages, ui.usage); } break; default: { DEV_ASSERT(false); @@ -1453,17 +1346,36 @@ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorView const &keyval : bound_resources) { - ResourceVector *resources = set->usage_to_resources.getptr(keyval.value); - if (resources == nullptr) { - resources = &set->usage_to_resources.insert(keyval.value, ResourceVector())->value; - } - int64_t pos = resources->span().bisect(keyval.key, true); - if (pos == resources->size() || (*resources)[pos] != keyval.key) { - resources->insert(pos, keyval.key); +#undef ADD_USAGE + + if (!use_barriers) { + for (KeyValue const &keyval : bound_resources) { + ResourceVector *resources = set->usage_to_resources.getptr(keyval.value); + if (resources == nullptr) { + resources = &set->usage_to_resources.insert(keyval.value, ResourceVector())->value; + } + int64_t pos = resources->span().bisect(keyval.key, true); + if (pos == resources->size() || (*resources)[pos] != keyval.key) { + resources->insert(pos, keyval.key); + } } } + if (!is_dynamic) { + set->arg_buffer = NS::TransferPtr(device->newBuffer(shader_set.buffer_size, base_hazard_tracking | MTL::ResourceStorageModePrivate)); +#if DEV_ENABLED + char label[64]; + snprintf(label, sizeof(label), "Uniform Set %u", p_set_index); + set->arg_buffer->setLabel(NS::String::string(label, NS::UTF8StringEncoding)); +#endif + _track_resource(set->arg_buffer.get()); + _copy_queue_copy_to_buffer(arg_buffer_data, set->arg_buffer.get()); + } else { + // Store the arg buffer data for dynamic uniform sets. + // It will be copied and updated at bind time. + set->arg_buffer_data = arg_buffer_data; + } + GODOT_CLANG_WARNING_POP } Vector bound_uniforms; @@ -1472,13 +1384,15 @@ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorViewuniforms = bound_uniforms; - set->index = p_set_index; return UniformSetID(set); } void RenderingDeviceDriverMetal::uniform_set_free(UniformSetID p_uniform_set) { MDUniformSet *obj = (MDUniformSet *)p_uniform_set.id; + if (obj->arg_buffer) { + _untrack_resource(obj->arg_buffer.get()); + } memdelete(obj); } @@ -1520,42 +1434,42 @@ void RenderingDeviceDriverMetal::command_uniform_set_prepare_for_use(CommandBuff #pragma mark - Transfer void RenderingDeviceDriverMetal::command_clear_buffer(CommandBufferID p_cmd_buffer, BufferID p_buffer, uint64_t p_offset, uint64_t p_size) { - MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cmd = (MDCommandBufferBase *)(p_cmd_buffer.id); cmd->clear_buffer(p_buffer, p_offset, p_size); } void RenderingDeviceDriverMetal::command_copy_buffer(CommandBufferID p_cmd_buffer, BufferID p_src_buffer, BufferID p_dst_buffer, VectorView p_regions) { - MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cmd = (MDCommandBufferBase *)(p_cmd_buffer.id); cmd->copy_buffer(p_src_buffer, p_dst_buffer, p_regions); } void RenderingDeviceDriverMetal::command_copy_texture(CommandBufferID p_cmd_buffer, TextureID p_src_texture, TextureLayout p_src_texture_layout, TextureID p_dst_texture, TextureLayout p_dst_texture_layout, VectorView p_regions) { - MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cmd = (MDCommandBufferBase *)(p_cmd_buffer.id); cmd->copy_texture(p_src_texture, p_dst_texture, p_regions); } void RenderingDeviceDriverMetal::command_resolve_texture(CommandBufferID p_cmd_buffer, TextureID p_src_texture, TextureLayout p_src_texture_layout, uint32_t p_src_layer, uint32_t p_src_mipmap, TextureID p_dst_texture, TextureLayout p_dst_texture_layout, uint32_t p_dst_layer, uint32_t p_dst_mipmap) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->resolve_texture(p_src_texture, p_src_texture_layout, p_src_layer, p_src_mipmap, p_dst_texture, p_dst_texture_layout, p_dst_layer, p_dst_mipmap); } void RenderingDeviceDriverMetal::command_clear_color_texture(CommandBufferID p_cmd_buffer, TextureID p_texture, TextureLayout p_texture_layout, const Color &p_color, const TextureSubresourceRange &p_subresources) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->clear_color_texture(p_texture, p_texture_layout, p_color, p_subresources); } void RenderingDeviceDriverMetal::command_clear_depth_stencil_texture(CommandBufferID p_cmd_buffer, TextureID p_texture, TextureLayout p_texture_layout, float p_depth, uint8_t p_stencil, const TextureSubresourceRange &p_subresources) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->clear_depth_stencil_texture(p_texture, p_texture_layout, p_depth, p_stencil, p_subresources); } void RenderingDeviceDriverMetal::command_copy_buffer_to_texture(CommandBufferID p_cmd_buffer, BufferID p_src_buffer, TextureID p_dst_texture, TextureLayout p_dst_texture_layout, VectorView p_regions) { - MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cmd = (MDCommandBufferBase *)(p_cmd_buffer.id); cmd->copy_buffer_to_texture(p_src_buffer, p_dst_texture, p_regions); } void RenderingDeviceDriverMetal::command_copy_texture_to_buffer(CommandBufferID p_cmd_buffer, TextureID p_src_texture, TextureLayout p_src_texture_layout, BufferID p_dst_buffer, VectorView p_regions) { - MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cmd = (MDCommandBufferBase *)(p_cmd_buffer.id); cmd->copy_texture_to_buffer(p_src_texture, p_dst_buffer, p_regions); } @@ -1569,7 +1483,7 @@ void RenderingDeviceDriverMetal::pipeline_free(PipelineID p_pipeline_id) { // ----- BINDING ----- void RenderingDeviceDriverMetal::command_bind_push_constants(CommandBufferID p_cmd_buffer, ShaderID p_shader, uint32_t p_dst_first_index, VectorView p_data) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->encode_push_constant_data(p_shader, p_data); } @@ -1588,22 +1502,16 @@ String RenderingDeviceDriverMetal::_pipeline_get_cache_path() const { bool RenderingDeviceDriverMetal::pipeline_cache_create(const Vector &p_data) { return false; - CharString path = _pipeline_get_cache_path().utf8(); - NSString *nPath = [[NSString alloc] initWithBytesNoCopy:path.ptrw() - length:path.length() - encoding:NSUTF8StringEncoding - freeWhenDone:NO]; - MTLBinaryArchiveDescriptor *desc = [MTLBinaryArchiveDescriptor new]; - if ([[NSFileManager defaultManager] fileExistsAtPath:nPath]) { - desc.url = [NSURL fileURLWithPath:nPath]; - } - NSError *error = nil; - archive = [device newBinaryArchiveWithDescriptor:desc error:&error]; - return true; + // TODO: Convert to metal-cpp when pipeline caching is re-enabled + // CharString path = _pipeline_get_cache_path().utf8(); + // NS::SharedPtr desc = NS::TransferPtr(MTL::BinaryArchiveDescriptor::alloc()->init()); + // NS::Error *error = nullptr; + // archive = NS::TransferPtr(device->newBinaryArchive(desc.get(), &error)); + // return true; } void RenderingDeviceDriverMetal::pipeline_cache_free() { - archive = nil; + archive = nullptr; } size_t RenderingDeviceDriverMetal::pipeline_cache_query_size() { @@ -1615,20 +1523,17 @@ Vector RenderingDeviceDriverMetal::pipeline_cache_serialize() { return Vector(); } - CharString path = _pipeline_get_cache_path().utf8(); - - NSString *nPath = [[NSString alloc] initWithBytesNoCopy:path.ptrw() - length:path.length() - encoding:NSUTF8StringEncoding - freeWhenDone:NO]; - NSURL *target = [NSURL fileURLWithPath:nPath]; - NSError *error = nil; - if ([archive serializeToURL:target error:&error]) { - return Vector(); - } else { - print_line(error.localizedDescription.UTF8String); - return Vector(); - } + // TODO: Convert to metal-cpp when pipeline caching is re-enabled + // CharString path = _pipeline_get_cache_path().utf8(); + // NS::URL *target = NS::URL::fileURLWithPath(NS::String::string(path.get_data(), NS::UTF8StringEncoding)); + // NS::Error *error = nullptr; + // if (archive->serializeToURL(target, &error)) { + // return Vector(); + // } else { + // print_line(error->localizedDescription()->utf8String()); + // return Vector(); + // } + return Vector(); } #pragma mark - Rendering @@ -1652,15 +1557,15 @@ RDD::RenderPassID RenderingDeviceDriverMetal::render_pass_create(VectorView attachments; @@ -1669,7 +1574,7 @@ RDD::RenderPassID RenderingDeviceDriverMetal::render_pass_create(VectorView TEXTURE_SAMPLES_1) { mda.samples = (*device_properties).find_nearest_supported_sample_count(a.samples); @@ -1690,99 +1595,99 @@ RDD::RenderPassID RenderingDeviceDriverMetal::render_pass_create(VectorView p_clear_values) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_begin_pass(p_render_pass, p_framebuffer, p_cmd_buffer_type, p_rect, p_clear_values); } void RenderingDeviceDriverMetal::command_end_render_pass(CommandBufferID p_cmd_buffer) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_end_pass(); } void RenderingDeviceDriverMetal::command_next_render_subpass(CommandBufferID p_cmd_buffer, CommandBufferType p_cmd_buffer_type) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_next_subpass(); } void RenderingDeviceDriverMetal::command_render_set_viewport(CommandBufferID p_cmd_buffer, VectorView p_viewports) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_set_viewport(p_viewports); } void RenderingDeviceDriverMetal::command_render_set_scissor(CommandBufferID p_cmd_buffer, VectorView p_scissors) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_set_scissor(p_scissors); } void RenderingDeviceDriverMetal::command_render_clear_attachments(CommandBufferID p_cmd_buffer, VectorView p_attachment_clears, VectorView p_rects) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_clear_attachments(p_attachment_clears, p_rects); } void RenderingDeviceDriverMetal::command_bind_render_pipeline(CommandBufferID p_cmd_buffer, PipelineID p_pipeline) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->bind_pipeline(p_pipeline); } void RenderingDeviceDriverMetal::command_bind_render_uniform_sets(CommandBufferID p_cmd_buffer, VectorView p_uniform_sets, ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_bind_uniform_sets(p_uniform_sets, p_shader, p_first_set_index, p_set_count, p_dynamic_offsets); } void RenderingDeviceDriverMetal::command_render_draw(CommandBufferID p_cmd_buffer, uint32_t p_vertex_count, uint32_t p_instance_count, uint32_t p_base_vertex, uint32_t p_first_instance) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw(p_vertex_count, p_instance_count, p_base_vertex, p_first_instance); } void RenderingDeviceDriverMetal::command_render_draw_indexed(CommandBufferID p_cmd_buffer, uint32_t p_index_count, uint32_t p_instance_count, uint32_t p_first_index, int32_t p_vertex_offset, uint32_t p_first_instance) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw_indexed(p_index_count, p_instance_count, p_first_index, p_vertex_offset, p_first_instance); } void RenderingDeviceDriverMetal::command_render_draw_indexed_indirect(CommandBufferID p_cmd_buffer, BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw_indexed_indirect(p_indirect_buffer, p_offset, p_draw_count, p_stride); } void RenderingDeviceDriverMetal::command_render_draw_indexed_indirect_count(CommandBufferID p_cmd_buffer, BufferID p_indirect_buffer, uint64_t p_offset, BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw_indexed_indirect_count(p_indirect_buffer, p_offset, p_count_buffer, p_count_buffer_offset, p_max_draw_count, p_stride); } void RenderingDeviceDriverMetal::command_render_draw_indirect(CommandBufferID p_cmd_buffer, BufferID p_indirect_buffer, uint64_t p_offset, uint32_t p_draw_count, uint32_t p_stride) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw_indirect(p_indirect_buffer, p_offset, p_draw_count, p_stride); } void RenderingDeviceDriverMetal::command_render_draw_indirect_count(CommandBufferID p_cmd_buffer, BufferID p_indirect_buffer, uint64_t p_offset, BufferID p_count_buffer, uint64_t p_count_buffer_offset, uint32_t p_max_draw_count, uint32_t p_stride) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_draw_indirect_count(p_indirect_buffer, p_offset, p_count_buffer, p_count_buffer_offset, p_max_draw_count, p_stride); } void RenderingDeviceDriverMetal::command_render_bind_vertex_buffers(CommandBufferID p_cmd_buffer, uint32_t p_binding_count, const BufferID *p_buffers, const uint64_t *p_offsets, uint64_t p_dynamic_offsets) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_bind_vertex_buffers(p_binding_count, p_buffers, p_offsets, p_dynamic_offsets); } void RenderingDeviceDriverMetal::command_render_bind_index_buffer(CommandBufferID p_cmd_buffer, BufferID p_buffer, IndexBufferFormat p_format, uint64_t p_offset) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_bind_index_buffer(p_buffer, p_format, p_offset); } void RenderingDeviceDriverMetal::command_render_set_blend_constants(CommandBufferID p_cmd_buffer, const Color &p_constants) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->render_set_blend_constants(p_constants); } @@ -1794,119 +1699,123 @@ void RenderingDeviceDriverMetal::command_render_set_line_width(CommandBufferID p // ----- PIPELINE ----- -RenderingDeviceDriverMetal::Result> RenderingDeviceDriverMetal::_create_function(MDLibrary *p_library, NSString *p_name, VectorView &p_specialization_constants) { - id library = p_library.library; +RenderingDeviceDriverMetal::Result> RenderingDeviceDriverMetal::_create_function(MDLibrary *p_library, NS::String *p_name, VectorView &p_specialization_constants) { + MTL::Library *library = p_library->get_library(); if (!library) { ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Failed to compile Metal library"); } - id function = [library newFunctionWithName:p_name]; + MTL::Function *function = library->newFunction(p_name); ERR_FAIL_NULL_V_MSG(function, ERR_CANT_CREATE, "No function named main0"); - if (function.functionConstantsDictionary.count == 0) { - return function; + NS::Dictionary *constants_dict = function->functionConstantsDictionary(); + if (constants_dict->count() == 0) { + return NS::TransferPtr(function); } - NSArray *constants = function.functionConstantsDictionary.allValues; + LocalVector constants; + NS::Enumerator *keys = constants_dict->keyEnumerator(); + while (NS::String *key = keys->nextObject()) { + constants.push_back(constants_dict->object(key)); + } + + // Check if already sorted by index. bool is_sorted = true; - for (uint32_t i = 1; i < constants.count; i++) { - if (constants[i - 1].index > constants[i].index) { + for (NS::UInteger i = 1; i < constants.size(); i++) { + MTL::FunctionConstant *prev = constants[i - 1]; + MTL::FunctionConstant *curr = constants[i]; + if (prev->index() > curr->index()) { is_sorted = false; break; } } if (!is_sorted) { - constants = [constants sortedArrayUsingComparator:^NSComparisonResult(MTLFunctionConstant *a, MTLFunctionConstant *b) { - if (a.index < b.index) { - return NSOrderedAscending; - } else if (a.index > b.index) { - return NSOrderedDescending; - } else { - return NSOrderedSame; + struct Comparator { + bool operator()(const MTL::FunctionConstant *p, const MTL::FunctionConstant *q) const { + return p->index() < q->index(); } - }]; + }; + + constants.sort_custom(); } - // Initialize an array of integers representing the indexes of p_specialization_constants + // Build a sorted list of specialization constants by constant_id. uint32_t *indexes = (uint32_t *)alloca(p_specialization_constants.size() * sizeof(uint32_t)); for (uint32_t i = 0; i < p_specialization_constants.size(); i++) { indexes[i] = i; } - // Sort the array of integers based on the values in p_specialization_constants std::sort(indexes, &indexes[p_specialization_constants.size()], [&](int a, int b) { return p_specialization_constants[a].constant_id < p_specialization_constants[b].constant_id; }); - MTLFunctionConstantValues *constantValues = [MTLFunctionConstantValues new]; - uint32_t i = 0; + NS::SharedPtr constantValues = NS::TransferPtr(MTL::FunctionConstantValues::alloc()->init()); + + // Merge the sorted constants from the function with the sorted user constants. + NS::UInteger i = 0; uint32_t j = 0; - while (i < constants.count && j < p_specialization_constants.size()) { - MTLFunctionConstant *curr = constants[i]; + while (i < constants.size() && j < p_specialization_constants.size()) { + MTL::FunctionConstant *curr = (MTL::FunctionConstant *)constants[i]; PipelineSpecializationConstant const &sc = p_specialization_constants[indexes[j]]; - if (curr.index == sc.constant_id) { - switch (curr.type) { - case MTLDataTypeBool: - case MTLDataTypeFloat: - case MTLDataTypeInt: - case MTLDataTypeUInt: { - [constantValues setConstantValue:&sc.int_value - type:curr.type - atIndex:sc.constant_id]; + if (curr->index() == sc.constant_id) { + switch (curr->type()) { + case MTL::DataTypeBool: + case MTL::DataTypeFloat: + case MTL::DataTypeInt: + case MTL::DataTypeUInt: { + constantValues->setConstantValue(&sc.int_value, curr->type(), sc.constant_id); } break; default: - ERR_FAIL_V_MSG(function, "Invalid specialization constant type"); + ERR_FAIL_V_MSG(NS::TransferPtr(function), "Invalid specialization constant type"); } i++; j++; - } else if (curr.index < sc.constant_id) { + } else if (curr->index() < sc.constant_id) { i++; } else { j++; } } - if (i != constants.count) { - MTLFunctionConstant *curr = constants[i]; - if (curr.index == R32UI_ALIGNMENT_CONSTANT_ID) { + // Handle R32UI_ALIGNMENT_CONSTANT_ID if present. + if (i < constants.size()) { + MTL::FunctionConstant *curr = constants[i]; + if (curr->index() == R32UI_ALIGNMENT_CONSTANT_ID) { uint32_t alignment = 16; // TODO(sgc): is this always correct? - [constantValues setConstantValue:&alignment - type:curr.type - atIndex:curr.index]; + constantValues->setConstantValue(&alignment, curr->type(), curr->index()); i++; } } - NSError *err = nil; - function = [library newFunctionWithName:@"main0" - constantValues:constantValues - error:&err]; - ERR_FAIL_NULL_V_MSG(function, ERR_CANT_CREATE, String("specialized function failed: ") + err.localizedDescription.UTF8String); + NS::Error *err = nullptr; + function->release(); + function = library->newFunction(p_name, constantValues.get(), &err); + ERR_FAIL_NULL_V_MSG(function, ERR_CANT_CREATE, String("specialized function failed: ") + (err ? err->localizedDescription()->utf8String() : "unknown error")); - return function; + return NS::TransferPtr(function); } -// RDD::PolygonCullMode == MTLCullMode. -static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_DISABLED, MTLCullModeNone)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_FRONT, MTLCullModeFront)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_BACK, MTLCullModeBack)); +// RDD::PolygonCullMode == MTL::CullMode. +static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_DISABLED, MTL::CullModeNone)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_FRONT, MTL::CullModeFront)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::POLYGON_CULL_BACK, MTL::CullModeBack)); -// RDD::StencilOperation == MTLStencilOperation. -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_KEEP, MTLStencilOperationKeep)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_ZERO, MTLStencilOperationZero)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_REPLACE, MTLStencilOperationReplace)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INCREMENT_AND_CLAMP, MTLStencilOperationIncrementClamp)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_DECREMENT_AND_CLAMP, MTLStencilOperationDecrementClamp)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INVERT, MTLStencilOperationInvert)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INCREMENT_AND_WRAP, MTLStencilOperationIncrementWrap)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_DECREMENT_AND_WRAP, MTLStencilOperationDecrementWrap)); +// RDD::StencilOperation == MTL::StencilOperation. +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_KEEP, MTL::StencilOperationKeep)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_ZERO, MTL::StencilOperationZero)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_REPLACE, MTL::StencilOperationReplace)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INCREMENT_AND_CLAMP, MTL::StencilOperationIncrementClamp)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_DECREMENT_AND_CLAMP, MTL::StencilOperationDecrementClamp)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INVERT, MTL::StencilOperationInvert)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_INCREMENT_AND_WRAP, MTL::StencilOperationIncrementWrap)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::STENCIL_OP_DECREMENT_AND_WRAP, MTL::StencilOperationDecrementWrap)); -// RDD::BlendOperation == MTLBlendOperation. -static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_ADD, MTLBlendOperationAdd)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_SUBTRACT, MTLBlendOperationSubtract)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_REVERSE_SUBTRACT, MTLBlendOperationReverseSubtract)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_MINIMUM, MTLBlendOperationMin)); -static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_MAXIMUM, MTLBlendOperationMax)); +// RDD::BlendOperation == MTL::BlendOperation. +static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_ADD, MTL::BlendOperationAdd)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_SUBTRACT, MTL::BlendOperationSubtract)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_REVERSE_SUBTRACT, MTL::BlendOperationReverseSubtract)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_MINIMUM, MTL::BlendOperationMin)); +static_assert(ENUM_MEMBERS_EQUAL(RDD::BLEND_OP_MAXIMUM, MTL::BlendOperationMax)); RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( ShaderID p_shader, @@ -1922,7 +1831,7 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( uint32_t p_render_subpass, VectorView p_specialization_constants) { MDRenderShader *shader = (MDRenderShader *)(p_shader.id); - MTLVertexDescriptor *vert_desc = rid::get(p_vertex_format); + MTL::VertexDescriptor *vert_desc = reinterpret_cast(p_vertex_format.id); MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); os_signpost_id_t reflect_id = os_signpost_id_make_with_pointer(LOG_INTERVALS, shader); @@ -1933,7 +1842,7 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( os_signpost_event_emit(LOG_DRIVER, OS_SIGNPOST_ID_EXCLUSIVE, "create_pipeline"); - MTLRenderPipelineDescriptor *desc = [MTLRenderPipelineDescriptor new]; + NS::SharedPtr desc = NS::TransferPtr(MTL::RenderPipelineDescriptor::alloc()->init()); { MDSubpass const &subpass = pass->subpasses[p_render_subpass]; @@ -1941,7 +1850,7 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( uint32_t attachment = subpass.color_references[i].attachment; if (attachment != AttachmentReference::UNUSED) { MDAttachment const &a = pass->attachments[attachment]; - desc.colorAttachments[i].pixelFormat = a.format; + desc->colorAttachments()->object(i)->setPixelFormat(a.format); } } @@ -1950,17 +1859,27 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( MDAttachment const &a = pass->attachments[attachment]; if (a.type & MDAttachmentType::Depth) { - desc.depthAttachmentPixelFormat = a.format; + desc->setDepthAttachmentPixelFormat(a.format); } if (a.type & MDAttachmentType::Stencil) { - desc.stencilAttachmentPixelFormat = a.format; + desc->setStencilAttachmentPixelFormat(a.format); } } } - desc.vertexDescriptor = vert_desc; - desc.label = [NSString stringWithUTF8String:shader->name.get_data()]; + desc->setVertexDescriptor(vert_desc); + desc->setLabel(conv::to_nsstring(shader->name)); + + if (shader->uses_argument_buffers) { + // Set mutability of argument buffers. + for (uint32_t i = 0; i < shader->sets.size(); i++) { + const UniformSet &set = shader->sets[i]; + const MTL::Mutability mutability = set.dynamic_uniforms.is_empty() ? MTL::MutabilityImmutable : MTL::MutabilityMutable; + desc->vertexBuffers()->object(i)->setMutability(mutability); + desc->fragmentBuffers()->object(i)->setMutability(mutability); + } + } // Input assembly & tessellation. @@ -1968,69 +1887,69 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( switch (p_render_primitive) { case RENDER_PRIMITIVE_POINTS: - desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassPoint; + desc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassPoint); break; case RENDER_PRIMITIVE_LINES: case RENDER_PRIMITIVE_LINES_WITH_ADJACENCY: case RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY: case RENDER_PRIMITIVE_LINESTRIPS: - desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassLine; + desc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassLine); break; case RENDER_PRIMITIVE_TRIANGLES: case RENDER_PRIMITIVE_TRIANGLE_STRIPS: case RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY: case RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY: case RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX: - desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassTriangle; + desc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassTriangle); break; case RENDER_PRIMITIVE_TESSELATION_PATCH: - desc.maxTessellationFactor = p_rasterization_state.patch_control_points; - desc.tessellationPartitionMode = MTLTessellationPartitionModeInteger; + desc->setMaxTessellationFactor(p_rasterization_state.patch_control_points); + desc->setTessellationPartitionMode(MTL::TessellationPartitionModeInteger); ERR_FAIL_V_MSG(PipelineID(), "tessellation not implemented"); break; case RENDER_PRIMITIVE_MAX: default: - desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassUnspecified; + desc->setInputPrimitiveTopology(MTL::PrimitiveTopologyClassUnspecified); break; } switch (p_render_primitive) { case RENDER_PRIMITIVE_POINTS: - pipeline->raster_state.render_primitive = MTLPrimitiveTypePoint; + pipeline->raster_state.render_primitive = MTL::PrimitiveTypePoint; break; case RENDER_PRIMITIVE_LINES: case RENDER_PRIMITIVE_LINES_WITH_ADJACENCY: - pipeline->raster_state.render_primitive = MTLPrimitiveTypeLine; + pipeline->raster_state.render_primitive = MTL::PrimitiveTypeLine; break; case RENDER_PRIMITIVE_LINESTRIPS: case RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY: - pipeline->raster_state.render_primitive = MTLPrimitiveTypeLineStrip; + pipeline->raster_state.render_primitive = MTL::PrimitiveTypeLineStrip; break; case RENDER_PRIMITIVE_TRIANGLES: case RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY: - pipeline->raster_state.render_primitive = MTLPrimitiveTypeTriangle; + pipeline->raster_state.render_primitive = MTL::PrimitiveTypeTriangle; break; case RENDER_PRIMITIVE_TRIANGLE_STRIPS: case RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_AJACENCY: case RENDER_PRIMITIVE_TRIANGLE_STRIPS_WITH_RESTART_INDEX: - pipeline->raster_state.render_primitive = MTLPrimitiveTypeTriangleStrip; + pipeline->raster_state.render_primitive = MTL::PrimitiveTypeTriangleStrip; break; default: break; } // Rasterization. - desc.rasterizationEnabled = !p_rasterization_state.discard_primitives; - pipeline->raster_state.clip_mode = p_rasterization_state.enable_depth_clamp ? MTLDepthClipModeClamp : MTLDepthClipModeClip; - pipeline->raster_state.fill_mode = p_rasterization_state.wireframe ? MTLTriangleFillModeLines : MTLTriangleFillModeFill; + desc->setRasterizationEnabled(!p_rasterization_state.discard_primitives); + pipeline->raster_state.clip_mode = p_rasterization_state.enable_depth_clamp ? MTL::DepthClipModeClamp : MTL::DepthClipModeClip; + pipeline->raster_state.fill_mode = p_rasterization_state.wireframe ? MTL::TriangleFillModeLines : MTL::TriangleFillModeFill; - static const MTLCullMode CULL_MODE[3] = { - MTLCullModeNone, - MTLCullModeFront, - MTLCullModeBack, + static const MTL::CullMode CULL_MODE[3] = { + MTL::CullModeNone, + MTL::CullModeFront, + MTL::CullModeBack, }; pipeline->raster_state.cull_mode = CULL_MODE[p_rasterization_state.cull_mode]; - pipeline->raster_state.winding = (p_rasterization_state.front_face == POLYGON_FRONT_FACE_CLOCKWISE) ? MTLWindingClockwise : MTLWindingCounterClockwise; + pipeline->raster_state.winding = (p_rasterization_state.front_face == POLYGON_FRONT_FACE_CLOCKWISE) ? MTL::WindingClockwise : MTL::WindingCounterClockwise; pipeline->raster_state.depth_bias.enabled = p_rasterization_state.depth_bias_enabled; pipeline->raster_state.depth_bias.depth_bias = p_rasterization_state.depth_bias_constant_factor; pipeline->raster_state.depth_bias.slope_scale = p_rasterization_state.depth_bias_slope_factor; @@ -2048,20 +1967,20 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( if (p_multisample_state.sample_count > TEXTURE_SAMPLES_1) { pipeline->sample_count = (*device_properties).find_nearest_supported_sample_count(p_multisample_state.sample_count); } - desc.rasterSampleCount = static_cast(pipeline->sample_count); - desc.alphaToCoverageEnabled = p_multisample_state.enable_alpha_to_coverage; - desc.alphaToOneEnabled = p_multisample_state.enable_alpha_to_one; + desc->setRasterSampleCount(static_cast(pipeline->sample_count)); + desc->setAlphaToCoverageEnabled(p_multisample_state.enable_alpha_to_coverage); + desc->setAlphaToOneEnabled(p_multisample_state.enable_alpha_to_one); // Depth buffer. - bool depth_enabled = p_depth_stencil_state.enable_depth_test && desc.depthAttachmentPixelFormat != MTLPixelFormatInvalid; - bool stencil_enabled = p_depth_stencil_state.enable_stencil && desc.stencilAttachmentPixelFormat != MTLPixelFormatInvalid; + bool depth_enabled = p_depth_stencil_state.enable_depth_test && desc->depthAttachmentPixelFormat() != MTL::PixelFormatInvalid; + bool stencil_enabled = p_depth_stencil_state.enable_stencil && desc->stencilAttachmentPixelFormat() != MTL::PixelFormatInvalid; if (depth_enabled || stencil_enabled) { - MTLDepthStencilDescriptor *ds_desc = [MTLDepthStencilDescriptor new]; + NS::SharedPtr ds_desc = NS::TransferPtr(MTL::DepthStencilDescriptor::alloc()->init()); pipeline->raster_state.depth_test.enabled = depth_enabled; - ds_desc.depthWriteEnabled = p_depth_stencil_state.enable_depth_write; - ds_desc.depthCompareFunction = COMPARE_OPERATORS[p_depth_stencil_state.depth_compare_operator]; + ds_desc->setDepthWriteEnabled(p_depth_stencil_state.enable_depth_write); + ds_desc->setDepthCompareFunction(COMPARE_OPERATORS[p_depth_stencil_state.depth_compare_operator]); if (p_depth_stencil_state.enable_depth_range) { WARN_PRINT("unsupported: depth range"); } @@ -2073,33 +1992,33 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( { // Front. - MTLStencilDescriptor *sd = [MTLStencilDescriptor new]; - sd.stencilFailureOperation = STENCIL_OPERATIONS[p_depth_stencil_state.front_op.fail]; - sd.depthStencilPassOperation = STENCIL_OPERATIONS[p_depth_stencil_state.front_op.pass]; - sd.depthFailureOperation = STENCIL_OPERATIONS[p_depth_stencil_state.front_op.depth_fail]; - sd.stencilCompareFunction = COMPARE_OPERATORS[p_depth_stencil_state.front_op.compare]; - sd.readMask = p_depth_stencil_state.front_op.compare_mask; - sd.writeMask = p_depth_stencil_state.front_op.write_mask; - ds_desc.frontFaceStencil = sd; + NS::SharedPtr sd = NS::TransferPtr(MTL::StencilDescriptor::alloc()->init()); + sd->setStencilFailureOperation(STENCIL_OPERATIONS[p_depth_stencil_state.front_op.fail]); + sd->setDepthStencilPassOperation(STENCIL_OPERATIONS[p_depth_stencil_state.front_op.pass]); + sd->setDepthFailureOperation(STENCIL_OPERATIONS[p_depth_stencil_state.front_op.depth_fail]); + sd->setStencilCompareFunction(COMPARE_OPERATORS[p_depth_stencil_state.front_op.compare]); + sd->setReadMask(p_depth_stencil_state.front_op.compare_mask); + sd->setWriteMask(p_depth_stencil_state.front_op.write_mask); + ds_desc->setFrontFaceStencil(sd.get()); } { // Back. - MTLStencilDescriptor *sd = [MTLStencilDescriptor new]; - sd.stencilFailureOperation = STENCIL_OPERATIONS[p_depth_stencil_state.back_op.fail]; - sd.depthStencilPassOperation = STENCIL_OPERATIONS[p_depth_stencil_state.back_op.pass]; - sd.depthFailureOperation = STENCIL_OPERATIONS[p_depth_stencil_state.back_op.depth_fail]; - sd.stencilCompareFunction = COMPARE_OPERATORS[p_depth_stencil_state.back_op.compare]; - sd.readMask = p_depth_stencil_state.back_op.compare_mask; - sd.writeMask = p_depth_stencil_state.back_op.write_mask; - ds_desc.backFaceStencil = sd; + NS::SharedPtr sd = NS::TransferPtr(MTL::StencilDescriptor::alloc()->init()); + sd->setStencilFailureOperation(STENCIL_OPERATIONS[p_depth_stencil_state.back_op.fail]); + sd->setDepthStencilPassOperation(STENCIL_OPERATIONS[p_depth_stencil_state.back_op.pass]); + sd->setDepthFailureOperation(STENCIL_OPERATIONS[p_depth_stencil_state.back_op.depth_fail]); + sd->setStencilCompareFunction(COMPARE_OPERATORS[p_depth_stencil_state.back_op.compare]); + sd->setReadMask(p_depth_stencil_state.back_op.compare_mask); + sd->setWriteMask(p_depth_stencil_state.back_op.write_mask); + ds_desc->setBackFaceStencil(sd.get()); } } - pipeline->depth_stencil = [device newDepthStencilStateWithDescriptor:ds_desc]; - ERR_FAIL_NULL_V_MSG(pipeline->depth_stencil, PipelineID(), "Failed to create depth stencil state"); + pipeline->depth_stencil = NS::TransferPtr(device->newDepthStencilState(ds_desc.get())); + ERR_FAIL_COND_V_MSG(!pipeline->depth_stencil, PipelineID(), "Failed to create depth stencil state"); } else { // TODO(sgc): FB13671991 raised as Apple docs state calling setDepthStencilState:nil is valid, but currently generates an exception - pipeline->depth_stencil = get_resource_cache().get_depth_stencil_state(false, false); + pipeline->depth_stencil = NS::RetainPtr(get_resource_cache().get_depth_stencil_state(false, false)); } // Blend state. @@ -2111,30 +2030,31 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( const PipelineColorBlendState::Attachment &bs = p_blend_state.attachments[i]; - MTLRenderPipelineColorAttachmentDescriptor *ca_desc = desc.colorAttachments[p_color_attachments[i]]; - ca_desc.blendingEnabled = bs.enable_blend; + MTL::RenderPipelineColorAttachmentDescriptor *ca_desc = desc->colorAttachments()->object(p_color_attachments[i]); + ca_desc->setBlendingEnabled(bs.enable_blend); - ca_desc.sourceRGBBlendFactor = BLEND_FACTORS[bs.src_color_blend_factor]; - ca_desc.destinationRGBBlendFactor = BLEND_FACTORS[bs.dst_color_blend_factor]; - ca_desc.rgbBlendOperation = BLEND_OPERATIONS[bs.color_blend_op]; + ca_desc->setSourceRGBBlendFactor(BLEND_FACTORS[bs.src_color_blend_factor]); + ca_desc->setDestinationRGBBlendFactor(BLEND_FACTORS[bs.dst_color_blend_factor]); + ca_desc->setRgbBlendOperation(BLEND_OPERATIONS[bs.color_blend_op]); - ca_desc.sourceAlphaBlendFactor = BLEND_FACTORS[bs.src_alpha_blend_factor]; - ca_desc.destinationAlphaBlendFactor = BLEND_FACTORS[bs.dst_alpha_blend_factor]; - ca_desc.alphaBlendOperation = BLEND_OPERATIONS[bs.alpha_blend_op]; + ca_desc->setSourceAlphaBlendFactor(BLEND_FACTORS[bs.src_alpha_blend_factor]); + ca_desc->setDestinationAlphaBlendFactor(BLEND_FACTORS[bs.dst_alpha_blend_factor]); + ca_desc->setAlphaBlendOperation(BLEND_OPERATIONS[bs.alpha_blend_op]); - ca_desc.writeMask = MTLColorWriteMaskNone; + MTL::ColorWriteMask writeMask = MTL::ColorWriteMaskNone; if (bs.write_r) { - ca_desc.writeMask |= MTLColorWriteMaskRed; + writeMask |= MTL::ColorWriteMaskRed; } if (bs.write_g) { - ca_desc.writeMask |= MTLColorWriteMaskGreen; + writeMask |= MTL::ColorWriteMaskGreen; } if (bs.write_b) { - ca_desc.writeMask |= MTLColorWriteMaskBlue; + writeMask |= MTL::ColorWriteMaskBlue; } if (bs.write_a) { - ca_desc.writeMask |= MTLColorWriteMaskAlpha; + writeMask |= MTL::ColorWriteMaskAlpha; } + ca_desc->setWriteMask(writeMask); } pipeline->raster_state.blend.r = p_blend_state.blend_constant.r; @@ -2169,34 +2089,40 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( pipeline->raster_state.stencil.enabled = true; } - if (shader->vert != nil) { - Result> function_or_err = _create_function(shader->vert, @"main0", p_specialization_constants); + if (shader->vert) { + Result> function_or_err = _create_function(shader->vert.get(), MTLSTR("main0"), p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); - desc.vertexFunction = std::get>(function_or_err); + desc->setVertexFunction(std::get>(function_or_err).get()); } - if (shader->frag != nil) { - Result> function_or_err = _create_function(shader->frag, @"main0", p_specialization_constants); + if (shader->frag) { + Result> function_or_err = _create_function(shader->frag.get(), MTLSTR("main0"), p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); - desc.fragmentFunction = std::get>(function_or_err); + desc->setFragmentFunction(std::get>(function_or_err).get()); } - if (archive) { - desc.binaryArchives = @[ archive ]; + MTL::PipelineOption options = MTL::PipelineOptionNone; + MTL::BinaryArchive *arc = archive.get(); + if (arc) { + NS::SharedPtr archives = NS::TransferPtr(NS::Array::array(reinterpret_cast(&arc), 1)->retain()); + desc->setBinaryArchives(archives.get()); + if (archive_fail_on_miss) { + options |= MTL::PipelineOptionFailOnBinaryArchiveMiss; + } } - NSError *error = nil; - pipeline->state = [device newRenderPipelineStateWithDescriptor:desc - error:&error]; + NS::Error *error = nullptr; + pipeline->state = NS::TransferPtr(device->newRenderPipelineState(desc.get(), options, nullptr, &error)); pipeline->shader = shader; - ERR_FAIL_COND_V_MSG(error != nil, PipelineID(), ([NSString stringWithFormat:@"error creating pipeline: %@", error.localizedDescription].UTF8String)); + ERR_FAIL_COND_V_MSG(error != nullptr, PipelineID(), String("error creating pipeline: ") + error->localizedDescription()->utf8String()); + ERR_FAIL_COND_V_MSG(!pipeline->state, PipelineID(), "Failed to create render pipeline state"); - if (archive) { - if ([archive addRenderPipelineFunctionsWithDescriptor:desc error:&error]) { + if (arc) { + if (arc->addRenderPipelineFunctions(desc.get(), &error)) { archive_count += 1; } else { - print_error(error.localizedDescription.UTF8String); + print_error(error->localizedDescription()->utf8String()); } } @@ -2208,22 +2134,22 @@ RDD::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( // ----- COMMANDS ----- void RenderingDeviceDriverMetal::command_bind_compute_pipeline(CommandBufferID p_cmd_buffer, PipelineID p_pipeline) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->bind_pipeline(p_pipeline); } void RenderingDeviceDriverMetal::command_bind_compute_uniform_sets(CommandBufferID p_cmd_buffer, VectorView p_uniform_sets, ShaderID p_shader, uint32_t p_first_set_index, uint32_t p_set_count, uint32_t p_dynamic_offsets) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->compute_bind_uniform_sets(p_uniform_sets, p_shader, p_first_set_index, p_set_count, p_dynamic_offsets); } void RenderingDeviceDriverMetal::command_compute_dispatch(CommandBufferID p_cmd_buffer, uint32_t p_x_groups, uint32_t p_y_groups, uint32_t p_z_groups) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->compute_dispatch(p_x_groups, p_y_groups, p_z_groups); } void RenderingDeviceDriverMetal::command_compute_dispatch_indirect(CommandBufferID p_cmd_buffer, BufferID p_indirect_buffer, uint64_t p_offset) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->compute_dispatch_indirect(p_indirect_buffer, p_offset); } @@ -2240,33 +2166,47 @@ RDD::PipelineID RenderingDeviceDriverMetal::compute_pipeline_create(ShaderID p_s os_signpost_event_emit(LOG_DRIVER, OS_SIGNPOST_ID_EXCLUSIVE, "create_pipeline"); - Result> function_or_err = _create_function(shader->kernel, @"main0", p_specialization_constants); + Result> function_or_err = _create_function(shader->kernel.get(), MTLSTR("main0"), p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); - id function = std::get>(function_or_err); + NS::SharedPtr function = std::get>(function_or_err); - MTLComputePipelineDescriptor *desc = [MTLComputePipelineDescriptor new]; - desc.computeFunction = function; - desc.label = conv::to_nsstring(shader->name); - if (archive) { - desc.binaryArchives = @[ archive ]; + NS::SharedPtr desc = NS::TransferPtr(MTL::ComputePipelineDescriptor::alloc()->init()); + desc->setComputeFunction(function.get()); + desc->setLabel(conv::to_nsstring(shader->name)); + + if (shader->uses_argument_buffers) { + // Set mutability of argument buffers. + for (uint32_t i = 0; i < shader->sets.size(); i++) { + const UniformSet &set = shader->sets[i]; + const MTL::Mutability mutability = set.dynamic_uniforms.is_empty() ? MTL::MutabilityImmutable : MTL::MutabilityMutable; + desc->buffers()->object(i)->setMutability(mutability); + } } - NSError *error; - id state = [device newComputePipelineStateWithDescriptor:desc - options:MTLPipelineOptionNone - reflection:nil - error:&error]; - ERR_FAIL_COND_V_MSG(error != nil, PipelineID(), ([NSString stringWithFormat:@"error creating pipeline: %@", error.localizedDescription].UTF8String)); + MTL::PipelineOption options = MTL::PipelineOptionNone; + MTL::BinaryArchive *arc = archive.get(); + if (arc) { + NS::SharedPtr archives = NS::TransferPtr(NS::Array::array(reinterpret_cast(&arc), 1)->retain()); + desc->setBinaryArchives(archives.get()); + if (archive_fail_on_miss) { + options |= MTL::PipelineOptionFailOnBinaryArchiveMiss; + } + } + + NS::Error *error = nullptr; + NS::SharedPtr state = NS::TransferPtr(device->newComputePipelineState(desc.get(), options, nullptr, &error)); + ERR_FAIL_COND_V_MSG(error != nullptr, PipelineID(), String("error creating pipeline: ") + error->localizedDescription()->utf8String()); + ERR_FAIL_COND_V_MSG(!state, PipelineID(), "Failed to create compute pipeline state"); MDComputePipeline *pipeline = new MDComputePipeline(state); pipeline->compute_state.local = shader->local; pipeline->shader = shader; - if (archive) { - if ([archive addComputePipelineFunctionsWithDescriptor:desc error:&error]) { + if (arc) { + if (arc->addComputePipelineFunctions(desc.get(), &error)) { archive_count += 1; } else { - print_error(error.localizedDescription.UTF8String); + print_error(error->localizedDescription()->utf8String()); } } @@ -2358,12 +2298,12 @@ void RenderingDeviceDriverMetal::command_timestamp_write(CommandBufferID p_cmd_b #pragma mark - Labels void RenderingDeviceDriverMetal::command_begin_label(CommandBufferID p_cmd_buffer, const char *p_label_name, const Color &p_color) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->begin_label(p_label_name, p_color); } void RenderingDeviceDriverMetal::command_end_label(CommandBufferID p_cmd_buffer) { - MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); + MDCommandBufferBase *cb = (MDCommandBufferBase *)(p_cmd_buffer.id); cb->end_label(); } @@ -2381,38 +2321,41 @@ void RenderingDeviceDriverMetal::begin_segment(uint32_t p_frame_index, uint32_t } void RenderingDeviceDriverMetal::end_segment() { + MutexLock lock(copy_queue_mutex); + _copy_queue_flush(); } #pragma mark - Misc void RenderingDeviceDriverMetal::set_object_name(ObjectType p_type, ID p_driver_id, const String &p_name) { + NS::String *label = conv::to_nsstring(p_name); + switch (p_type) { case OBJECT_TYPE_TEXTURE: { - id tex = rid::get(p_driver_id); - tex.label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; + MTL::Texture *tex = reinterpret_cast(p_driver_id.id); + tex->setLabel(label); } break; case OBJECT_TYPE_SAMPLER: { // Can't set label after creation. } break; case OBJECT_TYPE_BUFFER: { const BufferInfo *buf_info = (const BufferInfo *)p_driver_id.id; - buf_info->metal_buffer.label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; + buf_info->metal_buffer.get()->setLabel(label); } break; case OBJECT_TYPE_SHADER: { - NSString *label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; MDShader *shader = (MDShader *)(p_driver_id.id); if (MDRenderShader *rs = dynamic_cast(shader); rs != nullptr) { - [rs->vert setLabel:label]; - [rs->frag setLabel:label]; + rs->vert->set_label(label); + rs->frag->set_label(label); } else if (MDComputeShader *cs = dynamic_cast(shader); cs != nullptr) { - [cs->kernel setLabel:label]; + cs->kernel->set_label(label); } else { DEV_ASSERT(false); } } break; case OBJECT_TYPE_UNIFORM_SET: { MDUniformSet *set = (MDUniformSet *)(p_driver_id.id); - set->arg_buffer.label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; + set->arg_buffer->setLabel(label); } break; case OBJECT_TYPE_PIPELINE: { // Can't set label after creation. @@ -2426,7 +2369,7 @@ void RenderingDeviceDriverMetal::set_object_name(ObjectType p_type, ID p_driver_ uint64_t RenderingDeviceDriverMetal::get_resource_native_handle(DriverResource p_type, ID p_driver_id) { switch (p_type) { case DRIVER_RESOURCE_LOGICAL_DEVICE: { - return (uint64_t)(uintptr_t)(__bridge void *)device; + return (uint64_t)(uintptr_t)device; } case DRIVER_RESOURCE_PHYSICAL_DEVICE: { return 0; @@ -2435,7 +2378,7 @@ uint64_t RenderingDeviceDriverMetal::get_resource_native_handle(DriverResource p return 0; } case DRIVER_RESOURCE_COMMAND_QUEUE: { - return (uint64_t)(uintptr_t)(__bridge void *)device_queue; + return (uint64_t)(uintptr_t)get_command_queue(); } case DRIVER_RESOURCE_QUEUE_FAMILY: { return 0; @@ -2460,11 +2403,11 @@ uint64_t RenderingDeviceDriverMetal::get_resource_native_handle(DriverResource p } case DRIVER_RESOURCE_COMPUTE_PIPELINE: { MDComputePipeline *pipeline = (MDComputePipeline *)(p_driver_id.id); - return (uint64_t)(uintptr_t)(__bridge void *)pipeline->state; + return (uint64_t)(uintptr_t)pipeline->state.get(); } case DRIVER_RESOURCE_RENDER_PIPELINE: { MDRenderPipeline *pipeline = (MDRenderPipeline *)(p_driver_id.id); - return (uint64_t)(uintptr_t)(__bridge void *)pipeline->state; + return (uint64_t)(uintptr_t)pipeline->state.get(); } default: { return 0; @@ -2472,8 +2415,65 @@ uint64_t RenderingDeviceDriverMetal::get_resource_native_handle(DriverResource p } } +void RenderingDeviceDriverMetal::_copy_queue_copy_to_buffer(Span p_src_data, MTL::Buffer *p_dst_buffer, uint64_t p_dst_offset) { + MutexLock lock(copy_queue_mutex); + if (_copy_queue_buffer_available() < p_src_data.size()) { + _copy_queue_flush(); + } + + MTL::BlitCommandEncoder *blit_encoder = _copy_queue_blit_encoder(); + + memcpy(_copy_queue_buffer_ptr(), p_src_data.ptr(), p_src_data.size()); + + copy_queue_rs.get()->addAllocation(p_dst_buffer); + blit_encoder->copyFromBuffer(copy_queue_buffer.get(), copy_queue_buffer_offset, p_dst_buffer, p_dst_offset, p_src_data.size()); + + _copy_queue_buffer_consume(p_src_data.size()); +} + +void RenderingDeviceDriverMetal::_copy_queue_flush() { + if (!copy_queue_blit_encoder) { + return; + } + + copy_queue_rs.get()->addAllocation(copy_queue_buffer.get()); + copy_queue_rs.get()->commit(); + + copy_queue_blit_encoder.get()->endEncoding(); + copy_queue_blit_encoder.reset(); + copy_queue_command_buffer.get()->commit(); + copy_queue_command_buffer.get()->waitUntilCompleted(); + copy_queue_command_buffer.reset(); + copy_queue_buffer_offset = 0; + copy_queue_rs.get()->removeAllAllocations(); +} + +Error RenderingDeviceDriverMetal::_copy_queue_initialize() { + DEV_ASSERT(!copy_queue); + + copy_queue = NS::TransferPtr(device->newCommandQueue()); + copy_queue.get()->setLabel(MTLSTR("Copy Command Queue")); + ERR_FAIL_COND_V(!copy_queue, ERR_CANT_CREATE); + + // Reserve 64 KiB for copy commands. If the buffer fills, it will be flushed automatically. + copy_queue_buffer = NS::TransferPtr(device->newBuffer(64 * 1024, MTL::ResourceStorageModeShared | MTL::ResourceHazardTrackingModeUntracked)); + copy_queue_buffer.get()->setLabel(MTLSTR("Copy Command Scratch Buffer")); + + if (__builtin_available(macOS 15.0, iOS 18.0, tvOS 18.0, visionOS 1.0, *)) { + MTL::ResidencySetDescriptor *rs_desc = MTL::ResidencySetDescriptor::alloc()->init(); + rs_desc->setInitialCapacity(2); + rs_desc->setLabel(MTLSTR("Copy Queue Residency Set")); + NS::Error *error = nullptr; + copy_queue_rs = NS::TransferPtr(device->newResidencySet(rs_desc, &error)); + rs_desc->release(); + copy_queue.get()->addResidencySet(copy_queue_rs.get()); + } + + return OK; +} + uint64_t RenderingDeviceDriverMetal::get_total_memory_used() { - return device.currentAllocatedSize; + return device->currentAllocatedSize(); } uint64_t RenderingDeviceDriverMetal::get_lazily_memory_used() { @@ -2602,7 +2602,7 @@ uint64_t RenderingDeviceDriverMetal::limit_get(Limit p_limit) { uint64_t RenderingDeviceDriverMetal::api_trait_get(ApiTrait p_trait) { switch (p_trait) { case API_TRAIT_HONORS_PIPELINE_BARRIERS: - return false; + return use_barriers; case API_TRAIT_CLEARS_WITH_COPY_ENGINE: return false; default: @@ -2663,11 +2663,11 @@ bool RenderingDeviceDriverMetal::is_composite_alpha_supported(CommandQueueID p_q } size_t RenderingDeviceDriverMetal::get_texel_buffer_alignment_for_format(RDD::DataFormat p_format) const { - return [device minimumLinearTextureAlignmentForPixelFormat:pixel_formats->getMTLPixelFormat(p_format)]; + return device->minimumLinearTextureAlignmentForPixelFormat(pixel_formats->getMTLPixelFormat(p_format)); } -size_t RenderingDeviceDriverMetal::get_texel_buffer_alignment_for_format(MTLPixelFormat p_format) const { - return [device minimumLinearTextureAlignmentForPixelFormat:p_format]; +size_t RenderingDeviceDriverMetal::get_texel_buffer_alignment_for_format(MTL::PixelFormat p_format) const { + return device->minimumLinearTextureAlignmentForPixelFormat(p_format); } /******************/ @@ -2675,6 +2675,9 @@ size_t RenderingDeviceDriverMetal::get_texel_buffer_alignment_for_format(MTLPixe RenderingDeviceDriverMetal::RenderingDeviceDriverMetal(RenderingContextDriverMetal *p_context_driver) : context_driver(p_context_driver) { DEV_ASSERT(p_context_driver != nullptr); + if (String res = OS::get_singleton()->get_environment("GODOT_MTL_ARCHIVE_FAIL_ON_MISS"); res == "1") { + archive_fail_on_miss = true; + } #if TARGET_OS_OSX if (String res = OS::get_singleton()->get_environment("GODOT_MTL_SHADER_LOAD_STRATEGY"); res == U"lazy") { @@ -2687,10 +2690,6 @@ RenderingDeviceDriverMetal::RenderingDeviceDriverMetal(RenderingContextDriverMet } RenderingDeviceDriverMetal::~RenderingDeviceDriverMetal() { - for (MDCommandBuffer *cb : command_buffers) { - delete cb; - } - for (KeyValue &kv : _shader_cache) { memdelete(kv.value); } @@ -2713,18 +2712,25 @@ RenderingDeviceDriverMetal::~RenderingDeviceDriverMetal() { Error RenderingDeviceDriverMetal::_create_device() { device = context_driver->get_metal_device(); - device_queue = [device newCommandQueue]; - ERR_FAIL_NULL_V(device_queue, ERR_CANT_CREATE); - - device_scope = [MTLCaptureManager.sharedCaptureManager newCaptureScopeWithCommandQueue:device_queue]; - device_scope.label = @"Godot Frame"; - [device_scope beginScope]; // Allow Xcode to capture the first frame, if desired. - - resource_cache = std::make_unique(this); + device_scope = NS::TransferPtr(MTL::CaptureManager::sharedCaptureManager()->newCaptureScope(device)); + device_scope->setLabel(MTLSTR("Godot Frame")); + device_scope->beginScope(); // Allow Xcode to capture the first frame, if desired. return OK; } +void RenderingDeviceDriverMetal::_track_resource(MTL::Resource *p_resource) { + if (use_barriers) { + _residency_add.push_back(p_resource); + } +} + +void RenderingDeviceDriverMetal::_untrack_resource(MTL::Resource *p_resource) { + if (use_barriers) { + _residency_del.push_back(p_resource); + } +} + void RenderingDeviceDriverMetal::_check_capabilities() { capabilities.device_family = DEVICE_METAL; parse_msl_version(device_properties->features.msl_target_version, capabilities.version_major, capabilities.version_minor); @@ -2733,13 +2739,17 @@ void RenderingDeviceDriverMetal::_check_capabilities() { API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) static MetalDeviceProfile device_profile_from_properties(MetalDeviceProperties *p_device_properties) { using DP = MetalDeviceProfile; - NSOperatingSystemVersion os_version = NSProcessInfo.processInfo.operatingSystemVersion; + NS::OperatingSystemVersion os_version = NS::ProcessInfo::processInfo()->operatingSystemVersion(); MetalDeviceProfile res; res.min_os_version = MinOsVersion(os_version.majorVersion, os_version.minorVersion, os_version.patchVersion); #if TARGET_OS_OSX res.platform = DP::Platform::macOS; -#else +#elif TARGET_OS_IPHONE res.platform = DP::Platform::iOS; +#elif TARGET_OS_VISION + res.platform = DP::Platform::visionOS; +#else +#error "Unsupported Apple platform" #endif res.features = { .msl_version = p_device_properties->features.msl_target_version, @@ -2749,31 +2759,31 @@ static MetalDeviceProfile device_profile_from_properties(MetalDeviceProperties * // highestFamily will only be set to an Apple GPU family switch (p_device_properties->features.highestFamily) { - case MTLGPUFamilyApple1: + case MTL::GPUFamilyApple1: res.gpu = DP::GPU::Apple1; break; - case MTLGPUFamilyApple2: + case MTL::GPUFamilyApple2: res.gpu = DP::GPU::Apple2; break; - case MTLGPUFamilyApple3: + case MTL::GPUFamilyApple3: res.gpu = DP::GPU::Apple3; break; - case MTLGPUFamilyApple4: + case MTL::GPUFamilyApple4: res.gpu = DP::GPU::Apple4; break; - case MTLGPUFamilyApple5: + case MTL::GPUFamilyApple5: res.gpu = DP::GPU::Apple5; break; - case MTLGPUFamilyApple6: + case MTL::GPUFamilyApple6: res.gpu = DP::GPU::Apple6; break; - case MTLGPUFamilyApple7: + case MTL::GPUFamilyApple7: res.gpu = DP::GPU::Apple7; break; - case MTLGPUFamilyApple8: + case MTL::GPUFamilyApple8: res.gpu = DP::GPU::Apple8; break; - case MTLGPUFamilyApple9: + case MTL::GPUFamilyApple9: res.gpu = DP::GPU::Apple9; break; default: { @@ -2785,17 +2795,21 @@ static MetalDeviceProfile device_profile_from_properties(MetalDeviceProperties * return res; } -Error RenderingDeviceDriverMetal::initialize(uint32_t p_device_index, uint32_t p_frame_count) { +Error RenderingDeviceDriverMetal::_initialize(uint32_t p_device_index, uint32_t p_frame_count) { context_device = context_driver->device_get(p_device_index); Error err = _create_device(); ERR_FAIL_COND_V(err, ERR_CANT_CREATE); device_properties = memnew(MetalDeviceProperties(device)); device_profile = device_profile_from_properties(device_properties); + resource_cache = std::make_unique(device, *pixel_formats, device_properties->limits.maxPerStageBufferCount); shader_container_format = memnew(RenderingShaderContainerFormatMetal(&device_profile)); _check_capabilities(); + err = _copy_queue_initialize(); + ERR_FAIL_COND_V(err, ERR_CANT_CREATE); + _frame_count = p_frame_count; // Set the pipeline cache ID based on the Metal version. @@ -2816,7 +2830,7 @@ Error RenderingDeviceDriverMetal::initialize(uint32_t p_device_index, uint32_t p } // The Metal renderer requires Apple4 family. This is 2017 era A11 chips and newer. - if (device_properties->features.highestFamily < MTLGPUFamilyApple4) { + if (device_properties->features.highestFamily < MTL::GPUFamilyApple4) { String error_string = vformat("Your Apple GPU does not support the following features, which are required to use Metal-based renderers in Godot:\n\n"); if (!device_properties->features.imageCubeArray) { error_string += "- No support for image cube arrays.\n"; diff --git a/drivers/metal/rendering_device_driver_metal.h b/drivers/metal/rendering_device_driver_metal.h index d501a1140a..b6cdd84786 100644 --- a/drivers/metal/rendering_device_driver_metal.h +++ b/drivers/metal/rendering_device_driver_metal.h @@ -30,13 +30,13 @@ #pragma once -#import "metal_device_profile.h" -#import "metal_objects.h" +#include "metal_device_profile.h" +#include "metal_objects_shared.h" #include "servers/rendering/rendering_device_driver.h" -#import -#import +#include +#include class RenderingShaderContainerFormatMetal; @@ -48,18 +48,28 @@ class RenderingShaderContainerFormatMetal; class RenderingContextDriverMetal; +namespace MTL3 { +class MDCommandBuffer; +} +namespace MTL4 { +class MDCommandBuffer; +} + class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingDeviceDriverMetal : public RenderingDeviceDriver { friend struct ShaderCacheEntry; - friend class MDCommandBuffer; + friend class MTL3::MDCommandBuffer; + friend class MTL4::MDCommandBuffer; + friend class MDUniformSet; template using Result = std::variant; #pragma mark - Generic +protected: RenderingContextDriverMetal *context_driver = nullptr; RenderingContextDriver::Device context_device; - id device = nil; + MTL::Device *device = nullptr; uint32_t _frame_count = 1; /// frame_index is a cyclic counter derived from the current frame number modulo frame_count, @@ -78,16 +88,84 @@ class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingDeviceDriverMet RDD::FragmentShadingRateCapabilities fsr_capabilities; RDD::FragmentDensityMapCapabilities fdm_capabilities; - id archive = nil; + NS::SharedPtr archive; uint32_t archive_count = 0; + // DEV: When true, attempting to create a pipeline will fail if it cannot use the archive. + bool archive_fail_on_miss = false; - id device_queue = nil; - id device_scope = nil; + /// Resources to be added to the `main_residency_set`. + LocalVector _residency_add; + /// Resources to be removed from the `main_residency_set`. + LocalVector _residency_del; + +#pragma mark - Copy Queue + + Mutex copy_queue_mutex; + /// A command queue used for internal copy operations. + NS::SharedPtr copy_queue; + GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") + NS::SharedPtr copy_queue_rs; + GODOT_CLANG_WARNING_POP + // If this is not nullptr, there are pending copy operations. + NS::SharedPtr copy_queue_command_buffer; + NS::SharedPtr copy_queue_blit_encoder; + NS::SharedPtr copy_queue_buffer; + NS::UInteger copy_queue_buffer_offset = 0; + + _FORCE_INLINE_ NS::UInteger _copy_queue_buffer_available() const { + return copy_queue_buffer.get()->length() - copy_queue_buffer_offset; + } + + /// Marks p_size bytes as consumed from the copy queue buffer, aligning the offset to 16 bytes. + _FORCE_INLINE_ void _copy_queue_buffer_consume(NS::UInteger p_size) { + NS::UInteger aligned_offset = round_up_to_alignment(copy_queue_buffer_offset, 16); + copy_queue_buffer_offset = aligned_offset + p_size; + } + + /// Returns a pointer to the current position in the copy queue buffer. + _FORCE_INLINE_ void *_copy_queue_buffer_ptr() const { + return static_cast(copy_queue_buffer.get()->contents()) + copy_queue_buffer_offset; + } + + _FORCE_INLINE_ MTL::CommandBuffer *_copy_queue_command_buffer() { + if (!copy_queue_command_buffer) { + DEV_ASSERT(!copy_queue_blit_encoder); + copy_queue_command_buffer = NS::RetainPtr(copy_queue.get()->commandBufferWithUnretainedReferences()); + } + return copy_queue_command_buffer.get(); + } + + _FORCE_INLINE_ MTL::BlitCommandEncoder *_copy_queue_blit_encoder() { + if (!copy_queue_blit_encoder) { + MTL::BlitCommandEncoder *enc = _copy_queue_command_buffer()->blitCommandEncoder(); + copy_queue_blit_encoder = NS::RetainPtr(enc); + } + return copy_queue_blit_encoder.get(); + } + + void _copy_queue_copy_to_buffer(Span p_src_data, MTL::Buffer *p_dst_buffer, uint64_t p_dst_offset = 0); + void _copy_queue_flush(); + Error _copy_queue_initialize(); + + NS::SharedPtr device_scope; String pipeline_cache_id; - Error _create_device(); + virtual MTL::CommandQueue *get_command_queue() const = 0; + GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") + virtual void add_residency_set_to_main_queue(MTL::ResidencySet *p_set) = 0; + virtual void remove_residency_set_to_main_queue(MTL::ResidencySet *p_set) = 0; + NS::SharedPtr main_residency_set; + GODOT_CLANG_WARNING_POP + + bool use_barriers = false; + MTL::ResourceOptions base_hazard_tracking = MTL::ResourceHazardTrackingModeTracked; + + virtual Error _create_device(); + virtual void _track_resource(MTL::Resource *p_resource); + virtual void _untrack_resource(MTL::Resource *p_resource); void _check_capabilities(); + Error _initialize(uint32_t p_device_index, uint32_t p_frame_count); #pragma mark - Shader Cache @@ -103,7 +181,7 @@ class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingDeviceDriverMet void shader_cache_free_entry(const SHA256Digest &key); public: - Error initialize(uint32_t p_device_index, uint32_t p_frame_count) override final; + virtual Error initialize(uint32_t p_device_index, uint32_t p_frame_count) override = 0; #pragma mark - Memory @@ -111,7 +189,7 @@ public: public: struct BufferInfo { - id metal_buffer; + NS::SharedPtr metal_buffer; _FORCE_INLINE_ bool is_dynamic() const { return _frame_idx != UINT32_MAX; } _FORCE_INLINE_ uint32_t frame_index() const { return _frame_idx; } @@ -131,7 +209,6 @@ public: virtual void buffer_unmap(BufferID p_buffer) override final; virtual uint8_t *buffer_persistent_map_advance(BufferID p_buffer, uint64_t p_frames_drawn) override final; virtual uint64_t buffer_get_dynamic_offsets(Span p_buffers) override final; - virtual void buffer_flush(BufferID p_buffer) override final; virtual uint64_t buffer_get_device_address(BufferID p_buffer) override final; #pragma mark - Texture @@ -168,6 +245,7 @@ public: #pragma mark - Barriers +public: virtual void command_pipeline_barrier( CommandBufferID p_cmd_buffer, BitField p_src_stages, @@ -179,78 +257,16 @@ public: #pragma mark - Fences -private: - struct Fence { - virtual void signal(id p_cmd_buffer) = 0; - virtual Error wait(uint32_t p_timeout_ms) = 0; - virtual ~Fence() = default; - }; - - struct FenceEvent : public Fence { - id event; - uint64_t value; - FenceEvent(id p_event) : - event(p_event), - value(0) {} - - virtual void signal(id p_cb) override { - if (p_cb) { - value++; - [p_cb encodeSignalEvent:event value:value]; - } - } - - virtual Error wait(uint32_t p_timeout_ms) override { - GODOT_CLANG_WARNING_PUSH - GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") - BOOL signaled = [event waitUntilSignaledValue:value timeoutMS:p_timeout_ms]; - GODOT_CLANG_WARNING_POP - if (!signaled) { -#ifdef DEBUG_ENABLED - ERR_PRINT("timeout waiting for fence"); -#endif - return ERR_TIMEOUT; - } - - return OK; - } - }; - - struct FenceSemaphore : public Fence { - dispatch_semaphore_t semaphore; - FenceSemaphore() : - semaphore(dispatch_semaphore_create(0)) {} - - virtual void signal(id p_cb) override { - if (p_cb) { - [p_cb addCompletedHandler:^(id buffer) { - dispatch_semaphore_signal(semaphore); - }]; - } else { - dispatch_semaphore_signal(semaphore); - } - } - - virtual Error wait(uint32_t p_timeout_ms) override { - dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, static_cast(p_timeout_ms) * 1000000); - long result = dispatch_semaphore_wait(semaphore, timeout); - if (result != 0) { - return ERR_TIMEOUT; - } - return OK; - } - }; - public: - virtual FenceID fence_create() override final; - virtual Error fence_wait(FenceID p_fence) override final; - virtual void fence_free(FenceID p_fence) override final; + virtual FenceID fence_create() override = 0; + virtual Error fence_wait(FenceID p_fence) override = 0; + virtual void fence_free(FenceID p_fence) override = 0; #pragma mark - Semaphores public: - virtual SemaphoreID semaphore_create() override final; - virtual void semaphore_free(SemaphoreID p_semaphore) override final; + virtual SemaphoreID semaphore_create() override = 0; + virtual void semaphore_free(SemaphoreID p_semaphore) override = 0; #pragma mark - Commands // ----- QUEUE FAMILY ----- @@ -258,25 +274,22 @@ public: virtual CommandQueueFamilyID command_queue_family_get(BitField p_cmd_queue_family_bits, RenderingContextDriver::SurfaceID p_surface = 0) override final; // ----- QUEUE ----- + public: - virtual CommandQueueID command_queue_create(CommandQueueFamilyID p_cmd_queue_family, bool p_identify_as_main_queue = false) override final; - virtual Error command_queue_execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_semaphores, VectorView p_cmd_buffers, VectorView p_cmd_semaphores, FenceID p_cmd_fence, VectorView p_swap_chains) override final; - virtual void command_queue_free(CommandQueueID p_cmd_queue) override final; + virtual CommandQueueID command_queue_create(CommandQueueFamilyID p_cmd_queue_family, bool p_identify_as_main_queue = false) override = 0; + virtual Error command_queue_execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_semaphores, VectorView p_cmd_buffers, VectorView p_cmd_semaphores, FenceID p_cmd_fence, VectorView p_swap_chains) override = 0; + virtual void command_queue_free(CommandQueueID p_cmd_queue) override = 0; // ----- POOL ----- - virtual CommandPoolID command_pool_create(CommandQueueFamilyID p_cmd_queue_family, CommandBufferType p_cmd_buffer_type) override final; - virtual bool command_pool_reset(CommandPoolID p_cmd_pool) override final; - virtual void command_pool_free(CommandPoolID p_cmd_pool) override final; + virtual CommandPoolID command_pool_create(CommandQueueFamilyID p_cmd_queue_family, CommandBufferType p_cmd_buffer_type) override = 0; + virtual bool command_pool_reset(CommandPoolID p_cmd_pool) override = 0; + virtual void command_pool_free(CommandPoolID p_cmd_pool) override = 0; // ----- BUFFER ----- -private: - // Used to maintain references. - Vector command_buffers; - public: - virtual CommandBufferID command_buffer_create(CommandPoolID p_cmd_pool) override final; + virtual CommandBufferID command_buffer_create(CommandPoolID p_cmd_pool) override = 0; virtual bool command_buffer_begin(CommandBufferID p_cmd_buffer) override final; virtual bool command_buffer_begin_secondary(CommandBufferID p_cmd_buffer, RenderPassID p_render_pass, uint32_t p_subpass, FramebufferID p_framebuffer) override final; virtual void command_buffer_end(CommandBufferID p_cmd_buffer) override final; @@ -284,7 +297,7 @@ public: #pragma mark - Swapchain -private: +protected: struct SwapChain { RenderingContextDriver::SurfaceID surface = RenderingContextDriver::SurfaceID(); RenderPassID render_pass; @@ -355,7 +368,7 @@ public: #pragma mark Pipeline private: - Result> _create_function(MDLibrary *p_library, NSString *p_name, VectorView &p_specialization_constants); + Result> _create_function(MDLibrary *p_library, NS::String *p_name, VectorView &p_specialization_constants); public: virtual void pipeline_free(PipelineID p_pipeline_id) override final; @@ -506,14 +519,13 @@ public: virtual const MultiviewCapabilities &get_multiview_capabilities() override final; virtual const FragmentShadingRateCapabilities &get_fragment_shading_rate_capabilities() override final; virtual const FragmentDensityMapCapabilities &get_fragment_density_map_capabilities() override final; - virtual String get_api_name() const override final { return "Metal"; } virtual String get_api_version() const override final; virtual String get_pipeline_cache_uuid() const override final; virtual const Capabilities &get_capabilities() const override final; virtual bool is_composite_alpha_supported(CommandQueueID p_queue) const override final; // Metal-specific. - id get_device() const { return device; } + MTL::Device *get_device() const { return device; } PixelFormats &get_pixel_formats() const { return *pixel_formats; } MDResourceCache &get_resource_cache() const { return *resource_cache; } MetalDeviceProperties const &get_device_properties() const { return *device_properties; } @@ -523,7 +535,7 @@ public: } size_t get_texel_buffer_alignment_for_format(RDD::DataFormat p_format) const; - size_t get_texel_buffer_alignment_for_format(MTLPixelFormat p_format) const; + size_t get_texel_buffer_alignment_for_format(MTL::PixelFormat p_format) const; _FORCE_INLINE_ uint32_t frame_count() const { return _frame_count; } _FORCE_INLINE_ uint32_t frame_index() const { return _frame_index; } @@ -534,7 +546,7 @@ public: ~RenderingDeviceDriverMetal(); }; -// Defined outside because we need to forward declare it in metal_objects.h +// Defined outside because we need to forward declare it in metal3_objects.h struct API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) MetalBufferDynamicInfo : public RenderingDeviceDriverMetal::BufferInfo { uint64_t size_bytes; // Contains the real buffer size / frame_count. uint32_t next_frame_index(uint32_t p_frame_count) { diff --git a/drivers/metal/rendering_device_driver_metal3.cpp b/drivers/metal/rendering_device_driver_metal3.cpp new file mode 100644 index 0000000000..e2a1e4020f --- /dev/null +++ b/drivers/metal/rendering_device_driver_metal3.cpp @@ -0,0 +1,369 @@ +/**************************************************************************/ +/* rendering_device_driver_metal3.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#include "rendering_device_driver_metal3.h" + +#include "pixel_formats.h" +#include "rendering_context_driver_metal.h" + +#include "core/config/project_settings.h" +#include "core/string/ustring.h" + +namespace MTL3 { + +#pragma mark - FenceEvent / FenceSemaphore + +void RenderingDeviceDriverMetal::FenceEvent::signal(MTL::CommandBuffer *p_cb) { + if (p_cb) { + value++; + p_cb->encodeSignalEvent(event.get(), value); + } +} + +Error RenderingDeviceDriverMetal::FenceEvent::wait(uint32_t p_timeout_ms) { + bool signaled = event->waitUntilSignaledValue(value, p_timeout_ms); + if (!signaled) { +#ifdef DEBUG_ENABLED + ERR_PRINT("timeout waiting for fence"); +#endif + return ERR_TIMEOUT; + } + return OK; +} + +void RenderingDeviceDriverMetal::FenceSemaphore::signal(MTL::CommandBuffer *p_cb) { + if (p_cb) { + p_cb->addCompletedHandler([this](MTL::CommandBuffer *) { + dispatch_semaphore_signal(semaphore); + }); + } else { + dispatch_semaphore_signal(semaphore); + } +} + +Error RenderingDeviceDriverMetal::FenceSemaphore::wait(uint32_t p_timeout_ms) { + dispatch_time_t timeout = dispatch_time(DISPATCH_TIME_NOW, static_cast(p_timeout_ms) * 1000000); + long result = dispatch_semaphore_wait(semaphore, timeout); + if (result != 0) { + return ERR_TIMEOUT; + } + return OK; +} + +#pragma mark - Constructor / Destructor + +RenderingDeviceDriverMetal::RenderingDeviceDriverMetal(RenderingContextDriverMetal *p_context_driver) : + ::RenderingDeviceDriverMetal(p_context_driver) { +} + +RenderingDeviceDriverMetal::~RenderingDeviceDriverMetal() { + for (MDCommandBuffer *cb : command_buffers) { + memdelete(cb); + } +} + +#pragma mark - Initialization + +Error RenderingDeviceDriverMetal::_create_device() { + Error err = ::RenderingDeviceDriverMetal::_create_device(); + ERR_FAIL_COND_V(err, err); + + device_queue = NS::TransferPtr(device->newCommandQueue()); + ERR_FAIL_NULL_V(device_queue.get(), ERR_CANT_CREATE); + device_queue->setLabel(MTLSTR("Godot Main Command Queue")); + + return OK; +} + +Error RenderingDeviceDriverMetal::initialize(uint32_t p_device_index, uint32_t p_frame_count) { + Error err = _initialize(p_device_index, p_frame_count); + ERR_FAIL_COND_V(err, err); + + // Barriers are still experimental in Metal 3, so they are disabled by default + // and can only be enabled via an environment variable. + bool barriers_enabled = OS::get_singleton()->get_environment("GODOT_MTL_FORCE_BARRIERS") == "1"; + if (__builtin_available(macos 26.0, ios 26.0, tvos 26.0, visionos 26.0, *)) { + if (barriers_enabled) { + print_line("Metal 3: Resource barriers enabled."); + NS::SharedPtr rs_desc = NS::TransferPtr(MTL::ResidencySetDescriptor::alloc()->init()); + rs_desc->setInitialCapacity(250); + rs_desc->setLabel(MTLSTR("Main Residency Set")); + NS::Error *error = nullptr; + NS::SharedPtr mrs = NS::TransferPtr(device->newResidencySet(rs_desc.get(), &error)); + if (!mrs) { + String error_msg = error ? String(error->localizedDescription()->utf8String()) : "Unknown error"; + print_error(vformat("Resource barriers unavailable. Failed to create main residency set for explicit resource barriers: %s", error_msg)); + } else { + use_barriers = true; + base_hazard_tracking = MTL::ResourceHazardTrackingModeUntracked; + main_residency_set = mrs; + device_queue->addResidencySet(mrs.get()); + } + } + } else { + if (barriers_enabled) { + // Application or user has requested barriers, but the OS doesn't support them. + print_verbose("Metal 3: Resource barriers are not supported on this OS version."); + barriers_enabled = false; + } + } + + return OK; +} + +#pragma mark - Residency + +void RenderingDeviceDriverMetal::add_residency_set_to_main_queue(MTL::ResidencySet *p_set) { + device_queue->addResidencySet(p_set); +} + +void RenderingDeviceDriverMetal::remove_residency_set_to_main_queue(MTL::ResidencySet *p_set) { + device_queue->removeResidencySet(p_set); +} + +#pragma mark - Fences + +RDD::FenceID RenderingDeviceDriverMetal::fence_create() { + Fence *fence = memnew(FenceEvent(NS::TransferPtr(device->newSharedEvent()))); + return FenceID(fence); +} + +Error RenderingDeviceDriverMetal::fence_wait(FenceID p_fence) { + Fence *fence = (Fence *)(p_fence.id); + return fence->wait(1000); +} + +void RenderingDeviceDriverMetal::fence_free(FenceID p_fence) { + Fence *fence = (Fence *)(p_fence.id); + memdelete(fence); +} + +#pragma mark - Semaphores + +RDD::SemaphoreID RenderingDeviceDriverMetal::semaphore_create() { + if (use_barriers) { + Semaphore *sem = memnew(Semaphore(NS::TransferPtr(device->newEvent()))); + return SemaphoreID(sem); + } + return SemaphoreID(1); +} + +void RenderingDeviceDriverMetal::semaphore_free(SemaphoreID p_semaphore) { + if (use_barriers) { + Semaphore *sem = (Semaphore *)(p_semaphore.id); + memdelete(sem); + } +} + +#pragma mark - Command Queues + +RDD::CommandQueueID RenderingDeviceDriverMetal::command_queue_create(CommandQueueFamilyID p_cmd_queue_family, bool p_identify_as_main_queue) { + return CommandQueueID(1); +} + +Error RenderingDeviceDriverMetal::_execute_and_present_barriers(CommandQueueID p_cmd_queue, VectorView p_wait_sem, VectorView p_cmd_buffers, VectorView p_cmd_sem, FenceID p_cmd_fence, VectorView p_swap_chains) { + uint32_t size = p_cmd_buffers.size(); + if (size == 0) { + return OK; + } + + bool changed = false; + MTL::ResidencySet *mrs = main_residency_set.get(); + if (!_residency_add.is_empty()) { + mrs->addAllocations(reinterpret_cast(_residency_add.ptr()), _residency_add.size()); + _residency_add.clear(); + changed = true; + } + if (!_residency_del.is_empty()) { + mrs->removeAllocations(reinterpret_cast(_residency_del.ptr()), _residency_del.size()); + _residency_del.clear(); + changed = true; + } + if (changed) { + mrs->commit(); + } + + if (p_wait_sem.size() > 0) { + MTL::CommandBuffer *cb = device_queue->commandBuffer(); +#ifdef DEV_ENABLED + cb->setLabel(MTLSTR("Wait Command Buffer")); +#endif + for (uint32_t i = 0; i < p_wait_sem.size(); i++) { + Semaphore *sem = (Semaphore *)p_wait_sem[i].id; + cb->encodeWait(sem->event.get(), sem->value); + } + cb->commit(); + } + + for (uint32_t i = 0; i < size - 1; i++) { + MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[i].id); + cmd_buffer->commit(); + } + + // The last command buffer will signal the fence and semaphores. + MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[size - 1].id); + Fence *fence = (Fence *)(p_cmd_fence.id); + if (fence != nullptr) { + cmd_buffer->end(); + MTL::CommandBuffer *cb = cmd_buffer->get_command_buffer(); + fence->signal(cb); + } + + struct DrawRequest { + NS::SharedPtr drawable; + DisplayServer::VSyncMode vsync_mode; + double duration; + }; + + if (p_swap_chains.size() > 0) { + Vector drawables; + drawables.reserve(p_swap_chains.size()); + + for (uint32_t i = 0; i < p_swap_chains.size(); i++) { + SwapChain *swap_chain = (SwapChain *)(p_swap_chains[i].id); + RenderingContextDriverMetal::Surface *metal_surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); + MTL::Drawable *drawable = metal_surface->next_drawable(); + if (drawable) { + drawables.push_back(DrawRequest{ + .drawable = NS::RetainPtr(drawable), + .vsync_mode = metal_surface->vsync_mode, + .duration = metal_surface->present_minimum_duration, + }); + } + } + + MTL::CommandBuffer *cb = cmd_buffer->get_command_buffer(); + cb->addCompletedHandler([drawables = std::move(drawables)](MTL::CommandBuffer *) { + for (const DrawRequest &dr : drawables) { + switch (dr.vsync_mode) { + case DisplayServer::VSYNC_DISABLED: { + dr.drawable->present(); + } break; + default: { + dr.drawable->presentAfterMinimumDuration(dr.duration); + } break; + } + } + }); + } + + cmd_buffer->commit(); + + if (p_cmd_sem.size() > 0) { + MTL::CommandBuffer *cb = device_queue->commandBuffer(); + for (uint32_t i = 0; i < p_cmd_sem.size(); i++) { + Semaphore *sem = (Semaphore *)p_cmd_sem[i].id; + sem->value++; + cb->encodeSignalEvent(sem->event.get(), sem->value); + } + cb->commit(); + } + + return OK; +} + +Error RenderingDeviceDriverMetal::_execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_sem, VectorView p_cmd_buffers, VectorView p_cmd_sem, FenceID p_cmd_fence, VectorView p_swap_chains) { + uint32_t size = p_cmd_buffers.size(); + if (size == 0) { + return OK; + } + + for (uint32_t i = 0; i < size - 1; i++) { + MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[i].id); + cmd_buffer->commit(); + } + + // The last command buffer will signal the fence and semaphores. + MDCommandBuffer *cmd_buffer = (MDCommandBuffer *)(p_cmd_buffers[size - 1].id); + Fence *fence = (Fence *)(p_cmd_fence.id); + if (fence != nullptr) { + cmd_buffer->end(); + MTL::CommandBuffer *cb = cmd_buffer->get_command_buffer(); + fence->signal(cb); + } + + for (uint32_t i = 0; i < p_swap_chains.size(); i++) { + SwapChain *swap_chain = (SwapChain *)(p_swap_chains[i].id); + RenderingContextDriverMetal::Surface *metal_surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); + metal_surface->present(cmd_buffer); + } + + cmd_buffer->commit(); + + return OK; +} + +Error RenderingDeviceDriverMetal::command_queue_execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_sem, VectorView p_cmd_buffers, VectorView p_cmd_sem, FenceID p_cmd_fence, VectorView p_swap_chains) { + Error res; + if (use_barriers) { + res = _execute_and_present_barriers(p_cmd_queue, p_wait_sem, p_cmd_buffers, p_cmd_sem, p_cmd_fence, p_swap_chains); + } else { + res = _execute_and_present(p_cmd_queue, p_wait_sem, p_cmd_buffers, p_cmd_sem, p_cmd_fence, p_swap_chains); + } + ERR_FAIL_COND_V(res != OK, res); + + if (p_swap_chains.size() > 0) { + // Used as a signal that we're presenting, so this is the end of a frame. + MTL::CaptureScope *scope = device_scope.get(); + scope->endScope(); + scope->beginScope(); + } + + return OK; +} + +void RenderingDeviceDriverMetal::command_queue_free(CommandQueueID p_cmd_queue) { +} + +#pragma mark - Command Pools + +RDD::CommandPoolID RenderingDeviceDriverMetal::command_pool_create(CommandQueueFamilyID p_cmd_queue_family, CommandBufferType p_cmd_buffer_type) { + DEV_ASSERT(p_cmd_buffer_type == COMMAND_BUFFER_TYPE_PRIMARY); + return CommandPoolID(reinterpret_cast(device_queue.get())); +} + +bool RenderingDeviceDriverMetal::command_pool_reset(CommandPoolID p_cmd_pool) { + return true; +} + +void RenderingDeviceDriverMetal::command_pool_free(CommandPoolID p_cmd_pool) { + // Nothing to free - the device_queue is managed by SharedPtr. +} + +#pragma mark - Command Buffers + +RDD::CommandBufferID RenderingDeviceDriverMetal::command_buffer_create(CommandPoolID p_cmd_pool) { + MTL::CommandQueue *queue = reinterpret_cast(p_cmd_pool.id); + MDCommandBuffer *obj = memnew(MDCommandBuffer(queue, this)); + command_buffers.push_back(obj); + return CommandBufferID(obj); +} + +} // namespace MTL3 diff --git a/drivers/metal/rendering_device_driver_metal3.h b/drivers/metal/rendering_device_driver_metal3.h new file mode 100644 index 0000000000..648fdd57a8 --- /dev/null +++ b/drivers/metal/rendering_device_driver_metal3.h @@ -0,0 +1,115 @@ +/**************************************************************************/ +/* rendering_device_driver_metal3.h */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#pragma once + +#include "metal3_objects.h" +#include "rendering_device_driver_metal.h" + +#include + +namespace MTL3 { + +class API_AVAILABLE(macos(11.0), ios(14.0), tvos(14.0)) RenderingDeviceDriverMetal final : public ::RenderingDeviceDriverMetal { + friend class MDCommandBuffer; +#pragma mark - Generic + + NS::SharedPtr device_queue; + + struct Fence { + virtual void signal(MTL::CommandBuffer *p_cmd_buffer) = 0; + virtual Error wait(uint32_t p_timeout_ms) = 0; + virtual ~Fence() = default; + }; + + struct FenceEvent : Fence { + NS::SharedPtr event; + uint64_t value = 0; + FenceEvent(NS::SharedPtr p_event) : + event(p_event) {} + void signal(MTL::CommandBuffer *p_cb) override; + Error wait(uint32_t p_timeout_ms) override; + }; + + struct FenceSemaphore : Fence { + dispatch_semaphore_t semaphore; + FenceSemaphore() : + semaphore(dispatch_semaphore_create(0)) {} + void signal(MTL::CommandBuffer *p_cb) override; + Error wait(uint32_t p_timeout_ms) override; + }; + + struct Semaphore { + NS::SharedPtr event; + uint64_t value = 0; + Semaphore(NS::SharedPtr p_event) : + event(p_event) {} + }; + + Vector command_buffers; + + Error _create_device() override; + Error _execute_and_present_barriers(CommandQueueID p_cmd_queue, VectorView p_wait_semaphores, VectorView p_cmd_buffers, VectorView p_cmd_semaphores, FenceID p_cmd_fence, VectorView p_swap_chains); + Error _execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_semaphores, VectorView p_cmd_buffers, VectorView p_cmd_semaphores, FenceID p_cmd_fence, VectorView p_swap_chains); + +protected: + MTL::CommandQueue *get_command_queue() const override { return device_queue.get(); } + void add_residency_set_to_main_queue(MTL::ResidencySet *p_set) override; + void remove_residency_set_to_main_queue(MTL::ResidencySet *p_set) override; + +public: + Error initialize(uint32_t p_device_index, uint32_t p_frame_count) override; + + FenceID fence_create() override; + Error fence_wait(FenceID p_fence) override; + void fence_free(FenceID p_fence) override; + + SemaphoreID semaphore_create() override; + void semaphore_free(SemaphoreID p_semaphore) override; + + CommandQueueID command_queue_create(CommandQueueFamilyID p_cmd_queue_family, bool p_identify_as_main_queue = false) override; + Error command_queue_execute_and_present(CommandQueueID p_cmd_queue, VectorView p_wait_semaphores, VectorView p_cmd_buffers, VectorView p_cmd_semaphores, FenceID p_cmd_fence, VectorView p_swap_chains) override; + void command_queue_free(CommandQueueID p_cmd_queue) override; + + CommandPoolID command_pool_create(CommandQueueFamilyID p_cmd_queue_family, CommandBufferType p_cmd_buffer_type) override; + bool command_pool_reset(CommandPoolID p_cmd_pool) override; + void command_pool_free(CommandPoolID p_cmd_pool) override; + + CommandBufferID command_buffer_create(CommandPoolID p_cmd_pool) override; + +#pragma mark - Miscellaneous + + String get_api_name() const override { return "Metal"; } + + RenderingDeviceDriverMetal(RenderingContextDriverMetal *p_context_driver); + ~RenderingDeviceDriverMetal(); +}; + +} // namespace MTL3 diff --git a/drivers/metal/rendering_shader_container_metal.mm b/drivers/metal/rendering_shader_container_metal.cpp similarity index 85% rename from drivers/metal/rendering_shader_container_metal.mm rename to drivers/metal/rendering_shader_container_metal.cpp index 6fc95e08f0..2c74d33bb3 100644 --- a/drivers/metal/rendering_shader_container_metal.mm +++ b/drivers/metal/rendering_shader_container_metal.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* rendering_shader_container_metal.mm */ +/* rendering_shader_container_metal.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -28,21 +28,21 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ -#import "rendering_shader_container_metal.h" +#include "rendering_shader_container_metal.h" -#import "metal_utils.h" +#include "metal_utils.h" -#import "core/io/file_access.h" -#import "core/io/marshalls.h" -#import "core/templates/fixed_vector.h" -#import "servers/rendering/rendering_device.h" +#include "core/io/file_access.h" +#include "core/io/marshalls.h" +#include "core/templates/fixed_vector.h" +#include "servers/rendering/rendering_device.h" #include "thirdparty/spirv-reflect/spirv_reflect.h" -#import -#import -#import -#import +#include +#include +#include +#include void RenderingShaderContainerMetal::_initialize_toolchain_properties() { if (compiler_props.is_valid()) { @@ -236,6 +236,74 @@ spv::ExecutionModel map_stage(RDD::ShaderStage p_stage) { return SHADER_STAGE_REMAP[p_stage]; } +Error RenderingShaderContainerMetal::reflect_spirv(const ReflectShader &p_shader) { + // const LocalVector &p_spirv = p_shader.shader_stages; + // + // using ShaderStage = RenderingDeviceCommons::ShaderStage; + // + // const uint32_t spirv_size = p_spirv.size(); + // + // HashSet atomic_spirv_ids; + // bool atomics_scanned = false; + // auto scan_atomic_accesses = [&atomic_spirv_ids, &p_spirv, spirv_size, &atomics_scanned]() { + // if (atomics_scanned) { + // return; + // } + // + // for (uint32_t i = 0; i < spirv_size + 0; i++) { + // const uint32_t STARTING_WORD_INDEX = 5; + // Span spirv = p_spirv[i].spirv(); + // const uint32_t *words = spirv.ptr() + STARTING_WORD_INDEX; + // while (words < spirv.end()) { + // uint32_t instruction = *words; + // uint16_t word_count = instruction >> 16; + // SpvOp opcode = (SpvOp)(instruction & 0xFFFF); + // if (opcode == SpvOpImageTexelPointer) { + // uint32_t image_var_id = words[3]; + // atomic_spirv_ids.insert(image_var_id); + // } + // words += word_count; + // } + // } + // + // atomics_scanned = true; + // }; + // + // for (uint32_t i = 0; i < spirv_size + 0; i++) { + // ShaderStage stage = p_spirv[i].shader_stage; + // ShaderStage stage_flag = (ShaderStage)(1 << p_spirv[i].shader_stage); + // SpvReflectResult result; + // + // const SpvReflectShaderModule &module = p_spirv[i].module(); + // + // uint32_t binding_count = 0; + // result = spvReflectEnumerateDescriptorBindings(&module, &binding_count, nullptr); + // CRASH_COND(result != SPV_REFLECT_RESULT_SUCCESS); + // + // if (binding_count > 0) { + // LocalVector bindings; + // bindings.resize_uninitialized(binding_count); + // result = spvReflectEnumerateDescriptorBindings(&module, &binding_count, bindings.ptr()); + // + // for (uint32_t j = 0; j < binding_count; j++) { + // const SpvReflectDescriptorBinding &binding = *bindings[j]; + // + // switch (binding.descriptor_type) { + // case SPV_REFLECT_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: + // case SPV_REFLECT_DESCRIPTOR_TYPE_SAMPLED_IMAGE: + // case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE: + // case SPV_REFLECT_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: + // break; + // default: + // break; + // } + // } + // } + // } + // + return OK; +} + bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_shader) { using namespace spirv_cross; using spirv_cross::CompilerMSL; @@ -282,12 +350,7 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ msl_options.ios_support_base_vertex_instance = true; } - // We don't currently allow argument buffers when using dynamic buffers as - // the current implementation does not update the argument buffer each time - // the dynamic buffer changes. This is a future TODO. - bool argument_buffers_allowed = get_shader_reflection().has_dynamic_buffers == false; - - if (device_profile->features.use_argument_buffers && argument_buffers_allowed) { + if (device_profile->features.use_argument_buffers) { msl_options.argument_buffers_tier = CompilerMSL::Options::ArgumentBuffersTier::Tier2; msl_options.argument_buffers = true; mtl_reflection_data.set_uses_argument_buffers(true); @@ -384,9 +447,9 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_IMAGE: { if (!(binding.decoration_flags & SPV_REFLECT_DECORATION_NON_WRITABLE)) { if (!(binding.decoration_flags & SPV_REFLECT_DECORATION_NON_READABLE)) { - found->access = MTLBindingAccessReadWrite; + found->access = MTL::BindingAccessReadWrite; } else { - found->access = MTLBindingAccessWriteOnly; + found->access = MTL::BindingAccessWriteOnly; } } } break; @@ -394,9 +457,9 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ case SPV_REFLECT_DESCRIPTOR_TYPE_STORAGE_BUFFER: { if (!(binding.decoration_flags & SPV_REFLECT_DECORATION_NON_WRITABLE) && !(binding.block.decoration_flags & SPV_REFLECT_DECORATION_NON_WRITABLE)) { if (!(binding.decoration_flags & SPV_REFLECT_DECORATION_NON_READABLE) && !(binding.block.decoration_flags & SPV_REFLECT_DECORATION_NON_READABLE)) { - found->access = MTLBindingAccessReadWrite; + found->access = MTL::BindingAccessReadWrite; } else { - found->access = MTLBindingAccessWriteOnly; + found->access = MTL::BindingAccessWriteOnly; } } } break; @@ -405,14 +468,14 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ } switch (found->access) { - case MTLBindingAccessReadOnly: - found->usage = MTLResourceUsageRead; + case MTL::BindingAccessReadOnly: + found->usage = MTL::ResourceUsageRead; break; - case MTLBindingAccessWriteOnly: - found->usage = MTLResourceUsageWrite; + case MTL::BindingAccessWriteOnly: + found->usage = MTL::ResourceUsageWrite; break; - case MTLBindingAccessReadWrite: - found->usage = MTLResourceUsageRead | MTLResourceUsageWrite; + case MTL::BindingAccessReadWrite: + found->usage = MTL::ResourceUsageRead | MTL::ResourceUsageWrite; break; } @@ -424,7 +487,7 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ switch (type) { case RDC::UNIFORM_TYPE_SAMPLER: { - found->data_type = MTLDataTypeSampler; + found->data_type = MTL::DataTypeSampler; found->get_indexes(UniformData::IndexType::SLOT).sampler = next_index(Sampler, binding_stride); found->get_indexes(UniformData::IndexType::ARG).sampler = next_arg_index(binding_stride); @@ -433,7 +496,7 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ } break; case RDC::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE: case RDC::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE_BUFFER: { - found->data_type = MTLDataTypeTexture; + found->data_type = MTL::DataTypeTexture; found->get_indexes(UniformData::IndexType::SLOT).texture = next_index(Texture, binding_stride); found->get_indexes(UniformData::IndexType::SLOT).sampler = next_index(Sampler, binding_stride); found->get_indexes(UniformData::IndexType::ARG).texture = next_arg_index(binding_stride); @@ -443,7 +506,7 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ case RDC::UNIFORM_TYPE_TEXTURE: case RDC::UNIFORM_TYPE_IMAGE: case RDC::UNIFORM_TYPE_TEXTURE_BUFFER: { - found->data_type = MTLDataTypeTexture; + found->data_type = MTL::DataTypeTexture; found->get_indexes(UniformData::IndexType::SLOT).texture = next_index(Texture, binding_stride); found->get_indexes(UniformData::IndexType::ARG).texture = next_arg_index(binding_stride); rb.basetype = SPIRType::BaseType::Image; @@ -455,13 +518,13 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ case RDC::UNIFORM_TYPE_STORAGE_BUFFER_DYNAMIC: case RDC::UNIFORM_TYPE_UNIFORM_BUFFER: case RDC::UNIFORM_TYPE_STORAGE_BUFFER: { - found->data_type = MTLDataTypePointer; + found->data_type = MTL::DataTypePointer; found->get_indexes(UniformData::IndexType::SLOT).buffer = next_index(Buffer, binding_stride); found->get_indexes(UniformData::IndexType::ARG).buffer = next_arg_index(binding_stride); rb.basetype = SPIRType::BaseType::Void; } break; case RDC::UNIFORM_TYPE_INPUT_ATTACHMENT: { - found->data_type = MTLDataTypeTexture; + found->data_type = MTL::DataTypeTexture; found->get_indexes(UniformData::IndexType::SLOT).texture = next_index(Texture, binding_stride); found->get_indexes(UniformData::IndexType::ARG).texture = next_arg_index(binding_stride); rb.basetype = SPIRType::BaseType::Image; @@ -476,44 +539,53 @@ bool RenderingShaderContainerMetal::_set_code_from_spirv(const ReflectShader &p_ rb.msl_texture = found->get_indexes(shader_index_type).texture; rb.msl_sampler = found->get_indexes(shader_index_type).sampler; - if (found->data_type == MTLDataTypeTexture) { + if (found->data_type == MTL::DataTypeTexture) { const SpvReflectImageTraits &image = uniform.get_spv_reflect().image; switch (image.dim) { case SpvDim1D: { if (image.arrayed) { - found->texture_type = MTLTextureType1DArray; + found->texture_type = MTL::TextureType1DArray; } else { - found->texture_type = MTLTextureType1D; + found->texture_type = MTL::TextureType1D; } } break; case SpvDimSubpassData: case SpvDim2D: { if (image.arrayed && image.ms) { - found->texture_type = MTLTextureType2DMultisampleArray; + found->texture_type = MTL::TextureType2DMultisampleArray; } else if (image.arrayed) { - found->texture_type = MTLTextureType2DArray; + found->texture_type = MTL::TextureType2DArray; } else if (image.ms) { - found->texture_type = MTLTextureType2DMultisample; + found->texture_type = MTL::TextureType2DMultisample; } else { - found->texture_type = MTLTextureType2D; + found->texture_type = MTL::TextureType2D; } } break; case SpvDim3D: { - found->texture_type = MTLTextureType3D; + found->texture_type = MTL::TextureType3D; } break; case SpvDimCube: { if (image.arrayed) { - found->texture_type = MTLTextureTypeCubeArray; + found->texture_type = MTL::TextureTypeCubeArray; } else { - found->texture_type = MTLTextureTypeCube; + found->texture_type = MTL::TextureTypeCube; } } break; case SpvDimRect: { // Ignored. } break; case SpvDimBuffer: { - found->texture_type = MTLTextureTypeTextureBuffer; + found->texture_type = MTL::TextureTypeTextureBuffer; + // If this is used with atomics, we need to use a read-write texture. + // scan_atomic_accesses(); + // if (atomic_spirv_ids.find(uniform.spirv_id) != atomic_spirv_ids.end()) { + // rb.access = MTLBindingAccessReadWrite; + // found->access = MTLBindingAccessReadWrite; + // } else { + // rb.access = MTLBindingAccessReadOnly; + // found->access = MTLBindingAccessReadOnly; + // } } break; case SpvDimTileImageDataEXT: { // Godot does not use this extension. diff --git a/drivers/metal/rendering_shader_container_metal.h b/drivers/metal/rendering_shader_container_metal.h index 24af5783db..13097b4ef4 100644 --- a/drivers/metal/rendering_shader_container_metal.h +++ b/drivers/metal/rendering_shader_container_metal.h @@ -30,11 +30,11 @@ #pragma once -#import "metal_device_profile.h" -#import "sha256_digest.h" +#include "metal_device_profile.h" +#include "sha256_digest.h" -#import "servers/rendering/rendering_device_driver.h" -#import "servers/rendering/rendering_shader_container.h" +#include "servers/rendering/rendering_device_driver.h" +#include "servers/rendering/rendering_shader_container.h" constexpr uint32_t R32UI_ALIGNMENT_CONSTANT_ID = 65535; /// Metal buffer index for the view mask when rendering multi-view. @@ -177,6 +177,8 @@ private: Error compile_metal_source(const char *p_source, const StageData &p_stage_data, Vector &r_binary_data); + Error reflect_spirv(const ReflectShader &p_shader); + public: static constexpr uint32_t FORMAT_VERSION = 2; diff --git a/drivers/metal/sha256_digest.h b/drivers/metal/sha256_digest.h index 6b477c959d..f54a745139 100644 --- a/drivers/metal/sha256_digest.h +++ b/drivers/metal/sha256_digest.h @@ -30,9 +30,9 @@ #pragma once -#import -#import -#import +#include +#include +#include #include "core/templates/hashfuncs.h" #include "core/templates/local_vector.h" diff --git a/platform/macos/display_server_embedded.mm b/platform/macos/display_server_embedded.mm index d0c9c6ab0e..d85d48ca37 100644 --- a/platform/macos/display_server_embedded.mm +++ b/platform/macos/display_server_embedded.mm @@ -160,7 +160,7 @@ DisplayServerEmbedded::DisplayServerEmbedded(const String &p_rendering_driver, W #endif #ifdef METAL_ENABLED if (rendering_driver == "metal") { - wpd.metal.layer = (CAMetalLayer *)layer; + wpd.metal.layer = (__bridge CA::MetalLayer *)layer; } #endif Error err = rendering_context->window_create(window_id_counter, &wpd); diff --git a/platform/macos/display_server_macos.mm b/platform/macos/display_server_macos.mm index 8c599eb8f3..74b31fa14c 100644 --- a/platform/macos/display_server_macos.mm +++ b/platform/macos/display_server_macos.mm @@ -73,6 +73,7 @@ #if defined(RD_ENABLED) #include "servers/rendering/renderer_rd/renderer_compositor_rd.h" +#include "servers/rendering/rendering_device.h" #endif #if defined(ACCESSKIT_ENABLED) @@ -185,7 +186,7 @@ DisplayServerMacOS::WindowID DisplayServerMacOS::_create_window(WindowMode p_mod #endif #ifdef METAL_ENABLED if (rendering_driver == "metal") { - wpd.metal.layer = (CAMetalLayer *)layer; + wpd.metal.layer = (__bridge CA::MetalLayer *)layer; } #endif Error err = rendering_context->window_create(window_id_counter, &wpd); diff --git a/servers/rendering/renderer_rd/effects/SCsub b/servers/rendering/renderer_rd/effects/SCsub index 30656a4225..e76f258923 100644 --- a/servers/rendering/renderer_rd/effects/SCsub +++ b/servers/rendering/renderer_rd/effects/SCsub @@ -7,6 +7,10 @@ Import("env") env_effects = env.Clone() +# metal-cpp headers for Metal FX +if env["metal"]: + env_effects.Prepend(CPPPATH=["#thirdparty/metal-cpp"]) + # Thirdparty source files thirdparty_obj = [] @@ -69,8 +73,6 @@ env.servers_sources += thirdparty_obj module_obj = [] env_effects.add_source_files(module_obj, "*.cpp") -if env["metal"]: - env_effects.add_source_files(module_obj, "metal_fx.mm") env.servers_sources += module_obj # Needed to force rebuilding the module files when the thirdparty library is updated. diff --git a/servers/rendering/renderer_rd/effects/metal_fx.mm b/servers/rendering/renderer_rd/effects/metal_fx.cpp similarity index 59% rename from servers/rendering/renderer_rd/effects/metal_fx.mm rename to servers/rendering/renderer_rd/effects/metal_fx.cpp index 0f6152d526..11d23a7791 100644 --- a/servers/rendering/renderer_rd/effects/metal_fx.mm +++ b/servers/rendering/renderer_rd/effects/metal_fx.cpp @@ -1,5 +1,5 @@ /**************************************************************************/ -/* metal_fx.mm */ +/* metal_fx.cpp */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ @@ -28,20 +28,24 @@ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ -#import "metal_fx.h" +#ifdef METAL_ENABLED -#import "../storage_rd/render_scene_buffers_rd.h" -#import "drivers/metal/pixel_formats.h" -#import "drivers/metal/rendering_device_driver_metal.h" +#include "metal_fx.h" -#import -#import +#include "../storage_rd/render_scene_buffers_rd.h" +#include "drivers/metal/pixel_formats.h" +#include "drivers/metal/rendering_device_driver_metal3.h" + +#include using namespace RendererRD; #pragma mark - Spatial Scaler MFXSpatialContext::~MFXSpatialContext() { + if (scaler) { + scaler->release(); + } } MFXSpatialEffect::MFXSpatialEffect() { @@ -51,28 +55,21 @@ MFXSpatialEffect::~MFXSpatialEffect() { } void MFXSpatialEffect::callback(RDD *p_driver, RDD::CommandBufferID p_command_buffer, CallbackArgs *p_userdata) { - GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") - - MDCommandBuffer *obj = (MDCommandBuffer *)(p_command_buffer.id); + MDCommandBufferBase *obj = (MDCommandBufferBase *)(p_command_buffer.id); obj->end(); - id src_texture = rid::get(p_userdata->src); - id dst_texture = rid::get(p_userdata->dst); + MTL::Texture *src_texture = reinterpret_cast(p_userdata->src.id); + MTL::Texture *dst_texture = reinterpret_cast(p_userdata->dst.id); - __block id scaler = p_userdata->ctx.scaler; - scaler.colorTexture = src_texture; - scaler.outputTexture = dst_texture; - [scaler encodeToCommandBuffer:obj->get_command_buffer()]; - // TODO(sgc): add API to retain objects until the command buffer completes - [obj->get_command_buffer() addCompletedHandler:^(id _Nonnull) { - // This block retains a reference to the scaler until the command buffer. - // completes. - scaler = nil; - }]; + MTLFX::SpatialScalerBase *scaler = p_userdata->scaler; + scaler->setColorTexture(src_texture); + scaler->setOutputTexture(dst_texture); + MTLFX::SpatialScaler *s = static_cast(scaler); + MTL3::MDCommandBuffer *cmd = (MTL3::MDCommandBuffer *)(p_command_buffer.id); + s->encodeToCommandBuffer(cmd->get_command_buffer()); + obj->retain_resource(scaler); CallbackArgs::free(&p_userdata); - - GODOT_CLANG_WARNING_POP } void MFXSpatialEffect::ensure_context(Ref p_render_buffers) { @@ -98,27 +95,23 @@ void MFXSpatialEffect::process(Ref p_render_buffers, RID p MFXSpatialContext *MFXSpatialEffect::create_context(CreateParams p_params) const { DEV_ASSERT(RD::get_singleton()->has_feature(RD::SUPPORTS_METALFX_SPATIAL)); - GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") - RenderingDeviceDriverMetal *rdd = (RenderingDeviceDriverMetal *)RD::get_singleton()->get_device_driver(); PixelFormats &pf = rdd->get_pixel_formats(); - id dev = rdd->get_device(); + MTL::Device *dev = rdd->get_device(); - MTLFXSpatialScalerDescriptor *desc = [MTLFXSpatialScalerDescriptor new]; - desc.inputWidth = (NSUInteger)p_params.input_size.width; - desc.inputHeight = (NSUInteger)p_params.input_size.height; + NS::SharedPtr desc = NS::TransferPtr(MTLFX::SpatialScalerDescriptor::alloc()->init()); + desc->setInputWidth((NS::UInteger)p_params.input_size.width); + desc->setInputHeight((NS::UInteger)p_params.input_size.height); - desc.outputWidth = (NSUInteger)p_params.output_size.width; - desc.outputHeight = (NSUInteger)p_params.output_size.height; + desc->setOutputWidth((NS::UInteger)p_params.output_size.width); + desc->setOutputHeight((NS::UInteger)p_params.output_size.height); + + desc->setColorTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.input_format)); + desc->setOutputTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.output_format)); + desc->setColorProcessingMode(MTLFX::SpatialScalerColorProcessingModeLinear); - desc.colorTextureFormat = pf.getMTLPixelFormat(p_params.input_format); - desc.outputTextureFormat = pf.getMTLPixelFormat(p_params.output_format); - desc.colorProcessingMode = MTLFXSpatialScalerColorProcessingModeLinear; - id scaler = [desc newSpatialScalerWithDevice:dev]; MFXSpatialContext *context = memnew(MFXSpatialContext); - context->scaler = scaler; - - GODOT_CLANG_WARNING_POP + context->scaler = desc->newSpatialScaler(dev); return context; } @@ -127,7 +120,11 @@ MFXSpatialContext *MFXSpatialEffect::create_context(CreateParams p_params) const #pragma mark - Temporal Scaler -MFXTemporalContext::~MFXTemporalContext() {} +MFXTemporalContext::~MFXTemporalContext() { + if (scaler) { + scaler->release(); + } +} MFXTemporalEffect::MFXTemporalEffect() {} MFXTemporalEffect::~MFXTemporalEffect() {} @@ -135,35 +132,29 @@ MFXTemporalEffect::~MFXTemporalEffect() {} MFXTemporalContext *MFXTemporalEffect::create_context(CreateParams p_params) const { DEV_ASSERT(RD::get_singleton()->has_feature(RD::SUPPORTS_METALFX_TEMPORAL)); - GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") - RenderingDeviceDriverMetal *rdd = (RenderingDeviceDriverMetal *)RD::get_singleton()->get_device_driver(); PixelFormats &pf = rdd->get_pixel_formats(); - id dev = rdd->get_device(); + MTL::Device *dev = rdd->get_device(); - MTLFXTemporalScalerDescriptor *desc = [MTLFXTemporalScalerDescriptor new]; - desc.inputWidth = (NSUInteger)p_params.input_size.width; - desc.inputHeight = (NSUInteger)p_params.input_size.height; + NS::SharedPtr desc = NS::TransferPtr(MTLFX::TemporalScalerDescriptor::alloc()->init()); + desc->setInputWidth((NS::UInteger)p_params.input_size.width); + desc->setInputHeight((NS::UInteger)p_params.input_size.height); - desc.outputWidth = (NSUInteger)p_params.output_size.width; - desc.outputHeight = (NSUInteger)p_params.output_size.height; + desc->setOutputWidth((NS::UInteger)p_params.output_size.width); + desc->setOutputHeight((NS::UInteger)p_params.output_size.height); - desc.colorTextureFormat = pf.getMTLPixelFormat(p_params.input_format); - desc.depthTextureFormat = pf.getMTLPixelFormat(p_params.depth_format); - desc.motionTextureFormat = pf.getMTLPixelFormat(p_params.motion_format); - desc.autoExposureEnabled = NO; + desc->setColorTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.input_format)); + desc->setDepthTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.depth_format)); + desc->setMotionTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.motion_format)); + desc->setAutoExposureEnabled(false); - desc.outputTextureFormat = pf.getMTLPixelFormat(p_params.output_format); + desc->setOutputTextureFormat((MTL::PixelFormat)pf.getMTLPixelFormat(p_params.output_format)); - id scaler = [desc newTemporalScalerWithDevice:dev]; MFXTemporalContext *context = memnew(MFXTemporalContext); - context->scaler = scaler; - - scaler.motionVectorScaleX = p_params.motion_vector_scale.x; - scaler.motionVectorScaleY = p_params.motion_vector_scale.y; - scaler.depthReversed = true; // Godot uses reverse Z per https://github.com/godotengine/godot/pull/88328 - - GODOT_CLANG_WARNING_POP + context->scaler = desc->newTemporalScaler(dev); + context->scaler->setMotionVectorScaleX(p_params.motion_vector_scale.x); + context->scaler->setMotionVectorScaleY(p_params.motion_vector_scale.y); + context->scaler->setDepthReversed(true); // Godot uses reverse Z per https://github.com/godotengine/godot/pull/88328 return context; } @@ -188,38 +179,33 @@ void MFXTemporalEffect::process(RendererRD::MFXTemporalContext *p_ctx, RendererR } void MFXTemporalEffect::callback(RDD *p_driver, RDD::CommandBufferID p_command_buffer, CallbackArgs *p_userdata) { - GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability") - - MDCommandBuffer *obj = (MDCommandBuffer *)(p_command_buffer.id); + MDCommandBufferBase *obj = (MDCommandBufferBase *)(p_command_buffer.id); obj->end(); - id src_texture = rid::get(p_userdata->src); - id depth = rid::get(p_userdata->depth); - id motion = rid::get(p_userdata->motion); - id exposure = rid::get(p_userdata->exposure); + MTL::Texture *src_texture = reinterpret_cast(p_userdata->src.id); + MTL::Texture *depth = reinterpret_cast(p_userdata->depth.id); + MTL::Texture *motion = reinterpret_cast(p_userdata->motion.id); + MTL::Texture *exposure = reinterpret_cast(p_userdata->exposure.id); - id dst_texture = rid::get(p_userdata->dst); + MTL::Texture *dst_texture = reinterpret_cast(p_userdata->dst.id); - __block id scaler = p_userdata->ctx.scaler; - scaler.reset = p_userdata->reset; - scaler.colorTexture = src_texture; - scaler.depthTexture = depth; - scaler.motionTexture = motion; - scaler.exposureTexture = exposure; - scaler.jitterOffsetX = p_userdata->jitter_offset.x; - scaler.jitterOffsetY = p_userdata->jitter_offset.y; - scaler.outputTexture = dst_texture; - [scaler encodeToCommandBuffer:obj->get_command_buffer()]; - // TODO(sgc): add API to retain objects until the command buffer completes - [obj->get_command_buffer() addCompletedHandler:^(id _Nonnull) { - // This block retains a reference to the scaler until the command buffer. - // completes. - scaler = nil; - }]; + MTLFX::TemporalScalerBase *scaler = p_userdata->scaler; + scaler->setReset(p_userdata->reset); + scaler->setColorTexture(src_texture); + scaler->setDepthTexture(depth); + scaler->setMotionTexture(motion); + scaler->setExposureTexture(exposure); + scaler->setJitterOffsetX(p_userdata->jitter_offset.x); + scaler->setJitterOffsetY(p_userdata->jitter_offset.y); + scaler->setOutputTexture(dst_texture); + MTLFX::TemporalScaler *s = static_cast(scaler); + MTL3::MDCommandBuffer *cmd = (MTL3::MDCommandBuffer *)(p_command_buffer.id); + s->encodeToCommandBuffer(cmd->get_command_buffer()); + obj->retain_resource(scaler); CallbackArgs::free(&p_userdata); - - GODOT_CLANG_WARNING_POP } #endif + +#endif diff --git a/servers/rendering/renderer_rd/effects/metal_fx.h b/servers/rendering/renderer_rd/effects/metal_fx.h index b2a68aa1f9..7b6c1a215b 100644 --- a/servers/rendering/renderer_rd/effects/metal_fx.h +++ b/servers/rendering/renderer_rd/effects/metal_fx.h @@ -41,32 +41,28 @@ #include "core/templates/paged_allocator.h" #include "servers/rendering/renderer_scene_render.h" -#ifdef __OBJC__ -@protocol MTLFXSpatialScaler; -@protocol MTLFXTemporalScaler; -#endif +namespace MTLFX { +class SpatialScalerBase; +class TemporalScalerBase; +} //namespace MTLFX namespace RendererRD { struct MFXSpatialContext { -#ifdef __OBJC__ - id scaler = nullptr; -#else - void *scaler = nullptr; -#endif + MTLFX::SpatialScalerBase *scaler = nullptr; MFXSpatialContext() = default; ~MFXSpatialContext(); }; class MFXSpatialEffect : public SpatialUpscaler { struct CallbackArgs { - MFXSpatialEffect *owner; + MFXSpatialEffect *owner = nullptr; + MTLFX::SpatialScalerBase *scaler = nullptr; RDD::TextureID src; RDD::TextureID dst; - MFXSpatialContext ctx; - CallbackArgs(MFXSpatialEffect *p_owner, RDD::TextureID p_src, RDD::TextureID p_dst, MFXSpatialContext p_ctx) : - owner(p_owner), src(p_src), dst(p_dst), ctx(p_ctx) {} + CallbackArgs(MFXSpatialEffect *p_owner, RDD::TextureID p_src, RDD::TextureID p_dst, const MFXSpatialContext &p_ctx) : + owner(p_owner), scaler(p_ctx.scaler), src(p_src), dst(p_dst) {} static void free(CallbackArgs **p_args) { (*p_args)->owner->args_allocator.free(*p_args); @@ -98,25 +94,21 @@ public: #ifdef METAL_MFXTEMPORAL_ENABLED struct MFXTemporalContext { -#ifdef __OBJC__ - id scaler = nullptr; -#else - void *scaler = nullptr; -#endif + MTLFX::TemporalScalerBase *scaler = nullptr; MFXTemporalContext() = default; ~MFXTemporalContext(); }; class MFXTemporalEffect { struct CallbackArgs { - MFXTemporalEffect *owner; + MFXTemporalEffect *owner = nullptr; + MTLFX::TemporalScalerBase *scaler = nullptr; RDD::TextureID src; RDD::TextureID depth; RDD::TextureID motion; RDD::TextureID exposure; Vector2 jitter_offset; RDD::TextureID dst; - MFXTemporalContext ctx; bool reset = false; CallbackArgs( @@ -127,16 +119,16 @@ class MFXTemporalEffect { RDD::TextureID p_exposure, Vector2 p_jitter_offset, RDD::TextureID p_dst, - MFXTemporalContext p_ctx, + const MFXTemporalContext &p_ctx, bool p_reset) : owner(p_owner), + scaler(p_ctx.scaler), src(p_src), depth(p_depth), motion(p_motion), exposure(p_exposure), jitter_offset(p_jitter_offset), dst(p_dst), - ctx(p_ctx), reset(p_reset) {} static void free(CallbackArgs **p_args) { diff --git a/thirdparty/README.md b/thirdparty/README.md index 8918dd2a84..eaa5cc960d 100644 --- a/thirdparty/README.md +++ b/thirdparty/README.md @@ -694,6 +694,18 @@ Patches: - `0001-msvc-2019-psa-redeclaration.patch` ([GH-90535](https://github.com/godotengine/godot/pull/90535)) +## metal-cpp + +- Upstream: https://developer.apple.com/metal/cpp/ +- Version: 26.0 (2025) +- License: Apache 2.0 + +Update instructions: + +- Download latest metal-cpp ZIP from https://developer.apple.com/metal/cpp/: +- Run `update-metal-cpp.sh ` to extract the relevant files and apply patches. + + ## meshoptimizer - Upstream: https://github.com/zeux/meshoptimizer diff --git a/thirdparty/metal-cpp/Foundation/Foundation.hpp b/thirdparty/metal-cpp/Foundation/Foundation.hpp new file mode 100644 index 0000000000..31e8fb3cbb --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/Foundation.hpp @@ -0,0 +1,47 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/Foundation.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSArray.hpp" +#include "NSAutoreleasePool.hpp" +#include "NSBundle.hpp" +#include "NSData.hpp" +#include "NSDate.hpp" +#include "NSDefines.hpp" +#include "NSDictionary.hpp" +#include "NSEnumerator.hpp" +#include "NSError.hpp" +#include "NSLock.hpp" +#include "NSNotification.hpp" +#include "NSNumber.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSProcessInfo.hpp" +#include "NSRange.hpp" +#include "NSSet.hpp" +#include "NSSharedPtr.hpp" +#include "NSString.hpp" +#include "NSTypes.hpp" +#include "NSURL.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSArray.hpp b/thirdparty/metal-cpp/Foundation/NSArray.hpp new file mode 100644 index 0000000000..ea04d1ea3d --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSArray.hpp @@ -0,0 +1,124 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSArray.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSObject.hpp" +#include "NSTypes.hpp" +#include "NSEnumerator.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class Array : public Copying +{ +public: + static Array* array(); + static Array* array(const Object* pObject); + static Array* array(const Object* const* pObjects, UInteger count); + + static Array* alloc(); + + Array* init(); + Array* init(const Object* const* pObjects, UInteger count); + Array* init(const class Coder* pCoder); + + template + _Object* object(UInteger index) const; + UInteger count() const; + Enumerator* objectEnumerator() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::array() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(array)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::array(const Object* pObject) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObject_), pObject); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::array(const Object* const* pObjects, UInteger count) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSArray), _NS_PRIVATE_SEL(arrayWithObjects_count_), pObjects, count); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSArray)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::init() +{ + return NS::Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::init(const Object* const* pObjects, UInteger count) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Array::init(const class Coder* pCoder) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Array::count() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(count)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Object* NS::Array::object(UInteger index) const +{ + return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectAtIndex_), index); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Enumerator* NS::Array::objectEnumerator() const +{ + return NS::Object::sendMessage*>(this, _NS_PRIVATE_SEL(objectEnumerator)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSAutoreleasePool.hpp b/thirdparty/metal-cpp/Foundation/NSAutoreleasePool.hpp new file mode 100644 index 0000000000..6d01a465ff --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSAutoreleasePool.hpp @@ -0,0 +1,83 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSAutoreleasePool.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class AutoreleasePool : public Object +{ +public: + static AutoreleasePool* alloc(); + AutoreleasePool* init(); + + void drain(); + + void addObject(Object* pObject); + + static void showPools(); +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSAutoreleasePool)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::AutoreleasePool* NS::AutoreleasePool::init() +{ + return NS::Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::AutoreleasePool::drain() +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(drain)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::AutoreleasePool::addObject(Object* pObject) +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(addObject_), pObject); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::AutoreleasePool::showPools() +{ + Object::sendMessage(_NS_PRIVATE_CLS(NSAutoreleasePool), _NS_PRIVATE_SEL(showPools)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSBundle.hpp b/thirdparty/metal-cpp/Foundation/NSBundle.hpp new file mode 100644 index 0000000000..b9637f5172 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSBundle.hpp @@ -0,0 +1,374 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSBundle.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSNotification.hpp" +#include "NSObject.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +_NS_CONST(NotificationName, BundleDidLoadNotification); +_NS_CONST(NotificationName, BundleResourceRequestLowDiskSpaceNotification); + +class String* LocalizedString(const String* pKey, const String*); +class String* LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*); +class String* LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String*); +class String* LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const class Bundle* pBdle, const String* pVal, const String*); + +class Bundle : public Referencing +{ +public: + static Bundle* mainBundle(); + + static Bundle* bundle(const class String* pPath); + static Bundle* bundle(const class URL* pURL); + + static class Array* allBundles(); + static class Array* allFrameworks(); + + static Bundle* alloc(); + + Bundle* init(const class String* pPath); + Bundle* init(const class URL* pURL); + + bool load(); + bool unload(); + + bool isLoaded() const; + + bool preflightAndReturnError(class Error** pError) const; + bool loadAndReturnError(class Error** pError); + + class URL* bundleURL() const; + class URL* resourceURL() const; + class URL* executableURL() const; + class URL* URLForAuxiliaryExecutable(const class String* pExecutableName) const; + + class URL* privateFrameworksURL() const; + class URL* sharedFrameworksURL() const; + class URL* sharedSupportURL() const; + class URL* builtInPlugInsURL() const; + class URL* appStoreReceiptURL() const; + + class String* bundlePath() const; + class String* resourcePath() const; + class String* executablePath() const; + class String* pathForAuxiliaryExecutable(const class String* pExecutableName) const; + + class String* privateFrameworksPath() const; + class String* sharedFrameworksPath() const; + class String* sharedSupportPath() const; + class String* builtInPlugInsPath() const; + + class String* bundleIdentifier() const; + class Dictionary* infoDictionary() const; + class Dictionary* localizedInfoDictionary() const; + class Object* objectForInfoDictionaryKey(const class String* pKey); + + class String* localizedString(const class String* pKey, const class String* pValue = nullptr, const class String* pTableName = nullptr) const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleDidLoadNotification); +_NS_PRIVATE_DEF_CONST(NS::NotificationName, BundleResourceRequestLowDiskSpaceNotification); + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::LocalizedString(const String* pKey, const String*) +{ + return Bundle::mainBundle()->localizedString(pKey, nullptr, nullptr); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::LocalizedStringFromTable(const String* pKey, const String* pTbl, const String*) +{ + return Bundle::mainBundle()->localizedString(pKey, nullptr, pTbl); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::LocalizedStringFromTableInBundle(const String* pKey, const String* pTbl, const Bundle* pBdl, const String*) +{ + return pBdl->localizedString(pKey, nullptr, pTbl); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::LocalizedStringWithDefaultValue(const String* pKey, const String* pTbl, const Bundle* pBdl, const String* pVal, const String*) +{ + return pBdl->localizedString(pKey, pVal, pTbl); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::mainBundle() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(mainBundle)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class String* pPath) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithPath_), pPath); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::bundle(const class URL* pURL) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(bundleWithURL_), pURL); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Bundle::allBundles() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(allBundles)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Bundle::allFrameworks() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(allFrameworks)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::alloc() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSBundle), _NS_PRIVATE_SEL(alloc)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::init(const String* pPath) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithPath_), pPath); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Bundle* NS::Bundle::init(const URL* pURL) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithURL_), pURL); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Bundle::load() +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(load)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Bundle::unload() +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unload)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Bundle::isLoaded() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(isLoaded)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Bundle::preflightAndReturnError(Error** pError) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(preflightAndReturnError_), pError); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Bundle::loadAndReturnError(Error** pError) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(loadAndReturnError_), pError); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::bundleURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(bundleURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::resourceURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(resourceURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::executableURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(executableURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::URLForAuxiliaryExecutable(const String* pExecutableName) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(URLForAuxiliaryExecutable_), pExecutableName); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::privateFrameworksURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(privateFrameworksURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::sharedFrameworksURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(sharedFrameworksURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::sharedSupportURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(sharedSupportURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::builtInPlugInsURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(builtInPlugInsURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::Bundle::appStoreReceiptURL() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(appStoreReceiptURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::bundlePath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(bundlePath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::resourcePath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(resourcePath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::executablePath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(executablePath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::pathForAuxiliaryExecutable(const String* pExecutableName) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(pathForAuxiliaryExecutable_), pExecutableName); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::privateFrameworksPath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(privateFrameworksPath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::sharedFrameworksPath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(sharedFrameworksPath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::sharedSupportPath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(sharedSupportPath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::builtInPlugInsPath() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(builtInPlugInsPath)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::bundleIdentifier() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(bundleIdentifier)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Bundle::infoDictionary() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(infoDictionary)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Bundle::localizedInfoDictionary() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedInfoDictionary)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Object* NS::Bundle::objectForInfoDictionaryKey(const String* pKey) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(objectForInfoDictionaryKey_), pKey); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Bundle::localizedString(const String* pKey, const String* pValue /* = nullptr */, const String* pTableName /* = nullptr */) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedStringForKey_value_table_), pKey, pValue, pTableName); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSData.hpp b/thirdparty/metal-cpp/Foundation/NSData.hpp new file mode 100644 index 0000000000..fbf3f20343 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSData.hpp @@ -0,0 +1,60 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSData.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSObject.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class Data : public Copying +{ +public: + void* mutableBytes() const; + void* bytes() const; + UInteger length() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void* NS::Data::mutableBytes() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(mutableBytes)); +} + +_NS_INLINE void* NS::Data::bytes() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(bytes)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Data::length() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(length)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSDate.hpp b/thirdparty/metal-cpp/Foundation/NSDate.hpp new file mode 100644 index 0000000000..0a5ec7ddb4 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSDate.hpp @@ -0,0 +1,53 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSDate.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ + +using TimeInterval = double; + +class Date : public Copying +{ +public: + static Date* dateWithTimeIntervalSinceNow(TimeInterval secs); +}; + +} // NS + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Date* NS::Date::dateWithTimeIntervalSinceNow(NS::TimeInterval secs) +{ + return NS::Object::sendMessage(_NS_PRIVATE_CLS(NSDate), _NS_PRIVATE_SEL(dateWithTimeIntervalSinceNow_), secs); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/thirdparty/metal-cpp/Foundation/NSDefines.hpp b/thirdparty/metal-cpp/Foundation/NSDefines.hpp new file mode 100644 index 0000000000..33bef73268 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSDefines.hpp @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSDefines.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +// Forward declarations to avoid conflicts with Godot types (String, Object, Error) +namespace NS { +class Array; +class Dictionary; +class Error; +class Object; +class String; +class URL; +} // namespace NS + +#define _NS_WEAK_IMPORT __attribute__((weak_import)) +#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN +#define _NS_EXPORT __attribute__((visibility("hidden"))) +#else +#define _NS_EXPORT __attribute__((visibility("default"))) +#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN +#define _NS_EXTERN extern "C" _NS_EXPORT +#define _NS_INLINE inline __attribute__((always_inline)) +#define _NS_PACKED __attribute__((packed)) + +#define _NS_CONST(type, name) _NS_EXTERN type const name +#define _NS_ENUM(type, name) enum name : type +#define _NS_OPTIONS(type, name) \ + using name = type; \ + enum : name + +#define _NS_CAST_TO_UINT(value) static_cast(value) +#define _NS_VALIDATE_SIZE(ns, name) static_assert(sizeof(ns::name) == sizeof(ns##name), "size mismatch " #ns "::" #name) +#define _NS_VALIDATE_ENUM(ns, name) static_assert(_NS_CAST_TO_UINT(ns::name) == _NS_CAST_TO_UINT(ns##name), "value mismatch " #ns "::" #name) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSDictionary.hpp b/thirdparty/metal-cpp/Foundation/NSDictionary.hpp new file mode 100644 index 0000000000..d4a1519d5b --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSDictionary.hpp @@ -0,0 +1,128 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSDictionary.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSEnumerator.hpp" +#include "NSObject.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class Dictionary : public NS::Copying +{ +public: + static Dictionary* dictionary(); + static Dictionary* dictionary(const Object* pObject, const Object* pKey); + static Dictionary* dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count); + + static Dictionary* alloc(); + + Dictionary* init(); + Dictionary* init(const Object* const* pObjects, const Object* const* pKeys, UInteger count); + Dictionary* init(const class Coder* pCoder); + + template + Enumerator<_KeyType>* keyEnumerator() const; + + template + _Object* object(const Object* pKey) const; + UInteger count() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionary)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* pObject, const Object* pKey) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObject_forKey_), pObject, pKey); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::dictionary(const Object* const* pObjects, const Object* const* pKeys, UInteger count) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSDictionary), _NS_PRIVATE_SEL(dictionaryWithObjects_forKeys_count_), + pObjects, pKeys, count); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSDictionary)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::init() +{ + return NS::Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::init(const Object* const* pObjects, const Object* const* pKeys, UInteger count) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithObjects_forKeys_count_), pObjects, pKeys, count); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Dictionary::init(const class Coder* pCoder) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE NS::Enumerator<_KeyType>* NS::Dictionary::keyEnumerator() const +{ + return Object::sendMessage*>(this, _NS_PRIVATE_SEL(keyEnumerator)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Object* NS::Dictionary::object(const Object* pKey) const +{ + return Object::sendMessage<_Object*>(this, _NS_PRIVATE_SEL(objectForKey_), pKey); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Dictionary::count() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(count)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSEnumerator.hpp b/thirdparty/metal-cpp/Foundation/NSEnumerator.hpp new file mode 100644 index 0000000000..5a2500c1e7 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSEnumerator.hpp @@ -0,0 +1,78 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSEnumerator.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSObject.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +struct FastEnumerationState +{ + unsigned long state; + Object** itemsPtr; + unsigned long* mutationsPtr; + unsigned long extra[5]; +} _NS_PACKED; + +class FastEnumeration : public Referencing +{ +public: + NS::UInteger countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len); +}; + +template +class Enumerator : public Referencing, FastEnumeration> +{ +public: + _ObjectType* nextObject(); + class Array* allObjects(); +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::FastEnumeration::countByEnumerating(FastEnumerationState* pState, Object** pBuffer, NS::UInteger len) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(countByEnumeratingWithState_objects_count_), pState, pBuffer, len); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _ObjectType* NS::Enumerator<_ObjectType>::nextObject() +{ + return Object::sendMessage<_ObjectType*>(this, _NS_PRIVATE_SEL(nextObject)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE NS::Array* NS::Enumerator<_ObjectType>::allObjects() +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(allObjects)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSError.hpp b/thirdparty/metal-cpp/Foundation/NSError.hpp new file mode 100644 index 0000000000..ea331d46e4 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSError.hpp @@ -0,0 +1,173 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSError.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +using ErrorDomain = class String*; + +_NS_CONST(ErrorDomain, CocoaErrorDomain); +_NS_CONST(ErrorDomain, POSIXErrorDomain); +_NS_CONST(ErrorDomain, OSStatusErrorDomain); +_NS_CONST(ErrorDomain, MachErrorDomain); + +using ErrorUserInfoKey = class String*; + +_NS_CONST(ErrorUserInfoKey, UnderlyingErrorKey); +_NS_CONST(ErrorUserInfoKey, LocalizedDescriptionKey); +_NS_CONST(ErrorUserInfoKey, LocalizedFailureReasonErrorKey); +_NS_CONST(ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey); +_NS_CONST(ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey); +_NS_CONST(ErrorUserInfoKey, RecoveryAttempterErrorKey); +_NS_CONST(ErrorUserInfoKey, HelpAnchorErrorKey); +_NS_CONST(ErrorUserInfoKey, DebugDescriptionErrorKey); +_NS_CONST(ErrorUserInfoKey, LocalizedFailureErrorKey); +_NS_CONST(ErrorUserInfoKey, StringEncodingErrorKey); +_NS_CONST(ErrorUserInfoKey, URLErrorKey); +_NS_CONST(ErrorUserInfoKey, FilePathErrorKey); + +class Error : public Copying +{ +public: + static Error* error(ErrorDomain domain, Integer code, class Dictionary* pDictionary); + + static Error* alloc(); + Error* init(); + Error* init(ErrorDomain domain, Integer code, class Dictionary* pDictionary); + + Integer code() const; + ErrorDomain domain() const; + class Dictionary* userInfo() const; + + class String* localizedDescription() const; + class Array* localizedRecoveryOptions() const; + class String* localizedRecoverySuggestion() const; + class String* localizedFailureReason() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, CocoaErrorDomain); +_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, POSIXErrorDomain); +_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, OSStatusErrorDomain); +_NS_PRIVATE_DEF_CONST(NS::ErrorDomain, MachErrorDomain); + +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, UnderlyingErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedDescriptionKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureReasonErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoverySuggestionErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedRecoveryOptionsErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, RecoveryAttempterErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, HelpAnchorErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, DebugDescriptionErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, LocalizedFailureErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, StringEncodingErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, URLErrorKey); +_NS_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, FilePathErrorKey); + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Error* NS::Error::error(ErrorDomain domain, Integer code, class Dictionary* pDictionary) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSError), _NS_PRIVATE_SEL(errorWithDomain_code_userInfo_), domain, code, pDictionary); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Error* NS::Error::alloc() +{ + return Object::alloc(_NS_PRIVATE_CLS(NSError)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Error* NS::Error::init() +{ + return Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Error* NS::Error::init(ErrorDomain domain, Integer code, class Dictionary* pDictionary) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithDomain_code_userInfo_), domain, code, pDictionary); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Integer NS::Error::code() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(code)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::ErrorDomain NS::Error::domain() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(domain)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Error::userInfo() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(userInfo)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Error::localizedDescription() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedDescription)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::Error::localizedRecoveryOptions() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedRecoveryOptions)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Error::localizedRecoverySuggestion() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedRecoverySuggestion)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Error::localizedFailureReason() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(localizedFailureReason)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSLock.hpp b/thirdparty/metal-cpp/Foundation/NSLock.hpp new file mode 100644 index 0000000000..01df219402 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSLock.hpp @@ -0,0 +1,118 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSLock.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" +#include "NSDate.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ + +template +class Locking : public _Base +{ +public: + void lock(); + void unlock(); +}; + +class Condition : public Locking +{ +public: + static Condition* alloc(); + + Condition* init(); + + void wait(); + bool waitUntilDate(Date* pLimit); + void signal(); + void broadcast(); +}; + +} // NS + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE void NS::Locking<_Class, _Base>::lock() +{ + NS::Object::sendMessage(this, _NS_PRIVATE_SEL(lock)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE void NS::Locking<_Class, _Base>::unlock() +{ + NS::Object::sendMessage(this, _NS_PRIVATE_SEL(unlock)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Condition* NS::Condition::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSCondition)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Condition* NS::Condition::init() +{ + return NS::Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::Condition::wait() +{ + NS::Object::sendMessage(this, _NS_PRIVATE_SEL(wait)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Condition::waitUntilDate(NS::Date* pLimit) +{ + return NS::Object::sendMessage(this, _NS_PRIVATE_SEL(waitUntilDate_), pLimit); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::Condition::signal() +{ + NS::Object::sendMessage(this, _NS_PRIVATE_SEL(signal)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::Condition::broadcast() +{ + NS::Object::sendMessage(this, _NS_PRIVATE_SEL(broadcast)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- \ No newline at end of file diff --git a/thirdparty/metal-cpp/Foundation/NSNotification.hpp b/thirdparty/metal-cpp/Foundation/NSNotification.hpp new file mode 100644 index 0000000000..6b5be12117 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSNotification.hpp @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSNotification.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSDictionary.hpp" +#include "NSObject.hpp" +#include "NSString.hpp" +#include "NSTypes.hpp" +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +using NotificationName = class String*; + +class Notification : public NS::Referencing +{ +public: + NS::String* name() const; + NS::Object* object() const; + NS::Dictionary* userInfo() const; +}; + +using ObserverBlock = void(^)(Notification*); +using ObserverFunction = std::function; + +class NotificationCenter : public NS::Referencing +{ + public: + static class NotificationCenter* defaultCenter(); + Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverBlock block); + Object* addObserver(NotificationName name, Object* pObj, void* pQueue, ObserverFunction &handler); + void removeObserver(Object* pObserver); + +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Notification::name() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(name)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Object* NS::Notification::object() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(object)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::Notification::userInfo() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(userInfo)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::NotificationCenter* NS::NotificationCenter::defaultCenter() +{ + return NS::Object::sendMessage(_NS_PRIVATE_CLS(NSNotificationCenter), _NS_PRIVATE_SEL(defaultCenter)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverBlock block) +{ + return NS::Object::sendMessage(this, _NS_PRIVATE_SEL(addObserverName_object_queue_block_), name, pObj, pQueue, block); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Object* NS::NotificationCenter::addObserver(NS::NotificationName name, Object* pObj, void* pQueue, NS::ObserverFunction &handler) +{ + __block ObserverFunction blockFunction = handler; + + return addObserver(name, pObj, pQueue, ^(NS::Notification* pNotif) {blockFunction(pNotif);}); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::NotificationCenter::removeObserver(Object* pObserver) +{ + return NS::Object::sendMessage(this, _NS_PRIVATE_SEL(removeObserver_), pObserver); +} + diff --git a/thirdparty/metal-cpp/Foundation/NSNumber.hpp b/thirdparty/metal-cpp/Foundation/NSNumber.hpp new file mode 100644 index 0000000000..eec7ceac50 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSNumber.hpp @@ -0,0 +1,501 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSNumber.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSObjCRuntime.hpp" +#include "NSObject.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class Value : public Copying +{ +public: + static Value* value(const void* pValue, const char* pType); + static Value* value(const void* pPointer); + + static Value* alloc(); + + Value* init(const void* pValue, const char* pType); + Value* init(const class Coder* pCoder); + + void getValue(void* pValue, UInteger size) const; + const char* objCType() const; + + bool isEqualToValue(Value* pValue) const; + void* pointerValue() const; +}; + +class Number : public Copying +{ +public: + static Number* number(char value); + static Number* number(unsigned char value); + static Number* number(short value); + static Number* number(unsigned short value); + static Number* number(int value); + static Number* number(unsigned int value); + static Number* number(long value); + static Number* number(unsigned long value); + static Number* number(long long value); + static Number* number(unsigned long long value); + static Number* number(float value); + static Number* number(double value); + static Number* number(bool value); + + static Number* alloc(); + + Number* init(const class Coder* pCoder); + Number* init(char value); + Number* init(unsigned char value); + Number* init(short value); + Number* init(unsigned short value); + Number* init(int value); + Number* init(unsigned int value); + Number* init(long value); + Number* init(unsigned long value); + Number* init(long long value); + Number* init(unsigned long long value); + Number* init(float value); + Number* init(double value); + Number* init(bool value); + + char charValue() const; + unsigned char unsignedCharValue() const; + short shortValue() const; + unsigned short unsignedShortValue() const; + int intValue() const; + unsigned int unsignedIntValue() const; + long longValue() const; + unsigned long unsignedLongValue() const; + long long longLongValue() const; + unsigned long long unsignedLongLongValue() const; + float floatValue() const; + double doubleValue() const; + bool boolValue() const; + Integer integerValue() const; + UInteger unsignedIntegerValue() const; + class String* stringValue() const; + + ComparisonResult compare(const Number* pOtherNumber) const; + bool isEqualToNumber(const Number* pNumber) const; + + class String* descriptionWithLocale(const Object* pLocale) const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Value* NS::Value::value(const void* pValue, const char* pType) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithBytes_objCType_), pValue, pType); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Value* NS::Value::value(const void* pPointer) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSValue), _NS_PRIVATE_SEL(valueWithPointer_), pPointer); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Value* NS::Value::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Value* NS::Value::init(const void* pValue, const char* pType) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBytes_objCType_), pValue, pType); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Value* NS::Value::init(const class Coder* pCoder) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::Value::getValue(void* pValue, UInteger size) const +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(getValue_size_), pValue, size); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE const char* NS::Value::objCType() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(objCType)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Value::isEqualToValue(Value* pValue) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(isEqualToValue_), pValue); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void* NS::Value::pointerValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(pointerValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(char value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithChar_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(unsigned char value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedChar_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(short value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithShort_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(unsigned short value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedShort_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(int value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithInt_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(unsigned int value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedInt_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(long value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(unsigned long value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(long long value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithLongLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(unsigned long long value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithUnsignedLongLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(float value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithFloat_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(double value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithDouble_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::number(bool value) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSNumber), _NS_PRIVATE_SEL(numberWithBool_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSNumber)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(const Coder* pCoder) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(char value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithChar_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(unsigned char value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithUnsignedChar_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(short value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithShort_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(unsigned short value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithUnsignedShort_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(int value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithInt_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(unsigned int value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithUnsignedInt_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(long value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(unsigned long value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithUnsignedLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(long long value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithLongLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(unsigned long long value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithUnsignedLongLong_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(float value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithFloat_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(double value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithDouble_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Number* NS::Number::init(bool value) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBool_), value); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE char NS::Number::charValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(charValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned char NS::Number::unsignedCharValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedCharValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE short NS::Number::shortValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(shortValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned short NS::Number::unsignedShortValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedShortValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE int NS::Number::intValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(intValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned int NS::Number::unsignedIntValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedIntValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE long NS::Number::longValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(longValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned long NS::Number::unsignedLongValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedLongValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE long long NS::Number::longLongValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(longLongValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned long long NS::Number::unsignedLongLongValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedLongLongValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE float NS::Number::floatValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(floatValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE double NS::Number::doubleValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(doubleValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Number::boolValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(boolValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Integer NS::Number::integerValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(integerValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Number::unsignedIntegerValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(unsignedIntegerValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Number::stringValue() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(stringValue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::ComparisonResult NS::Number::compare(const Number* pOtherNumber) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(compare_), pOtherNumber); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Number::isEqualToNumber(const Number* pNumber) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(isEqualToNumber_), pNumber); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Number::descriptionWithLocale(const Object* pLocale) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(descriptionWithLocale_), pLocale); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSObjCRuntime.hpp b/thirdparty/metal-cpp/Foundation/NSObjCRuntime.hpp new file mode 100644 index 0000000000..9a5364c2e3 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSObjCRuntime.hpp @@ -0,0 +1,43 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSObjCRuntime.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ + +_NS_ENUM(Integer, ComparisonResult) { + OrderedAscending = -1L, + OrderedSame, + OrderedDescending +}; + +const Integer NotFound = IntegerMax; + +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSObject.hpp b/thirdparty/metal-cpp/Foundation/NSObject.hpp new file mode 100644 index 0000000000..4633ac66e1 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSObject.hpp @@ -0,0 +1,304 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSObject.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +#include +#include + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class String; + +template +class _NS_EXPORT Referencing : public _Base +{ +public: + _Class* retain(); + void release(); + + _Class* autorelease(); + + UInteger retainCount() const; +}; + +template +class Copying : public Referencing<_Class, _Base> +{ +public: + _Class* copy() const; +}; + +template +class SecureCoding : public Referencing<_Class, _Base> +{ +}; + +class Object : public Referencing +{ +public: + UInteger hash() const; + bool isEqual(const Object* pObject) const; + + class String* description() const; + class String* debugDescription() const; + +protected: + friend class Referencing; + + template + static _Class* alloc(const char* pClassName); + template + static _Class* alloc(const void* pClass); + template + _Class* init(); + + template + static _Dst bridgingCast(const void* pObj); + static class MethodSignature* methodSignatureForSelector(const void* pObj, SEL selector); + static bool respondsToSelector(const void* pObj, SEL selector); + template + static constexpr bool doesRequireMsgSendStret(); + template + static _Ret sendMessage(const void* pObj, SEL selector, _Args... args); + template + static _Ret sendMessageSafe(const void* pObj, SEL selector, _Args... args); + +private: + Object() = delete; + Object(const Object&) = delete; + ~Object() = delete; + + Object& operator=(const Object&) = delete; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Referencing<_Class, _Base>::retain() +{ + return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(retain)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE void NS::Referencing<_Class, _Base>::release() +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(release)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Referencing<_Class, _Base>::autorelease() +{ + return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(autorelease)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE NS::UInteger NS::Referencing<_Class, _Base>::retainCount() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(retainCount)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Copying<_Class, _Base>::copy() const +{ + return Object::sendMessage<_Class*>(this, _NS_PRIVATE_SEL(copy)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Dst NS::Object::bridgingCast(const void* pObj) +{ +#ifdef __OBJC__ + return (__bridge _Dst)pObj; +#else + return (_Dst)pObj; +#endif // __OBJC__ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret() +{ +#if (defined(__i386__) || defined(__x86_64__)) + constexpr size_t kStructLimit = (sizeof(std::uintptr_t) << 1); + + return sizeof(_Type) > kStructLimit; +#elif defined(__arm64__) + return false; +#elif defined(__arm__) + constexpr size_t kStructLimit = sizeof(std::uintptr_t); + + return std::is_class_v<_Type> && (sizeof(_Type) > kStructLimit); +#else +#error "Unsupported architecture!" +#endif +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template <> +_NS_INLINE constexpr bool NS::Object::doesRequireMsgSendStret() +{ + return false; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Ret NS::Object::sendMessage(const void* pObj, SEL selector, _Args... args) +{ +#if (defined(__i386__) || defined(__x86_64__)) + if constexpr (std::is_floating_point<_Ret>()) + { + using SendMessageProcFpret = _Ret (*)(const void*, SEL, _Args...); + + const SendMessageProcFpret pProc = reinterpret_cast(&objc_msgSend_fpret); + + return (*pProc)(pObj, selector, args...); + } + else +#endif // ( defined( __i386__ ) || defined( __x86_64__ ) ) +#if !defined(__arm64__) + if constexpr (doesRequireMsgSendStret<_Ret>()) + { + using SendMessageProcStret = void (*)(_Ret*, const void*, SEL, _Args...); + + const SendMessageProcStret pProc = reinterpret_cast(&objc_msgSend_stret); + _Ret ret; + + (*pProc)(&ret, pObj, selector, args...); + + return ret; + } + else +#endif // !defined( __arm64__ ) + { + using SendMessageProc = _Ret (*)(const void*, SEL, _Args...); + + const SendMessageProc pProc = reinterpret_cast(&objc_msgSend); + + return (*pProc)(pObj, selector, args...); + } +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::MethodSignature* NS::Object::methodSignatureForSelector(const void* pObj, SEL selector) +{ + return sendMessage(pObj, _NS_PRIVATE_SEL(methodSignatureForSelector_), selector); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Object::respondsToSelector(const void* pObj, SEL selector) +{ + return sendMessage(pObj, _NS_PRIVATE_SEL(respondsToSelector_), selector); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Ret NS::Object::sendMessageSafe(const void* pObj, SEL selector, _Args... args) +{ + if ((respondsToSelector(pObj, selector)) || (nullptr != methodSignatureForSelector(pObj, selector))) + { + return sendMessage<_Ret>(pObj, selector, args...); + } + + if constexpr (!std::is_void<_Ret>::value) + { + return _Ret(0); + } +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Object::alloc(const char* pClassName) +{ + return sendMessage<_Class*>(objc_lookUpClass(pClassName), _NS_PRIVATE_SEL(alloc)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Object::alloc(const void* pClass) +{ + return sendMessage<_Class*>(pClass, _NS_PRIVATE_SEL(alloc)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +template +_NS_INLINE _Class* NS::Object::init() +{ + return sendMessage<_Class*>(this, _NS_PRIVATE_SEL(init)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Object::hash() const +{ + return sendMessage(this, _NS_PRIVATE_SEL(hash)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Object::isEqual(const Object* pObject) const +{ + return sendMessage(this, _NS_PRIVATE_SEL(isEqual_), pObject); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Object::description() const +{ + return sendMessage(this, _NS_PRIVATE_SEL(description)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::Object::debugDescription() const +{ + return sendMessageSafe(this, _NS_PRIVATE_SEL(debugDescription)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSPrivate.hpp b/thirdparty/metal-cpp/Foundation/NSPrivate.hpp new file mode 100644 index 0000000000..17909fbd2a --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSPrivate.hpp @@ -0,0 +1,535 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSPrivate.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _NS_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol) +#define _NS_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#if defined(NS_PRIVATE_IMPLEMENTATION) + +#include + +namespace NS::Private +{ + template + inline _Type const LoadSymbol(const char* pSymbol) + { + const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol)); + + return pAddress ? *pAddress : _Type(); + } +} // NS::Private + +#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN +#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("hidden"))) +#else +#define _NS_PRIVATE_VISIBILITY __attribute__((visibility("default"))) +#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN + +#define _NS_PRIVATE_IMPORT __attribute__((weak_import)) + +#ifdef __OBJC__ +#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol)) +#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol)) +#else +#define _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol) +#define _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol) +#endif // __OBJC__ + +#define _NS_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_LOOKUP_CLASS(symbol) +#define _NS_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _NS_PRIVATE_VISIBILITY = _NS_PRIVATE_OBJC_GET_PROTOCOL(symbol) +#define _NS_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _NS_PRIVATE_VISIBILITY = sel_registerName(symbol) + +#if defined(__MAC_26_0) || defined(__IPHONE_26_0) || defined(__TVOS_26_0) +#define _NS_PRIVATE_DEF_CONST(type, symbol) \ + _NS_EXTERN type const NS##symbol _NS_PRIVATE_IMPORT; \ + type const NS::symbol = (nullptr != &NS##symbol) ? NS##symbol : type() +#else +#define _NS_PRIVATE_DEF_CONST(type, symbol) \ + _NS_EXTERN type const MTL##symbol _NS_PRIVATE_IMPORT; \ + type const NS::symbol = Private::LoadSymbol("NS" #symbol) +#endif + +#else + +#define _NS_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol +#define _NS_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol +#define _NS_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor +#define _NS_PRIVATE_DEF_CONST(type, symbol) extern type const NS::symbol + +#endif // NS_PRIVATE_IMPLEMENTATION + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +namespace Private +{ + namespace Class + { + + _NS_PRIVATE_DEF_CLS(NSArray); + _NS_PRIVATE_DEF_CLS(NSAutoreleasePool); + _NS_PRIVATE_DEF_CLS(NSBundle); + _NS_PRIVATE_DEF_CLS(NSCondition); + _NS_PRIVATE_DEF_CLS(NSDate); + _NS_PRIVATE_DEF_CLS(NSDictionary); + _NS_PRIVATE_DEF_CLS(NSError); + _NS_PRIVATE_DEF_CLS(NSNotificationCenter); + _NS_PRIVATE_DEF_CLS(NSNumber); + _NS_PRIVATE_DEF_CLS(NSObject); + _NS_PRIVATE_DEF_CLS(NSProcessInfo); + _NS_PRIVATE_DEF_CLS(NSSet); + _NS_PRIVATE_DEF_CLS(NSString); + _NS_PRIVATE_DEF_CLS(NSURL); + _NS_PRIVATE_DEF_CLS(NSValue); + + } // Class +} // Private +} // MTL + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +namespace Private +{ + namespace Protocol + { + + } // Protocol +} // Private +} // NS + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +namespace Private +{ + namespace Selector + { + + _NS_PRIVATE_DEF_SEL(addObject_, + "addObject:"); + _NS_PRIVATE_DEF_SEL(addObserverName_object_queue_block_, + "addObserverForName:object:queue:usingBlock:"); + _NS_PRIVATE_DEF_SEL(activeProcessorCount, + "activeProcessorCount"); + _NS_PRIVATE_DEF_SEL(allBundles, + "allBundles"); + _NS_PRIVATE_DEF_SEL(allFrameworks, + "allFrameworks"); + _NS_PRIVATE_DEF_SEL(allObjects, + "allObjects"); + _NS_PRIVATE_DEF_SEL(alloc, + "alloc"); + _NS_PRIVATE_DEF_SEL(appStoreReceiptURL, + "appStoreReceiptURL"); + _NS_PRIVATE_DEF_SEL(arguments, + "arguments"); + _NS_PRIVATE_DEF_SEL(array, + "array"); + _NS_PRIVATE_DEF_SEL(arrayWithObject_, + "arrayWithObject:"); + _NS_PRIVATE_DEF_SEL(arrayWithObjects_count_, + "arrayWithObjects:count:"); + _NS_PRIVATE_DEF_SEL(automaticTerminationSupportEnabled, + "automaticTerminationSupportEnabled"); + _NS_PRIVATE_DEF_SEL(autorelease, + "autorelease"); + _NS_PRIVATE_DEF_SEL(beginActivityWithOptions_reason_, + "beginActivityWithOptions:reason:"); + _NS_PRIVATE_DEF_SEL(boolValue, + "boolValue"); + _NS_PRIVATE_DEF_SEL(broadcast, + "broadcast"); + _NS_PRIVATE_DEF_SEL(builtInPlugInsPath, + "builtInPlugInsPath"); + _NS_PRIVATE_DEF_SEL(builtInPlugInsURL, + "builtInPlugInsURL"); + _NS_PRIVATE_DEF_SEL(bundleIdentifier, + "bundleIdentifier"); + _NS_PRIVATE_DEF_SEL(bundlePath, + "bundlePath"); + _NS_PRIVATE_DEF_SEL(bundleURL, + "bundleURL"); + _NS_PRIVATE_DEF_SEL(bundleWithPath_, + "bundleWithPath:"); + _NS_PRIVATE_DEF_SEL(bundleWithURL_, + "bundleWithURL:"); + _NS_PRIVATE_DEF_SEL(caseInsensitiveCompare_, + "caseInsensitiveCompare:"); + _NS_PRIVATE_DEF_SEL(characterAtIndex_, + "characterAtIndex:"); + _NS_PRIVATE_DEF_SEL(charValue, + "charValue"); + _NS_PRIVATE_DEF_SEL(countByEnumeratingWithState_objects_count_, + "countByEnumeratingWithState:objects:count:"); + _NS_PRIVATE_DEF_SEL(cStringUsingEncoding_, + "cStringUsingEncoding:"); + _NS_PRIVATE_DEF_SEL(code, + "code"); + _NS_PRIVATE_DEF_SEL(compare_, + "compare:"); + _NS_PRIVATE_DEF_SEL(copy, + "copy"); + _NS_PRIVATE_DEF_SEL(count, + "count"); + _NS_PRIVATE_DEF_SEL(dateWithTimeIntervalSinceNow_, + "dateWithTimeIntervalSinceNow:"); + _NS_PRIVATE_DEF_SEL(defaultCenter, + "defaultCenter"); + _NS_PRIVATE_DEF_SEL(descriptionWithLocale_, + "descriptionWithLocale:"); + _NS_PRIVATE_DEF_SEL(disableAutomaticTermination_, + "disableAutomaticTermination:"); + _NS_PRIVATE_DEF_SEL(disableSuddenTermination, + "disableSuddenTermination"); + _NS_PRIVATE_DEF_SEL(debugDescription, + "debugDescription"); + _NS_PRIVATE_DEF_SEL(description, + "description"); + _NS_PRIVATE_DEF_SEL(dictionary, + "dictionary"); + _NS_PRIVATE_DEF_SEL(dictionaryWithObject_forKey_, + "dictionaryWithObject:forKey:"); + _NS_PRIVATE_DEF_SEL(dictionaryWithObjects_forKeys_count_, + "dictionaryWithObjects:forKeys:count:"); + _NS_PRIVATE_DEF_SEL(domain, + "domain"); + _NS_PRIVATE_DEF_SEL(doubleValue, + "doubleValue"); + _NS_PRIVATE_DEF_SEL(drain, + "drain"); + _NS_PRIVATE_DEF_SEL(enableAutomaticTermination_, + "enableAutomaticTermination:"); + _NS_PRIVATE_DEF_SEL(enableSuddenTermination, + "enableSuddenTermination"); + _NS_PRIVATE_DEF_SEL(endActivity_, + "endActivity:"); + _NS_PRIVATE_DEF_SEL(environment, + "environment"); + _NS_PRIVATE_DEF_SEL(errorWithDomain_code_userInfo_, + "errorWithDomain:code:userInfo:"); + _NS_PRIVATE_DEF_SEL(executablePath, + "executablePath"); + _NS_PRIVATE_DEF_SEL(executableURL, + "executableURL"); + _NS_PRIVATE_DEF_SEL(fileSystemRepresentation, + "fileSystemRepresentation"); + _NS_PRIVATE_DEF_SEL(fileURLWithPath_, + "fileURLWithPath:"); + _NS_PRIVATE_DEF_SEL(floatValue, + "floatValue"); + _NS_PRIVATE_DEF_SEL(fullUserName, + "fullUserName"); + _NS_PRIVATE_DEF_SEL(getValue_size_, + "getValue:size:"); + _NS_PRIVATE_DEF_SEL(globallyUniqueString, + "globallyUniqueString"); + _NS_PRIVATE_DEF_SEL(hash, + "hash"); + _NS_PRIVATE_DEF_SEL(hasPerformanceProfile_, + "hasPerformanceProfile:"); + _NS_PRIVATE_DEF_SEL(hostName, + "hostName"); + _NS_PRIVATE_DEF_SEL(infoDictionary, + "infoDictionary"); + _NS_PRIVATE_DEF_SEL(init, + "init"); + _NS_PRIVATE_DEF_SEL(initFileURLWithPath_, + "initFileURLWithPath:"); + _NS_PRIVATE_DEF_SEL(initWithBool_, + "initWithBool:"); + _NS_PRIVATE_DEF_SEL(initWithBytes_objCType_, + "initWithBytes:objCType:"); + _NS_PRIVATE_DEF_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_, + "initWithBytesNoCopy:length:encoding:freeWhenDone:"); + _NS_PRIVATE_DEF_SEL(initWithBytes_length_encoding_, + "initWithBytes:length:encoding:"); + _NS_PRIVATE_DEF_SEL(initWithChar_, + "initWithChar:"); + _NS_PRIVATE_DEF_SEL(initWithCoder_, + "initWithCoder:"); + _NS_PRIVATE_DEF_SEL(initWithCString_encoding_, + "initWithCString:encoding:"); + _NS_PRIVATE_DEF_SEL(initWithDomain_code_userInfo_, + "initWithDomain:code:userInfo:"); + _NS_PRIVATE_DEF_SEL(initWithDouble_, + "initWithDouble:"); + _NS_PRIVATE_DEF_SEL(initWithFloat_, + "initWithFloat:"); + _NS_PRIVATE_DEF_SEL(initWithInt_, + "initWithInt:"); + _NS_PRIVATE_DEF_SEL(initWithLong_, + "initWithLong:"); + _NS_PRIVATE_DEF_SEL(initWithLongLong_, + "initWithLongLong:"); + _NS_PRIVATE_DEF_SEL(initWithObjects_count_, + "initWithObjects:count:"); + _NS_PRIVATE_DEF_SEL(initWithObjects_forKeys_count_, + "initWithObjects:forKeys:count:"); + _NS_PRIVATE_DEF_SEL(initWithPath_, + "initWithPath:"); + _NS_PRIVATE_DEF_SEL(initWithShort_, + "initWithShort:"); + _NS_PRIVATE_DEF_SEL(initWithString_, + "initWithString:"); + _NS_PRIVATE_DEF_SEL(initWithUnsignedChar_, + "initWithUnsignedChar:"); + _NS_PRIVATE_DEF_SEL(initWithUnsignedInt_, + "initWithUnsignedInt:"); + _NS_PRIVATE_DEF_SEL(initWithUnsignedLong_, + "initWithUnsignedLong:"); + _NS_PRIVATE_DEF_SEL(initWithUnsignedLongLong_, + "initWithUnsignedLongLong:"); + _NS_PRIVATE_DEF_SEL(initWithUnsignedShort_, + "initWithUnsignedShort:"); + _NS_PRIVATE_DEF_SEL(initWithURL_, + "initWithURL:"); + _NS_PRIVATE_DEF_SEL(integerValue, + "integerValue"); + _NS_PRIVATE_DEF_SEL(intValue, + "intValue"); + _NS_PRIVATE_DEF_SEL(isDeviceCertified_, + "isDeviceCertifiedFor:"); + _NS_PRIVATE_DEF_SEL(isEqual_, + "isEqual:"); + _NS_PRIVATE_DEF_SEL(isEqualToNumber_, + "isEqualToNumber:"); + _NS_PRIVATE_DEF_SEL(isEqualToString_, + "isEqualToString:"); + _NS_PRIVATE_DEF_SEL(isEqualToValue_, + "isEqualToValue:"); + _NS_PRIVATE_DEF_SEL(isiOSAppOnMac, + "isiOSAppOnMac"); + _NS_PRIVATE_DEF_SEL(isLoaded, + "isLoaded"); + _NS_PRIVATE_DEF_SEL(isLowPowerModeEnabled, + "isLowPowerModeEnabled"); + _NS_PRIVATE_DEF_SEL(isMacCatalystApp, + "isMacCatalystApp"); + _NS_PRIVATE_DEF_SEL(isOperatingSystemAtLeastVersion_, + "isOperatingSystemAtLeastVersion:"); + _NS_PRIVATE_DEF_SEL(keyEnumerator, + "keyEnumerator"); + _NS_PRIVATE_DEF_SEL(length, + "length"); + _NS_PRIVATE_DEF_SEL(lengthOfBytesUsingEncoding_, + "lengthOfBytesUsingEncoding:"); + _NS_PRIVATE_DEF_SEL(load, + "load"); + _NS_PRIVATE_DEF_SEL(loadAndReturnError_, + "loadAndReturnError:"); + _NS_PRIVATE_DEF_SEL(localizedDescription, + "localizedDescription"); + _NS_PRIVATE_DEF_SEL(localizedFailureReason, + "localizedFailureReason"); + _NS_PRIVATE_DEF_SEL(localizedInfoDictionary, + "localizedInfoDictionary"); + _NS_PRIVATE_DEF_SEL(localizedRecoveryOptions, + "localizedRecoveryOptions"); + _NS_PRIVATE_DEF_SEL(localizedRecoverySuggestion, + "localizedRecoverySuggestion"); + _NS_PRIVATE_DEF_SEL(localizedStringForKey_value_table_, + "localizedStringForKey:value:table:"); + _NS_PRIVATE_DEF_SEL(lock, + "lock"); + _NS_PRIVATE_DEF_SEL(longValue, + "longValue"); + _NS_PRIVATE_DEF_SEL(longLongValue, + "longLongValue"); + _NS_PRIVATE_DEF_SEL(mainBundle, + "mainBundle"); + _NS_PRIVATE_DEF_SEL(maximumLengthOfBytesUsingEncoding_, + "maximumLengthOfBytesUsingEncoding:"); + _NS_PRIVATE_DEF_SEL(methodSignatureForSelector_, + "methodSignatureForSelector:"); + _NS_PRIVATE_DEF_SEL(mutableBytes, + "mutableBytes"); + _NS_PRIVATE_DEF_SEL(bytes, + "bytes"); + _NS_PRIVATE_DEF_SEL(name, + "name"); + _NS_PRIVATE_DEF_SEL(nextObject, + "nextObject"); + _NS_PRIVATE_DEF_SEL(numberWithBool_, + "numberWithBool:"); + _NS_PRIVATE_DEF_SEL(numberWithChar_, + "numberWithChar:"); + _NS_PRIVATE_DEF_SEL(numberWithDouble_, + "numberWithDouble:"); + _NS_PRIVATE_DEF_SEL(numberWithFloat_, + "numberWithFloat:"); + _NS_PRIVATE_DEF_SEL(numberWithInt_, + "numberWithInt:"); + _NS_PRIVATE_DEF_SEL(numberWithLong_, + "numberWithLong:"); + _NS_PRIVATE_DEF_SEL(numberWithLongLong_, + "numberWithLongLong:"); + _NS_PRIVATE_DEF_SEL(numberWithShort_, + "numberWithShort:"); + _NS_PRIVATE_DEF_SEL(numberWithUnsignedChar_, + "numberWithUnsignedChar:"); + _NS_PRIVATE_DEF_SEL(numberWithUnsignedInt_, + "numberWithUnsignedInt:"); + _NS_PRIVATE_DEF_SEL(numberWithUnsignedLong_, + "numberWithUnsignedLong:"); + _NS_PRIVATE_DEF_SEL(numberWithUnsignedLongLong_, + "numberWithUnsignedLongLong:"); + _NS_PRIVATE_DEF_SEL(numberWithUnsignedShort_, + "numberWithUnsignedShort:"); + _NS_PRIVATE_DEF_SEL(objCType, + "objCType"); + _NS_PRIVATE_DEF_SEL(object, + "object"); + _NS_PRIVATE_DEF_SEL(objectAtIndex_, + "objectAtIndex:"); + _NS_PRIVATE_DEF_SEL(objectEnumerator, + "objectEnumerator"); + _NS_PRIVATE_DEF_SEL(objectForInfoDictionaryKey_, + "objectForInfoDictionaryKey:"); + _NS_PRIVATE_DEF_SEL(objectForKey_, + "objectForKey:"); + _NS_PRIVATE_DEF_SEL(operatingSystem, + "operatingSystem"); + _NS_PRIVATE_DEF_SEL(operatingSystemVersion, + "operatingSystemVersion"); + _NS_PRIVATE_DEF_SEL(operatingSystemVersionString, + "operatingSystemVersionString"); + _NS_PRIVATE_DEF_SEL(pathForAuxiliaryExecutable_, + "pathForAuxiliaryExecutable:"); + _NS_PRIVATE_DEF_SEL(performActivityWithOptions_reason_usingBlock_, + "performActivityWithOptions:reason:usingBlock:"); + _NS_PRIVATE_DEF_SEL(performExpiringActivityWithReason_usingBlock_, + "performExpiringActivityWithReason:usingBlock:"); + _NS_PRIVATE_DEF_SEL(physicalMemory, + "physicalMemory"); + _NS_PRIVATE_DEF_SEL(pointerValue, + "pointerValue"); + _NS_PRIVATE_DEF_SEL(preflightAndReturnError_, + "preflightAndReturnError:"); + _NS_PRIVATE_DEF_SEL(privateFrameworksPath, + "privateFrameworksPath"); + _NS_PRIVATE_DEF_SEL(privateFrameworksURL, + "privateFrameworksURL"); + _NS_PRIVATE_DEF_SEL(processIdentifier, + "processIdentifier"); + _NS_PRIVATE_DEF_SEL(processInfo, + "processInfo"); + _NS_PRIVATE_DEF_SEL(processName, + "processName"); + _NS_PRIVATE_DEF_SEL(processorCount, + "processorCount"); + _NS_PRIVATE_DEF_SEL(rangeOfString_options_, + "rangeOfString:options:"); + _NS_PRIVATE_DEF_SEL(release, + "release"); + _NS_PRIVATE_DEF_SEL(removeObserver_, + "removeObserver:"); + _NS_PRIVATE_DEF_SEL(resourcePath, + "resourcePath"); + _NS_PRIVATE_DEF_SEL(resourceURL, + "resourceURL"); + _NS_PRIVATE_DEF_SEL(respondsToSelector_, + "respondsToSelector:"); + _NS_PRIVATE_DEF_SEL(retain, + "retain"); + _NS_PRIVATE_DEF_SEL(retainCount, + "retainCount"); + _NS_PRIVATE_DEF_SEL(setAutomaticTerminationSupportEnabled_, + "setAutomaticTerminationSupportEnabled:"); + _NS_PRIVATE_DEF_SEL(setProcessName_, + "setProcessName:"); + _NS_PRIVATE_DEF_SEL(sharedFrameworksPath, + "sharedFrameworksPath"); + _NS_PRIVATE_DEF_SEL(sharedFrameworksURL, + "sharedFrameworksURL"); + _NS_PRIVATE_DEF_SEL(sharedSupportPath, + "sharedSupportPath"); + _NS_PRIVATE_DEF_SEL(sharedSupportURL, + "sharedSupportURL"); + _NS_PRIVATE_DEF_SEL(shortValue, + "shortValue"); + _NS_PRIVATE_DEF_SEL(showPools, + "showPools"); + _NS_PRIVATE_DEF_SEL(signal, + "signal"); + _NS_PRIVATE_DEF_SEL(string, + "string"); + _NS_PRIVATE_DEF_SEL(stringValue, + "stringValue"); + _NS_PRIVATE_DEF_SEL(stringWithString_, + "stringWithString:"); + _NS_PRIVATE_DEF_SEL(stringWithCString_encoding_, + "stringWithCString:encoding:"); + _NS_PRIVATE_DEF_SEL(stringByAppendingString_, + "stringByAppendingString:"); + _NS_PRIVATE_DEF_SEL(systemUptime, + "systemUptime"); + _NS_PRIVATE_DEF_SEL(thermalState, + "thermalState"); + _NS_PRIVATE_DEF_SEL(unload, + "unload"); + _NS_PRIVATE_DEF_SEL(unlock, + "unlock"); + _NS_PRIVATE_DEF_SEL(unsignedCharValue, + "unsignedCharValue"); + _NS_PRIVATE_DEF_SEL(unsignedIntegerValue, + "unsignedIntegerValue"); + _NS_PRIVATE_DEF_SEL(unsignedIntValue, + "unsignedIntValue"); + _NS_PRIVATE_DEF_SEL(unsignedLongValue, + "unsignedLongValue"); + _NS_PRIVATE_DEF_SEL(unsignedLongLongValue, + "unsignedLongLongValue"); + _NS_PRIVATE_DEF_SEL(unsignedShortValue, + "unsignedShortValue"); + _NS_PRIVATE_DEF_SEL(URLForAuxiliaryExecutable_, + "URLForAuxiliaryExecutable:"); + _NS_PRIVATE_DEF_SEL(userInfo, + "userInfo"); + _NS_PRIVATE_DEF_SEL(userName, + "userName"); + _NS_PRIVATE_DEF_SEL(UTF8String, + "UTF8String"); + _NS_PRIVATE_DEF_SEL(valueWithBytes_objCType_, + "valueWithBytes:objCType:"); + _NS_PRIVATE_DEF_SEL(valueWithPointer_, + "valueWithPointer:"); + _NS_PRIVATE_DEF_SEL(wait, + "wait"); + _NS_PRIVATE_DEF_SEL(waitUntilDate_, + "waitUntilDate:"); + } // Class +} // Private +} // MTL + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSProcessInfo.hpp b/thirdparty/metal-cpp/Foundation/NSProcessInfo.hpp new file mode 100644 index 0000000000..09c212d540 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSProcessInfo.hpp @@ -0,0 +1,386 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSProcessInfo.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSNotification.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +_NS_CONST(NotificationName, ProcessInfoThermalStateDidChangeNotification); +_NS_CONST(NotificationName, ProcessInfoPowerStateDidChangeNotification); +_NS_CONST(NotificationName, ProcessInfoPerformanceProfileDidChangeNotification); + +_NS_ENUM(NS::Integer, ProcessInfoThermalState) { + ProcessInfoThermalStateNominal = 0, + ProcessInfoThermalStateFair = 1, + ProcessInfoThermalStateSerious = 2, + ProcessInfoThermalStateCritical = 3 +}; + +_NS_OPTIONS(std::uint64_t, ActivityOptions) { + ActivityIdleDisplaySleepDisabled = (1ULL << 40), + ActivityIdleSystemSleepDisabled = (1ULL << 20), + ActivitySuddenTerminationDisabled = (1ULL << 14), + ActivityAutomaticTerminationDisabled = (1ULL << 15), + ActivityUserInitiated = (0x00FFFFFFULL | ActivityIdleSystemSleepDisabled), + ActivityUserInitiatedAllowingIdleSystemSleep = (ActivityUserInitiated & ~ActivityIdleSystemSleepDisabled), + ActivityBackground = 0x000000FFULL, + ActivityLatencyCritical = 0xFF00000000ULL, +}; + +typedef NS::Integer DeviceCertification; +_NS_CONST(DeviceCertification, DeviceCertificationiPhonePerformanceGaming); + +typedef NS::Integer ProcessPerformanceProfile; +_NS_CONST(ProcessPerformanceProfile, ProcessPerformanceProfileDefault); +_NS_CONST(ProcessPerformanceProfile, ProcessPerformanceProfileSustained); + +class ProcessInfo : public Referencing +{ +public: + static ProcessInfo* processInfo(); + + class Array* arguments() const; + class Dictionary* environment() const; + class String* hostName() const; + class String* processName() const; + void setProcessName(const String* pString); + int processIdentifier() const; + class String* globallyUniqueString() const; + + class String* userName() const; + class String* fullUserName() const; + + UInteger operatingSystem() const; + OperatingSystemVersion operatingSystemVersion() const; + class String* operatingSystemVersionString() const; + bool isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const; + + UInteger processorCount() const; + UInteger activeProcessorCount() const; + unsigned long long physicalMemory() const; + TimeInterval systemUptime() const; + + void disableSuddenTermination(); + void enableSuddenTermination(); + + void disableAutomaticTermination(const class String* pReason); + void enableAutomaticTermination(const class String* pReason); + bool automaticTerminationSupportEnabled() const; + void setAutomaticTerminationSupportEnabled(bool enabled); + + class Object* beginActivity(ActivityOptions options, const class String* pReason); + void endActivity(class Object* pActivity); + void performActivity(ActivityOptions options, const class String* pReason, void (^block)(void)); + void performActivity(ActivityOptions options, const class String* pReason, const std::function& func); + void performExpiringActivity(const class String* pReason, void (^block)(bool expired)); + void performExpiringActivity(const class String* pReason, const std::function& func); + + ProcessInfoThermalState thermalState() const; + bool isLowPowerModeEnabled() const; + + bool isiOSAppOnMac() const; + bool isMacCatalystApp() const; + + bool isDeviceCertified(DeviceCertification performanceTier) const; + bool hasPerformanceProfile(ProcessPerformanceProfile performanceProfile) const; + +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoThermalStateDidChangeNotification); +_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoPowerStateDidChangeNotification); + +// The linker searches for these symbols in the Metal framework, be sure to link it in as well: +_NS_PRIVATE_DEF_CONST(NS::NotificationName, ProcessInfoPerformanceProfileDidChangeNotification); +_NS_PRIVATE_DEF_CONST(NS::DeviceCertification, DeviceCertificationiPhonePerformanceGaming); +_NS_PRIVATE_DEF_CONST(NS::ProcessPerformanceProfile, ProcessPerformanceProfileDefault); +_NS_PRIVATE_DEF_CONST(NS::ProcessPerformanceProfile, ProcessPerformanceProfileSustained); + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::ProcessInfo* NS::ProcessInfo::processInfo() +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSProcessInfo), _NS_PRIVATE_SEL(processInfo)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Array* NS::ProcessInfo::arguments() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(arguments)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Dictionary* NS::ProcessInfo::environment() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(environment)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::hostName() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(hostName)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::processName() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(processName)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::setProcessName(const String* pString) +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(setProcessName_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE int NS::ProcessInfo::processIdentifier() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(processIdentifier)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::globallyUniqueString() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(globallyUniqueString)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::userName() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(userName)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::fullUserName() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(fullUserName)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::ProcessInfo::operatingSystem() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(operatingSystem)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::OperatingSystemVersion NS::ProcessInfo::operatingSystemVersion() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(operatingSystemVersion)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::ProcessInfo::operatingSystemVersionString() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(operatingSystemVersionString)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::isOperatingSystemAtLeastVersion(OperatingSystemVersion version) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(isOperatingSystemAtLeastVersion_), version); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::ProcessInfo::processorCount() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(processorCount)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::ProcessInfo::activeProcessorCount() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(activeProcessorCount)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE unsigned long long NS::ProcessInfo::physicalMemory() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(physicalMemory)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::TimeInterval NS::ProcessInfo::systemUptime() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(systemUptime)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::disableSuddenTermination() +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(disableSuddenTermination)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::enableSuddenTermination() +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(enableSuddenTermination)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::disableAutomaticTermination(const String* pReason) +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(disableAutomaticTermination_), pReason); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::enableAutomaticTermination(const String* pReason) +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(enableAutomaticTermination_), pReason); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::automaticTerminationSupportEnabled() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(automaticTerminationSupportEnabled)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::setAutomaticTerminationSupportEnabled(bool enabled) +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(setAutomaticTerminationSupportEnabled_), enabled); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Object* NS::ProcessInfo::beginActivity(ActivityOptions options, const String* pReason) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(beginActivityWithOptions_reason_), options, pReason); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::endActivity(Object* pActivity) +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(endActivity_), pActivity); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, void (^block)(void)) +{ + Object::sendMessage(this, _NS_PRIVATE_SEL(performActivityWithOptions_reason_usingBlock_), options, pReason, block); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::performActivity(ActivityOptions options, const String* pReason, const std::function& function) +{ + __block std::function blockFunction = function; + + performActivity(options, pReason, ^() { blockFunction(); }); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, void (^block)(bool expired)) +{ + Object::sendMessageSafe(this, _NS_PRIVATE_SEL(performExpiringActivityWithReason_usingBlock_), pReason, block); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE void NS::ProcessInfo::performExpiringActivity(const String* pReason, const std::function& function) +{ + __block std::function blockFunction = function; + + performExpiringActivity(pReason, ^(bool expired) { blockFunction(expired); }); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::ProcessInfoThermalState NS::ProcessInfo::thermalState() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(thermalState)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::isLowPowerModeEnabled() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(isLowPowerModeEnabled)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::isiOSAppOnMac() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(isiOSAppOnMac)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::isMacCatalystApp() const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(isMacCatalystApp)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::isDeviceCertified(DeviceCertification performanceTier) const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(isDeviceCertified_), performanceTier); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::ProcessInfo::hasPerformanceProfile(ProcessPerformanceProfile performanceProfile) const +{ + return Object::sendMessageSafe(this, _NS_PRIVATE_SEL(hasPerformanceProfile_), performanceProfile); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSRange.hpp b/thirdparty/metal-cpp/Foundation/NSRange.hpp new file mode 100644 index 0000000000..8500271d65 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSRange.hpp @@ -0,0 +1,83 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSRange.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +struct Range +{ + static Range Make(UInteger loc, UInteger len); + + Range(UInteger loc, UInteger len); + + bool Equal(const Range& range) const; + bool LocationInRange(UInteger loc) const; + UInteger Max() const; + + UInteger location; + UInteger length; +} _NS_PACKED; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Range::Range(UInteger loc, UInteger len) + : location(loc) + , length(len) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Range NS::Range::Make(UInteger loc, UInteger len) +{ + return Range(loc, len); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Range::Equal(const Range& range) const +{ + return (location == range.location) && (length == range.length); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::Range::LocationInRange(UInteger loc) const +{ + return (!(loc < location)) && ((loc - location) < length); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Range::Max() const +{ + return location + length; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSSet.hpp b/thirdparty/metal-cpp/Foundation/NSSet.hpp new file mode 100644 index 0000000000..382b6714e7 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSSet.hpp @@ -0,0 +1,87 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSSet.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSObject.hpp" +#include "NSEnumerator.hpp" + +/*****Immutable Set*******/ + +namespace NS +{ + class Set : public NS::Copying + { + public: + UInteger count() const; + Enumerator* objectEnumerator() const; + + static Set* alloc(); + + Set* init(); + Set* init(const Object* const* pObjects, UInteger count); + Set* init(const class Coder* pCoder); + + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::Set::count() const +{ + return NS::Object::sendMessage(this, _NS_PRIVATE_SEL(count)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Enumerator* NS::Set::objectEnumerator() const +{ + return NS::Object::sendMessage*>(this, _NS_PRIVATE_SEL(objectEnumerator)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Set* NS::Set::alloc() +{ + return NS::Object::alloc(_NS_PRIVATE_CLS(NSSet)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Set* NS::Set::init() +{ + return NS::Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Set* NS::Set::init(const Object* const* pObjects, NS::UInteger count) +{ + return NS::Object::sendMessage(this, _NS_PRIVATE_SEL(initWithObjects_count_), pObjects, count); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Set* NS::Set::init(const class Coder* pCoder) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCoder_), pCoder); +} diff --git a/thirdparty/metal-cpp/Foundation/NSSharedPtr.hpp b/thirdparty/metal-cpp/Foundation/NSSharedPtr.hpp new file mode 100644 index 0000000000..f1cf68e421 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSSharedPtr.hpp @@ -0,0 +1,310 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSSharedPtr.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include +#include "NSDefines.hpp" + +namespace NS +{ +template +class SharedPtr +{ +public: + /** + * Create a new null pointer. + */ + SharedPtr(); + + /** + * Destroy this SharedPtr, decreasing the reference count. + */ + ~SharedPtr(); + + /** + * Create a new null pointer. + */ + SharedPtr(std::nullptr_t) noexcept; + + /** + * SharedPtr copy constructor. + */ + SharedPtr(const SharedPtr<_Class>& other) noexcept; + + /** + * Construction from another pointee type. + */ + template + SharedPtr(const SharedPtr<_OtherClass>& other, typename std::enable_if_t> * = nullptr) noexcept; + + /** + * SharedPtr move constructor. + */ + SharedPtr(SharedPtr<_Class>&& other) noexcept; + + /** + * Move from another pointee type. + */ + template + SharedPtr(SharedPtr<_OtherClass>&& other, typename std::enable_if_t> * = nullptr) noexcept; + + /** + * Copy assignment operator. + * Copying increases reference count. Only releases previous pointee if objects are different. + */ + SharedPtr& operator=(const SharedPtr<_Class>& other); + + /** + * Copy-assignment from different pointee. + * Copying increases reference count. Only releases previous pointee if objects are different. + */ + template + typename std::enable_if_t, SharedPtr &> + operator=(const SharedPtr<_OtherClass>& other); + + /** + * Move assignment operator. + * Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr. + */ + SharedPtr& operator=(SharedPtr<_Class>&& other); + + /** + * Move-asignment from different pointee. + * Move without affecting reference counts, unless pointees are equal. Moved-from object is reset to nullptr. + */ + template + typename std::enable_if_t, SharedPtr &> + operator=(SharedPtr<_OtherClass>&& other); + + /** + * Access raw pointee. + * @warning Avoid wrapping the returned value again, as it may lead double frees unless this object becomes detached. + */ + _Class* get() const; + + /** + * Call operations directly on the pointee. + */ + _Class* operator->() const; + + /** + * Implicit cast to bool. + */ + explicit operator bool() const; + + /** + * Reset this SharedPtr to null, decreasing the reference count. + */ + void reset(); + + /** + * Detach the SharedPtr from the pointee, without decreasing the reference count. + */ + void detach(); + + template + friend SharedPtr<_OtherClass> RetainPtr(_OtherClass* ptr); + + template + friend SharedPtr<_OtherClass> TransferPtr(_OtherClass* ptr); + +private: + _Class* m_pObject; +}; + +/** + * Create a SharedPtr by retaining an existing raw pointer. + * Increases the reference count of the passed-in object. + * If the passed-in object was in an AutoreleasePool, it will be removed from it. + */ +template +_NS_INLINE NS::SharedPtr<_Class> RetainPtr(_Class* pObject) +{ + NS::SharedPtr<_Class> ret; + ret.m_pObject = pObject->retain(); + return ret; +} + +/* + * Create a SharedPtr by transfering the ownership of an existing raw pointer to SharedPtr. + * Does not increase the reference count of the passed-in pointer, it is assumed to be >= 1. + * This method does not remove objects from an AutoreleasePool. +*/ +template +_NS_INLINE NS::SharedPtr<_Class> TransferPtr(_Class* pObject) +{ + NS::SharedPtr<_Class> ret; + ret.m_pObject = pObject; + return ret; +} + +} + +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr() + : m_pObject(nullptr) +{ +} + +template +_NS_INLINE NS::SharedPtr<_Class>::~SharedPtr<_Class>() __attribute__((no_sanitize("undefined"))) +{ + m_pObject->release(); +} + +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(std::nullptr_t) noexcept + : m_pObject(nullptr) +{ +} + +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const SharedPtr<_Class>& other) noexcept + : m_pObject(other.m_pObject->retain()) +{ +} + +template +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(const SharedPtr<_OtherClass>& other, typename std::enable_if_t> *) noexcept + : m_pObject(reinterpret_cast<_Class*>(other.get()->retain())) +{ +} + +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(SharedPtr<_Class>&& other) noexcept + : m_pObject(other.m_pObject) +{ + other.m_pObject = nullptr; +} + +template +template +_NS_INLINE NS::SharedPtr<_Class>::SharedPtr(SharedPtr<_OtherClass>&& other, typename std::enable_if_t> *) noexcept + : m_pObject(reinterpret_cast<_Class*>(other.get())) +{ + other.detach(); +} + +template +_NS_INLINE _Class* NS::SharedPtr<_Class>::get() const +{ + return m_pObject; +} + +template +_NS_INLINE _Class* NS::SharedPtr<_Class>::operator->() const +{ + return m_pObject; +} + +template +_NS_INLINE NS::SharedPtr<_Class>::operator bool() const +{ + return nullptr != m_pObject; +} + +template +_NS_INLINE void NS::SharedPtr<_Class>::reset() __attribute__((no_sanitize("undefined"))) +{ + m_pObject->release(); + m_pObject = nullptr; +} + +template +_NS_INLINE void NS::SharedPtr<_Class>::detach() +{ + m_pObject = nullptr; +} + +template +_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(const SharedPtr<_Class>& other) __attribute__((no_sanitize("undefined"))) +{ + _Class* pOldObject = m_pObject; + + m_pObject = other.m_pObject->retain(); + + pOldObject->release(); + + return *this; +} + +template +template +typename std::enable_if_t, NS::SharedPtr<_Class> &> +_NS_INLINE NS::SharedPtr<_Class>::operator=(const SharedPtr<_OtherClass>& other) __attribute__((no_sanitize("undefined"))) +{ + _Class* pOldObject = m_pObject; + + m_pObject = reinterpret_cast<_Class*>(other.get()->retain()); + + pOldObject->release(); + + return *this; +} + +template +_NS_INLINE NS::SharedPtr<_Class>& NS::SharedPtr<_Class>::operator=(SharedPtr<_Class>&& other) __attribute__((no_sanitize("undefined"))) +{ + if (m_pObject != other.m_pObject) + { + m_pObject->release(); + m_pObject = other.m_pObject; + } + else + { + m_pObject = other.m_pObject; + other.m_pObject->release(); + } + other.m_pObject = nullptr; + return *this; +} + +template +template +typename std::enable_if_t, NS::SharedPtr<_Class> &> +_NS_INLINE NS::SharedPtr<_Class>::operator=(SharedPtr<_OtherClass>&& other) __attribute__((no_sanitize("undefined"))) +{ + if (m_pObject != other.get()) + { + m_pObject->release(); + m_pObject = reinterpret_cast<_Class*>(other.get()); + other.detach(); + } + else + { + m_pObject = other.get(); + other.reset(); + } + return *this; +} + +template +_NS_INLINE bool operator==(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs) +{ + return lhs.get() == rhs.get(); +} + +template +_NS_INLINE bool operator!=(const NS::SharedPtr<_ClassLhs>& lhs, const NS::SharedPtr<_ClassRhs>& rhs) +{ + return lhs.get() != rhs.get(); +} diff --git a/thirdparty/metal-cpp/Foundation/NSString.hpp b/thirdparty/metal-cpp/Foundation/NSString.hpp new file mode 100644 index 0000000000..d4d0c52ec2 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSString.hpp @@ -0,0 +1,262 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSString.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObjCRuntime.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSRange.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +_NS_ENUM(NS::UInteger, StringEncoding) { + ASCIIStringEncoding = 1, + NEXTSTEPStringEncoding = 2, + JapaneseEUCStringEncoding = 3, + UTF8StringEncoding = 4, + ISOLatin1StringEncoding = 5, + SymbolStringEncoding = 6, + NonLossyASCIIStringEncoding = 7, + ShiftJISStringEncoding = 8, + ISOLatin2StringEncoding = 9, + UnicodeStringEncoding = 10, + WindowsCP1251StringEncoding = 11, + WindowsCP1252StringEncoding = 12, + WindowsCP1253StringEncoding = 13, + WindowsCP1254StringEncoding = 14, + WindowsCP1250StringEncoding = 15, + ISO2022JPStringEncoding = 21, + MacOSRomanStringEncoding = 30, + + UTF16StringEncoding = UnicodeStringEncoding, + + UTF16BigEndianStringEncoding = 0x90000100, + UTF16LittleEndianStringEncoding = 0x94000100, + + UTF32StringEncoding = 0x8c000100, + UTF32BigEndianStringEncoding = 0x98000100, + UTF32LittleEndianStringEncoding = 0x9c000100 +}; + +_NS_OPTIONS(NS::UInteger, StringCompareOptions) { + CaseInsensitiveSearch = 1, + LiteralSearch = 2, + BackwardsSearch = 4, + AnchoredSearch = 8, + NumericSearch = 64, + DiacriticInsensitiveSearch = 128, + WidthInsensitiveSearch = 256, + ForcedOrderingSearch = 512, + RegularExpressionSearch = 1024 +}; + +using unichar = unsigned short; + +class String : public Copying +{ +public: + static String* string(); + static String* string(const String* pString); + static String* string(const char* pString, StringEncoding encoding); + + static String* alloc(); + String* init(); + String* init(const String* pString); + String* init(const char* pString, StringEncoding encoding); + String* init(void* pBytes, UInteger len, StringEncoding encoding); + String* init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer); + + unichar character(UInteger index) const; + UInteger length() const; + + const char* cString(StringEncoding encoding) const; + const char* utf8String() const; + UInteger maximumLengthOfBytes(StringEncoding encoding) const; + UInteger lengthOfBytes(StringEncoding encoding) const; + + bool isEqualToString(const String* pString) const; + Range rangeOfString(const String* pString, StringCompareOptions options) const; + + const char* fileSystemRepresentation() const; + + String* stringByAppendingString(const String* pString) const; + ComparisonResult caseInsensitiveCompare(const String* pString) const; +}; + +/// Create an NS::String* from a string literal. +#define MTLSTR(literal) (NS::String*)__builtin___CFStringMakeConstantString("" literal "") + +template +[[deprecated("please use MTLSTR(str)")]] constexpr const String* MakeConstantString(const char (&str)[_StringLen]) +{ + return reinterpret_cast(__CFStringMakeConstantString(str)); +} + +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::string() +{ + return sendMessage(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(string)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::string(const String* pString) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithString_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::string(const char* pString, StringEncoding encoding) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSString), _NS_PRIVATE_SEL(stringWithCString_encoding_), pString, encoding); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::alloc() +{ + return Object::alloc(_NS_PRIVATE_CLS(NSString)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::init() +{ + return Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::init(const String* pString) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithString_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::init(const char* pString, StringEncoding encoding) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithCString_encoding_), pString, encoding); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBytes_length_encoding_), pBytes, len, encoding); +} +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_), pBytes, len, encoding, freeBuffer); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::unichar NS::String::character(UInteger index) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(characterAtIndex_), index); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::String::length() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(length)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE const char* NS::String::cString(StringEncoding encoding) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(cStringUsingEncoding_), encoding); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE const char* NS::String::utf8String() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(UTF8String)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::String::maximumLengthOfBytes(StringEncoding encoding) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(maximumLengthOfBytesUsingEncoding_), encoding); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::UInteger NS::String::lengthOfBytes(StringEncoding encoding) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(lengthOfBytesUsingEncoding_), encoding); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE bool NS::String::isEqualToString(const NS::String* pString) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(isEqualToString_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::Range NS::String::rangeOfString(const NS::String* pString, NS::StringCompareOptions options) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(rangeOfString_options_), pString, options); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE const char* NS::String::fileSystemRepresentation() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(fileSystemRepresentation)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::String* NS::String::stringByAppendingString(const String* pString) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(stringByAppendingString_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::ComparisonResult NS::String::caseInsensitiveCompare(const String* pString) const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(caseInsensitiveCompare_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSTypes.hpp b/thirdparty/metal-cpp/Foundation/NSTypes.hpp new file mode 100644 index 0000000000..e6b723e5ce --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSTypes.hpp @@ -0,0 +1,51 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSTypes.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" + +#include +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +using TimeInterval = double; + +using Integer = std::intptr_t; +using UInteger = std::uintptr_t; + +const Integer IntegerMax = INTPTR_MAX; +const Integer IntegerMin = INTPTR_MIN; +const UInteger UIntegerMax = UINTPTR_MAX; + +struct OperatingSystemVersion +{ + Integer majorVersion; + Integer minorVersion; + Integer patchVersion; +} _NS_PACKED; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Foundation/NSURL.hpp b/thirdparty/metal-cpp/Foundation/NSURL.hpp new file mode 100644 index 0000000000..d90e5d70b8 --- /dev/null +++ b/thirdparty/metal-cpp/Foundation/NSURL.hpp @@ -0,0 +1,90 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Foundation/NSURL.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "NSDefines.hpp" +#include "NSObject.hpp" +#include "NSPrivate.hpp" +#include "NSTypes.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace NS +{ +class URL : public Copying +{ +public: + static URL* fileURLWithPath(const class String* pPath); + + static URL* alloc(); + URL* init(); + URL* init(const class String* pString); + URL* initFileURLWithPath(const class String* pPath); + + const char* fileSystemRepresentation() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::URL::fileURLWithPath(const String* pPath) +{ + return Object::sendMessage(_NS_PRIVATE_CLS(NSURL), _NS_PRIVATE_SEL(fileURLWithPath_), pPath); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::URL::alloc() +{ + return Object::alloc(_NS_PRIVATE_CLS(NSURL)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::URL::init() +{ + return Object::init(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::URL::init(const String* pString) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithString_), pString); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE NS::URL* NS::URL::initFileURLWithPath(const String* pPath) +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(initFileURLWithPath_), pPath); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_NS_INLINE const char* NS::URL::fileSystemRepresentation() const +{ + return Object::sendMessage(this, _NS_PRIVATE_SEL(fileSystemRepresentation)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/LICENSE.txt b/thirdparty/metal-cpp/LICENSE.txt new file mode 100644 index 0000000000..d07f885e7a --- /dev/null +++ b/thirdparty/metal-cpp/LICENSE.txt @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright © 2024 Apple Inc. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/thirdparty/metal-cpp/Metal/MTL4AccelerationStructure.hpp b/thirdparty/metal-cpp/Metal/MTL4AccelerationStructure.hpp new file mode 100644 index 0000000000..11540150fe --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4AccelerationStructure.hpp @@ -0,0 +1,1395 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4AccelerationStructure.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAccelerationStructure.hpp" +#include "MTLAccelerationStructureTypes.hpp" +#include "MTLArgument.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLStageInputOutputDescriptor.hpp" + +namespace MTL4 +{ +class AccelerationStructureBoundingBoxGeometryDescriptor; +class AccelerationStructureCurveGeometryDescriptor; +class AccelerationStructureDescriptor; +class AccelerationStructureGeometryDescriptor; +class AccelerationStructureMotionBoundingBoxGeometryDescriptor; +class AccelerationStructureMotionCurveGeometryDescriptor; +class AccelerationStructureMotionTriangleGeometryDescriptor; +class AccelerationStructureTriangleGeometryDescriptor; +class IndirectInstanceAccelerationStructureDescriptor; +class InstanceAccelerationStructureDescriptor; +class PrimitiveAccelerationStructureDescriptor; + +class AccelerationStructureDescriptor : public NS::Copying +{ +public: + static AccelerationStructureDescriptor* alloc(); + + AccelerationStructureDescriptor* init(); +}; +class AccelerationStructureGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureGeometryDescriptor* alloc(); + + bool allowDuplicateIntersectionFunctionInvocation() const; + + AccelerationStructureGeometryDescriptor* init(); + + NS::UInteger intersectionFunctionTableOffset() const; + + NS::String* label() const; + + bool opaque() const; + + BufferRange primitiveDataBuffer() const; + + NS::UInteger primitiveDataElementSize() const; + + NS::UInteger primitiveDataStride() const; + + void setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation); + + void setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset); + + void setLabel(const NS::String* label); + + void setOpaque(bool opaque); + + void setPrimitiveDataBuffer(const MTL4::BufferRange primitiveDataBuffer); + + void setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize); + + void setPrimitiveDataStride(NS::UInteger primitiveDataStride); +}; +class PrimitiveAccelerationStructureDescriptor : public NS::Copying +{ +public: + static PrimitiveAccelerationStructureDescriptor* alloc(); + + NS::Array* geometryDescriptors() const; + + PrimitiveAccelerationStructureDescriptor* init(); + + MTL::MotionBorderMode motionEndBorderMode() const; + + float motionEndTime() const; + + NS::UInteger motionKeyframeCount() const; + + MTL::MotionBorderMode motionStartBorderMode() const; + + float motionStartTime() const; + + void setGeometryDescriptors(const NS::Array* geometryDescriptors); + + void setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode); + + void setMotionEndTime(float motionEndTime); + + void setMotionKeyframeCount(NS::UInteger motionKeyframeCount); + + void setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode); + + void setMotionStartTime(float motionStartTime); +}; +class AccelerationStructureTriangleGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureTriangleGeometryDescriptor* alloc(); + + BufferRange indexBuffer() const; + + MTL::IndexType indexType() const; + + AccelerationStructureTriangleGeometryDescriptor* init(); + + void setIndexBuffer(const MTL4::BufferRange indexBuffer); + + void setIndexType(MTL::IndexType indexType); + + void setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer); + + void setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout); + + void setTriangleCount(NS::UInteger triangleCount); + + void setVertexBuffer(const MTL4::BufferRange vertexBuffer); + + void setVertexFormat(MTL::AttributeFormat vertexFormat); + + void setVertexStride(NS::UInteger vertexStride); + + BufferRange transformationMatrixBuffer() const; + + MTL::MatrixLayout transformationMatrixLayout() const; + + NS::UInteger triangleCount() const; + + BufferRange vertexBuffer() const; + + MTL::AttributeFormat vertexFormat() const; + + NS::UInteger vertexStride() const; +}; +class AccelerationStructureBoundingBoxGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureBoundingBoxGeometryDescriptor* alloc(); + + BufferRange boundingBoxBuffer() const; + + NS::UInteger boundingBoxCount() const; + + NS::UInteger boundingBoxStride() const; + + AccelerationStructureBoundingBoxGeometryDescriptor* init(); + + void setBoundingBoxBuffer(const MTL4::BufferRange boundingBoxBuffer); + + void setBoundingBoxCount(NS::UInteger boundingBoxCount); + + void setBoundingBoxStride(NS::UInteger boundingBoxStride); +}; +class AccelerationStructureMotionTriangleGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionTriangleGeometryDescriptor* alloc(); + + BufferRange indexBuffer() const; + + MTL::IndexType indexType() const; + + AccelerationStructureMotionTriangleGeometryDescriptor* init(); + + void setIndexBuffer(const MTL4::BufferRange indexBuffer); + + void setIndexType(MTL::IndexType indexType); + + void setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer); + + void setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout); + + void setTriangleCount(NS::UInteger triangleCount); + + void setVertexBuffers(const MTL4::BufferRange vertexBuffers); + + void setVertexFormat(MTL::AttributeFormat vertexFormat); + + void setVertexStride(NS::UInteger vertexStride); + + BufferRange transformationMatrixBuffer() const; + + MTL::MatrixLayout transformationMatrixLayout() const; + + NS::UInteger triangleCount() const; + + BufferRange vertexBuffers() const; + + MTL::AttributeFormat vertexFormat() const; + + NS::UInteger vertexStride() const; +}; +class AccelerationStructureMotionBoundingBoxGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionBoundingBoxGeometryDescriptor* alloc(); + + BufferRange boundingBoxBuffers() const; + + NS::UInteger boundingBoxCount() const; + + NS::UInteger boundingBoxStride() const; + + AccelerationStructureMotionBoundingBoxGeometryDescriptor* init(); + + void setBoundingBoxBuffers(const MTL4::BufferRange boundingBoxBuffers); + + void setBoundingBoxCount(NS::UInteger boundingBoxCount); + + void setBoundingBoxStride(NS::UInteger boundingBoxStride); +}; +class AccelerationStructureCurveGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureCurveGeometryDescriptor* alloc(); + + BufferRange controlPointBuffer() const; + + NS::UInteger controlPointCount() const; + + MTL::AttributeFormat controlPointFormat() const; + + NS::UInteger controlPointStride() const; + + MTL::CurveBasis curveBasis() const; + + MTL::CurveEndCaps curveEndCaps() const; + + MTL::CurveType curveType() const; + + BufferRange indexBuffer() const; + + MTL::IndexType indexType() const; + + AccelerationStructureCurveGeometryDescriptor* init(); + + BufferRange radiusBuffer() const; + + MTL::AttributeFormat radiusFormat() const; + + NS::UInteger radiusStride() const; + + NS::UInteger segmentControlPointCount() const; + + NS::UInteger segmentCount() const; + + void setControlPointBuffer(const MTL4::BufferRange controlPointBuffer); + + void setControlPointCount(NS::UInteger controlPointCount); + + void setControlPointFormat(MTL::AttributeFormat controlPointFormat); + + void setControlPointStride(NS::UInteger controlPointStride); + + void setCurveBasis(MTL::CurveBasis curveBasis); + + void setCurveEndCaps(MTL::CurveEndCaps curveEndCaps); + + void setCurveType(MTL::CurveType curveType); + + void setIndexBuffer(const MTL4::BufferRange indexBuffer); + + void setIndexType(MTL::IndexType indexType); + + void setRadiusBuffer(const MTL4::BufferRange radiusBuffer); + + void setRadiusFormat(MTL::AttributeFormat radiusFormat); + + void setRadiusStride(NS::UInteger radiusStride); + + void setSegmentControlPointCount(NS::UInteger segmentControlPointCount); + + void setSegmentCount(NS::UInteger segmentCount); +}; +class AccelerationStructureMotionCurveGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionCurveGeometryDescriptor* alloc(); + + BufferRange controlPointBuffers() const; + + NS::UInteger controlPointCount() const; + + MTL::AttributeFormat controlPointFormat() const; + + NS::UInteger controlPointStride() const; + + MTL::CurveBasis curveBasis() const; + + MTL::CurveEndCaps curveEndCaps() const; + + MTL::CurveType curveType() const; + + BufferRange indexBuffer() const; + + MTL::IndexType indexType() const; + + AccelerationStructureMotionCurveGeometryDescriptor* init(); + + BufferRange radiusBuffers() const; + + MTL::AttributeFormat radiusFormat() const; + + NS::UInteger radiusStride() const; + + NS::UInteger segmentControlPointCount() const; + + NS::UInteger segmentCount() const; + + void setControlPointBuffers(const MTL4::BufferRange controlPointBuffers); + + void setControlPointCount(NS::UInteger controlPointCount); + + void setControlPointFormat(MTL::AttributeFormat controlPointFormat); + + void setControlPointStride(NS::UInteger controlPointStride); + + void setCurveBasis(MTL::CurveBasis curveBasis); + + void setCurveEndCaps(MTL::CurveEndCaps curveEndCaps); + + void setCurveType(MTL::CurveType curveType); + + void setIndexBuffer(const MTL4::BufferRange indexBuffer); + + void setIndexType(MTL::IndexType indexType); + + void setRadiusBuffers(const MTL4::BufferRange radiusBuffers); + + void setRadiusFormat(MTL::AttributeFormat radiusFormat); + + void setRadiusStride(NS::UInteger radiusStride); + + void setSegmentControlPointCount(NS::UInteger segmentControlPointCount); + + void setSegmentCount(NS::UInteger segmentCount); +}; +class InstanceAccelerationStructureDescriptor : public NS::Copying +{ +public: + static InstanceAccelerationStructureDescriptor* alloc(); + + InstanceAccelerationStructureDescriptor* init(); + + NS::UInteger instanceCount() const; + + BufferRange instanceDescriptorBuffer() const; + + NS::UInteger instanceDescriptorStride() const; + + MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType() const; + + MTL::MatrixLayout instanceTransformationMatrixLayout() const; + + BufferRange motionTransformBuffer() const; + + NS::UInteger motionTransformCount() const; + + NS::UInteger motionTransformStride() const; + + MTL::TransformType motionTransformType() const; + + void setInstanceCount(NS::UInteger instanceCount); + + void setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer); + + void setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride); + + void setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType); + + void setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout); + + void setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer); + + void setMotionTransformCount(NS::UInteger motionTransformCount); + + void setMotionTransformStride(NS::UInteger motionTransformStride); + + void setMotionTransformType(MTL::TransformType motionTransformType); +}; +class IndirectInstanceAccelerationStructureDescriptor : public NS::Copying +{ +public: + static IndirectInstanceAccelerationStructureDescriptor* alloc(); + + IndirectInstanceAccelerationStructureDescriptor* init(); + + BufferRange instanceCountBuffer() const; + + BufferRange instanceDescriptorBuffer() const; + + NS::UInteger instanceDescriptorStride() const; + + MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType() const; + + MTL::MatrixLayout instanceTransformationMatrixLayout() const; + + NS::UInteger maxInstanceCount() const; + + NS::UInteger maxMotionTransformCount() const; + + BufferRange motionTransformBuffer() const; + + BufferRange motionTransformCountBuffer() const; + + NS::UInteger motionTransformStride() const; + + MTL::TransformType motionTransformType() const; + + void setInstanceCountBuffer(const MTL4::BufferRange instanceCountBuffer); + + void setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer); + + void setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride); + + void setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType); + + void setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout); + + void setMaxInstanceCount(NS::UInteger maxInstanceCount); + + void setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount); + + void setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer); + + void setMotionTransformCountBuffer(const MTL4::BufferRange motionTransformCountBuffer); + + void setMotionTransformStride(NS::UInteger motionTransformStride); + + void setMotionTransformType(MTL::TransformType motionTransformType); +}; + +} +_MTL_INLINE MTL4::AccelerationStructureDescriptor* MTL4::AccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL4::AccelerationStructureDescriptor* MTL4::AccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::AccelerationStructureGeometryDescriptor* MTL4::AccelerationStructureGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureGeometryDescriptor)); +} + +_MTL_INLINE bool MTL4::AccelerationStructureGeometryDescriptor::allowDuplicateIntersectionFunctionInvocation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allowDuplicateIntersectionFunctionInvocation)); +} + +_MTL_INLINE MTL4::AccelerationStructureGeometryDescriptor* MTL4::AccelerationStructureGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::intersectionFunctionTableOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(intersectionFunctionTableOffset)); +} + +_MTL_INLINE NS::String* MTL4::AccelerationStructureGeometryDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE bool MTL4::AccelerationStructureGeometryDescriptor::opaque() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(opaque)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureGeometryDescriptor::primitiveDataBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::primitiveDataElementSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataElementSize)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::primitiveDataStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataStride)); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAllowDuplicateIntersectionFunctionInvocation_), allowDuplicateIntersectionFunctionInvocation); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTableOffset_), intersectionFunctionTableOffset); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setOpaque(bool opaque) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaque_), opaque); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataBuffer(const MTL4::BufferRange primitiveDataBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataBuffer_), primitiveDataBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataElementSize_), primitiveDataElementSize); +} + +_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataStride(NS::UInteger primitiveDataStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataStride_), primitiveDataStride); +} + +_MTL_INLINE MTL4::PrimitiveAccelerationStructureDescriptor* MTL4::PrimitiveAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4PrimitiveAccelerationStructureDescriptor)); +} + +_MTL_INLINE NS::Array* MTL4::PrimitiveAccelerationStructureDescriptor::geometryDescriptors() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(geometryDescriptors)); +} + +_MTL_INLINE MTL4::PrimitiveAccelerationStructureDescriptor* MTL4::PrimitiveAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::MotionBorderMode MTL4::PrimitiveAccelerationStructureDescriptor::motionEndBorderMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionEndBorderMode)); +} + +_MTL_INLINE float MTL4::PrimitiveAccelerationStructureDescriptor::motionEndTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionEndTime)); +} + +_MTL_INLINE NS::UInteger MTL4::PrimitiveAccelerationStructureDescriptor::motionKeyframeCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionKeyframeCount)); +} + +_MTL_INLINE MTL::MotionBorderMode MTL4::PrimitiveAccelerationStructureDescriptor::motionStartBorderMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionStartBorderMode)); +} + +_MTL_INLINE float MTL4::PrimitiveAccelerationStructureDescriptor::motionStartTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionStartTime)); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setGeometryDescriptors(const NS::Array* geometryDescriptors) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setGeometryDescriptors_), geometryDescriptors); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionEndBorderMode_), motionEndBorderMode); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionEndTime(float motionEndTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionEndTime_), motionEndTime); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionKeyframeCount(NS::UInteger motionKeyframeCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionKeyframeCount_), motionKeyframeCount); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionStartBorderMode_), motionStartBorderMode); +} + +_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionStartTime(float motionStartTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionStartTime_), motionStartTime); +} + +_MTL_INLINE MTL4::AccelerationStructureTriangleGeometryDescriptor* MTL4::AccelerationStructureTriangleGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureTriangleGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureTriangleGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL4::AccelerationStructureTriangleGeometryDescriptor* MTL4::AccelerationStructureTriangleGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexBuffer(const MTL4::BufferRange vertexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_), vertexBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer)); +} + +_MTL_INLINE MTL::MatrixLayout MTL4::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureTriangleGeometryDescriptor::triangleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(triangleCount)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBuffer)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexStride)); +} + +_MTL_INLINE MTL4::AccelerationStructureBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureBoundingBoxGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxCount)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxStride)); +} + +_MTL_INLINE MTL4::AccelerationStructureBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBuffer(const MTL4::BufferRange boundingBoxBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffer_), boundingBoxBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionTriangleGeometryDescriptor* MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionTriangleGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionTriangleGeometryDescriptor* MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexBuffers(const MTL4::BufferRange vertexBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffers_), vertexBuffers); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer)); +} + +_MTL_INLINE MTL::MatrixLayout MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::triangleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(triangleCount)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBuffers)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexStride)); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionBoundingBoxGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxBuffers)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxCount)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxStride)); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxBuffers(const MTL4::BufferRange boundingBoxBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffers_), boundingBoxBuffers); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride); +} + +_MTL_INLINE MTL4::AccelerationStructureCurveGeometryDescriptor* MTL4::AccelerationStructureCurveGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureCurveGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointCount)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointStride)); +} + +_MTL_INLINE MTL::CurveBasis MTL4::AccelerationStructureCurveGeometryDescriptor::curveBasis() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveBasis)); +} + +_MTL_INLINE MTL::CurveEndCaps MTL4::AccelerationStructureCurveGeometryDescriptor::curveEndCaps() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveEndCaps)); +} + +_MTL_INLINE MTL::CurveType MTL4::AccelerationStructureCurveGeometryDescriptor::curveType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveType)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureCurveGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL4::AccelerationStructureCurveGeometryDescriptor* MTL4::AccelerationStructureCurveGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::radiusBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusBuffer)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureCurveGeometryDescriptor::radiusFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::radiusStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusStride)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::segmentControlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentControlPointCount)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::segmentCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentCount)); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointBuffer(const MTL4::BufferRange controlPointBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointBuffer_), controlPointBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveType_), curveType); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusBuffer(const MTL4::BufferRange radiusBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusBuffer_), radiusBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionCurveGeometryDescriptor* MTL4::AccelerationStructureMotionCurveGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionCurveGeometryDescriptor)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointBuffers)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointCount)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointStride)); +} + +_MTL_INLINE MTL::CurveBasis MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveBasis() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveBasis)); +} + +_MTL_INLINE MTL::CurveEndCaps MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveEndCaps() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveEndCaps)); +} + +_MTL_INLINE MTL::CurveType MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveType)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureMotionCurveGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL4::AccelerationStructureMotionCurveGeometryDescriptor* MTL4::AccelerationStructureMotionCurveGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusBuffers)); +} + +_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusFormat)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusStride)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::segmentControlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentControlPointCount)); +} + +_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::segmentCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentCount)); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointBuffers(const MTL4::BufferRange controlPointBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointBuffers_), controlPointBuffers); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveType_), curveType); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusBuffers(const MTL4::BufferRange radiusBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusBuffers_), radiusBuffers); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount); +} + +_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount); +} + +_MTL_INLINE MTL4::InstanceAccelerationStructureDescriptor* MTL4::InstanceAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4InstanceAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL4::InstanceAccelerationStructureDescriptor* MTL4::InstanceAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::instanceCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceCount)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorStride)); +} + +_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorType)); +} + +_MTL_INLINE MTL::MatrixLayout MTL4::InstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::InstanceAccelerationStructureDescriptor::motionTransformBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::motionTransformCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformCount)); +} + +_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::motionTransformStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformStride)); +} + +_MTL_INLINE MTL::TransformType MTL4::InstanceAccelerationStructureDescriptor::motionTransformType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformType)); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceCount(NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceCount_), instanceCount); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformCount(NS::UInteger motionTransformCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformCount_), motionTransformCount); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride); +} + +_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType); +} + +_MTL_INLINE MTL4::IndirectInstanceAccelerationStructureDescriptor* MTL4::IndirectInstanceAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4IndirectInstanceAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL4::IndirectInstanceAccelerationStructureDescriptor* MTL4::IndirectInstanceAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceCountBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceCountBuffer)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorStride)); +} + +_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorType)); +} + +_MTL_INLINE MTL::MatrixLayout MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::maxInstanceCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxInstanceCount)); +} + +_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::maxMotionTransformCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxMotionTransformCount)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBuffer)); +} + +_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformCountBuffer)); +} + +_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformStride)); +} + +_MTL_INLINE MTL::TransformType MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformType)); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBuffer(const MTL4::BufferRange instanceCountBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceCountBuffer_), instanceCountBuffer); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMaxInstanceCount(NS::UInteger maxInstanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxInstanceCount_), maxInstanceCount); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxMotionTransformCount_), maxMotionTransformCount); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBuffer(const MTL4::BufferRange motionTransformCountBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformCountBuffer_), motionTransformCountBuffer); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride); +} + +_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4Archive.hpp b/thirdparty/metal-cpp/Metal/MTL4Archive.hpp new file mode 100644 index 0000000000..c83ef6389a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4Archive.hpp @@ -0,0 +1,93 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4Archive.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class ComputePipelineState; +class RenderPipelineState; +} + +namespace MTL4 +{ +class BinaryFunction; +class BinaryFunctionDescriptor; +class ComputePipelineDescriptor; +class PipelineDescriptor; +class PipelineStageDynamicLinkingDescriptor; +class RenderPipelineDynamicLinkingDescriptor; + +class Archive : public NS::Referencing +{ +public: + NS::String* label() const; + + BinaryFunction* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, NS::Error** error); + + MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, NS::Error** error); + MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error); + + MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, NS::Error** error); + MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error); + + void setLabel(const NS::String* label); +}; + +} +_MTL_INLINE NS::String* MTL4::Archive::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::BinaryFunction* MTL4::Archive::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL4::Archive::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL4::Archive::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_error_), descriptor, dynamicLinkingDescriptor, error); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL4::Archive::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL4::Archive::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_error_), descriptor, dynamicLinkingDescriptor, error); +} + +_MTL_INLINE void MTL4::Archive::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4ArgumentTable.hpp b/thirdparty/metal-cpp/Metal/MTL4ArgumentTable.hpp new file mode 100644 index 0000000000..7788ed94fd --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4ArgumentTable.hpp @@ -0,0 +1,187 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4ArgumentTable.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLGPUAddress.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Device; +} + +namespace MTL4 +{ +class ArgumentTableDescriptor : public NS::Copying +{ +public: + static ArgumentTableDescriptor* alloc(); + + ArgumentTableDescriptor* init(); + bool initializeBindings() const; + + NS::String* label() const; + + NS::UInteger maxBufferBindCount() const; + + NS::UInteger maxSamplerStateBindCount() const; + + NS::UInteger maxTextureBindCount() const; + + void setInitializeBindings(bool initializeBindings); + + void setLabel(const NS::String* label); + + void setMaxBufferBindCount(NS::UInteger maxBufferBindCount); + + void setMaxSamplerStateBindCount(NS::UInteger maxSamplerStateBindCount); + + void setMaxTextureBindCount(NS::UInteger maxTextureBindCount); + + void setSupportAttributeStrides(bool supportAttributeStrides); + bool supportAttributeStrides() const; +}; +class ArgumentTable : public NS::Referencing +{ +public: + MTL::Device* device() const; + + NS::String* label() const; + + void setAddress(MTL::GPUAddress gpuAddress, NS::UInteger bindingIndex); + void setAddress(MTL::GPUAddress gpuAddress, NS::UInteger stride, NS::UInteger bindingIndex); + + void setResource(MTL::ResourceID resourceID, NS::UInteger bindingIndex); + + void setSamplerState(MTL::ResourceID resourceID, NS::UInteger bindingIndex); + + void setTexture(MTL::ResourceID resourceID, NS::UInteger bindingIndex); +}; + +} +_MTL_INLINE MTL4::ArgumentTableDescriptor* MTL4::ArgumentTableDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4ArgumentTableDescriptor)); +} + +_MTL_INLINE MTL4::ArgumentTableDescriptor* MTL4::ArgumentTableDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL4::ArgumentTableDescriptor::initializeBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initializeBindings)); +} + +_MTL_INLINE NS::String* MTL4::ArgumentTableDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxBufferBindCount)); +} + +_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxSamplerStateBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxSamplerStateBindCount)); +} + +_MTL_INLINE NS::UInteger MTL4::ArgumentTableDescriptor::maxTextureBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTextureBindCount)); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setInitializeBindings(bool initializeBindings) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInitializeBindings_), initializeBindings); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxBufferBindCount(NS::UInteger maxBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxBufferBindCount_), maxBufferBindCount); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxSamplerStateBindCount(NS::UInteger maxSamplerStateBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxSamplerStateBindCount_), maxSamplerStateBindCount); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setMaxTextureBindCount(NS::UInteger maxTextureBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTextureBindCount_), maxTextureBindCount); +} + +_MTL_INLINE void MTL4::ArgumentTableDescriptor::setSupportAttributeStrides(bool supportAttributeStrides) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportAttributeStrides_), supportAttributeStrides); +} + +_MTL_INLINE bool MTL4::ArgumentTableDescriptor::supportAttributeStrides() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportAttributeStrides)); +} + +_MTL_INLINE MTL::Device* MTL4::ArgumentTable::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL4::ArgumentTable::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::ArgumentTable::setAddress(MTL::GPUAddress gpuAddress, NS::UInteger bindingIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAddress_atIndex_), gpuAddress, bindingIndex); +} + +_MTL_INLINE void MTL4::ArgumentTable::setAddress(MTL::GPUAddress gpuAddress, NS::UInteger stride, NS::UInteger bindingIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAddress_attributeStride_atIndex_), gpuAddress, stride, bindingIndex); +} + +_MTL_INLINE void MTL4::ArgumentTable::setResource(MTL::ResourceID resourceID, NS::UInteger bindingIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResource_atBufferIndex_), resourceID, bindingIndex); +} + +_MTL_INLINE void MTL4::ArgumentTable::setSamplerState(MTL::ResourceID resourceID, NS::UInteger bindingIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), resourceID, bindingIndex); +} + +_MTL_INLINE void MTL4::ArgumentTable::setTexture(MTL::ResourceID resourceID, NS::UInteger bindingIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), resourceID, bindingIndex); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4BinaryFunction.hpp b/thirdparty/metal-cpp/Metal/MTL4BinaryFunction.hpp new file mode 100644 index 0000000000..30d90a6b2a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4BinaryFunction.hpp @@ -0,0 +1,50 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4BinaryFunction.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLLibrary.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ + +class BinaryFunction : public NS::Referencing +{ +public: + MTL::FunctionType functionType() const; + + NS::String* name() const; +}; + +} + +_MTL_INLINE MTL::FunctionType MTL4::BinaryFunction::functionType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionType)); +} + +_MTL_INLINE NS::String* MTL4::BinaryFunction::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4BinaryFunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4BinaryFunctionDescriptor.hpp new file mode 100644 index 0000000000..ce173ce004 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4BinaryFunctionDescriptor.hpp @@ -0,0 +1,97 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4BinaryFunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class BinaryFunctionDescriptor; +class FunctionDescriptor; + +_MTL_OPTIONS(NS::UInteger, BinaryFunctionOptions) { + BinaryFunctionOptionNone = 0, + BinaryFunctionOptionPipelineIndependent = 1 << 1, +}; + +class BinaryFunctionDescriptor : public NS::Copying +{ +public: + static BinaryFunctionDescriptor* alloc(); + + FunctionDescriptor* functionDescriptor() const; + + BinaryFunctionDescriptor* init(); + + NS::String* name() const; + + BinaryFunctionOptions options() const; + + void setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor); + + void setName(const NS::String* name); + + void setOptions(MTL4::BinaryFunctionOptions options); +}; + +} +_MTL_INLINE MTL4::BinaryFunctionDescriptor* MTL4::BinaryFunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4BinaryFunctionDescriptor)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::BinaryFunctionDescriptor::functionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionDescriptor)); +} + +_MTL_INLINE MTL4::BinaryFunctionDescriptor* MTL4::BinaryFunctionDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::BinaryFunctionDescriptor::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL4::BinaryFunctionOptions MTL4::BinaryFunctionDescriptor::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionDescriptor_), functionDescriptor); +} + +_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setName(const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setName_), name); +} + +_MTL_INLINE void MTL4::BinaryFunctionDescriptor::setOptions(MTL4::BinaryFunctionOptions options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptions_), options); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CommandAllocator.hpp b/thirdparty/metal-cpp/Metal/MTL4CommandAllocator.hpp new file mode 100644 index 0000000000..a36b05081d --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CommandAllocator.hpp @@ -0,0 +1,100 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CommandAllocator.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +namespace MTL +{ +class Device; +} + +namespace MTL4 +{ + +class CommandAllocatorDescriptor : public NS::Copying +{ +public: + static CommandAllocatorDescriptor* alloc(); + + CommandAllocatorDescriptor* init(); + + NS::String* label() const; + void setLabel(const NS::String* label); +}; + +class CommandAllocator : public NS::Referencing +{ +public: + uint64_t allocatedSize(); + + MTL::Device* device() const; + + NS::String* label() const; + + void reset(); +}; + +} + +_MTL_INLINE MTL4::CommandAllocatorDescriptor* MTL4::CommandAllocatorDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CommandAllocatorDescriptor)); +} + +_MTL_INLINE MTL4::CommandAllocatorDescriptor* MTL4::CommandAllocatorDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::CommandAllocatorDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::CommandAllocatorDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE uint64_t MTL4::CommandAllocator::allocatedSize() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allocatedSize)); +} + +_MTL_INLINE MTL::Device* MTL4::CommandAllocator::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL4::CommandAllocator::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::CommandAllocator::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CommandBuffer.hpp b/thirdparty/metal-cpp/Metal/MTL4CommandBuffer.hpp new file mode 100644 index 0000000000..a69cc9413b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CommandBuffer.hpp @@ -0,0 +1,193 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CommandBuffer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4RenderCommandEncoder.hpp" +#include "MTLAccelerationStructureTypes.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class CommandAllocator; +class CommandBufferOptions; +class ComputeCommandEncoder; +class CounterHeap; +class MachineLearningCommandEncoder; +class RenderCommandEncoder; +class RenderPassDescriptor; +} + +namespace MTL +{ +class Device; +class Fence; +class LogState; +class ResidencySet; +} + +namespace MTL4 +{ +class CommandBufferOptions : public NS::Copying +{ +public: + static CommandBufferOptions* alloc(); + + CommandBufferOptions* init(); + + MTL::LogState* logState() const; + void setLogState(const MTL::LogState* logState); +}; +class CommandBuffer : public NS::Referencing +{ +public: + void beginCommandBuffer(const MTL4::CommandAllocator* allocator); + void beginCommandBuffer(const MTL4::CommandAllocator* allocator, const MTL4::CommandBufferOptions* options); + + ComputeCommandEncoder* computeCommandEncoder(); + + MTL::Device* device() const; + + void endCommandBuffer(); + + NS::String* label() const; + + MachineLearningCommandEncoder* machineLearningCommandEncoder(); + + void popDebugGroup(); + + void pushDebugGroup(const NS::String* string); + + RenderCommandEncoder* renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor); + RenderCommandEncoder* renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor, MTL4::RenderEncoderOptions options); + + void resolveCounterHeap(const MTL4::CounterHeap* counterHeap, NS::Range range, const MTL4::BufferRange bufferRange, const MTL::Fence* fenceToWait, const MTL::Fence* fenceToUpdate); + + void setLabel(const NS::String* label); + + void useResidencySet(const MTL::ResidencySet* residencySet); + void useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + void writeTimestampIntoHeap(const MTL4::CounterHeap* counterHeap, NS::UInteger index); +}; + +} +_MTL_INLINE MTL4::CommandBufferOptions* MTL4::CommandBufferOptions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CommandBufferOptions)); +} + +_MTL_INLINE MTL4::CommandBufferOptions* MTL4::CommandBufferOptions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::LogState* MTL4::CommandBufferOptions::logState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(logState)); +} + +_MTL_INLINE void MTL4::CommandBufferOptions::setLogState(const MTL::LogState* logState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLogState_), logState); +} + +_MTL_INLINE void MTL4::CommandBuffer::beginCommandBuffer(const MTL4::CommandAllocator* allocator) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(beginCommandBufferWithAllocator_), allocator); +} + +_MTL_INLINE void MTL4::CommandBuffer::beginCommandBuffer(const MTL4::CommandAllocator* allocator, const MTL4::CommandBufferOptions* options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(beginCommandBufferWithAllocator_options_), allocator, options); +} + +_MTL_INLINE MTL4::ComputeCommandEncoder* MTL4::CommandBuffer::computeCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeCommandEncoder)); +} + +_MTL_INLINE MTL::Device* MTL4::CommandBuffer::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE void MTL4::CommandBuffer::endCommandBuffer() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(endCommandBuffer)); +} + +_MTL_INLINE NS::String* MTL4::CommandBuffer::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::MachineLearningCommandEncoder* MTL4::CommandBuffer::machineLearningCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(machineLearningCommandEncoder)); +} + +_MTL_INLINE void MTL4::CommandBuffer::popDebugGroup() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(popDebugGroup)); +} + +_MTL_INLINE void MTL4::CommandBuffer::pushDebugGroup(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string); +} + +_MTL_INLINE MTL4::RenderCommandEncoder* MTL4::CommandBuffer::renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL4::RenderCommandEncoder* MTL4::CommandBuffer::renderCommandEncoder(const MTL4::RenderPassDescriptor* descriptor, MTL4::RenderEncoderOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_options_), descriptor, options); +} + +_MTL_INLINE void MTL4::CommandBuffer::resolveCounterHeap(const MTL4::CounterHeap* counterHeap, NS::Range range, const MTL4::BufferRange bufferRange, const MTL::Fence* fenceToWait, const MTL::Fence* fenceToUpdate) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveCounterHeap_withRange_intoBuffer_waitFence_updateFence_), counterHeap, range, bufferRange, fenceToWait, fenceToUpdate); +} + +_MTL_INLINE void MTL4::CommandBuffer::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::CommandBuffer::useResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResidencySet_), residencySet); +} + +_MTL_INLINE void MTL4::CommandBuffer::useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResidencySets_count_), residencySets, count); +} + +_MTL_INLINE void MTL4::CommandBuffer::writeTimestampIntoHeap(const MTL4::CounterHeap* counterHeap, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeTimestampIntoHeap_atIndex_), counterHeap, index); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTL4CommandEncoder.hpp new file mode 100644 index 0000000000..2336021ee5 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CommandEncoder.hpp @@ -0,0 +1,134 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class CommandBuffer; +} + +namespace MTL +{ +class Fence; +} + +namespace MTL4 +{ +_MTL_OPTIONS(NS::UInteger, VisibilityOptions) { + VisibilityOptionNone = 0, + VisibilityOptionDevice = 1, + VisibilityOptionResourceAlias = 1 << 1, +}; + +class CommandEncoder : public NS::Referencing +{ +public: + void barrierAfterEncoderStages(MTL::Stages afterEncoderStages, MTL::Stages beforeEncoderStages, MTL4::VisibilityOptions visibilityOptions); + + void barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages, MTL4::VisibilityOptions visibilityOptions); + + void barrierAfterStages(MTL::Stages afterStages, MTL::Stages beforeQueueStages, MTL4::VisibilityOptions visibilityOptions); + + CommandBuffer* commandBuffer() const; + + void endEncoding(); + + void insertDebugSignpost(const NS::String* string); + + NS::String* label() const; + + void popDebugGroup(); + + void pushDebugGroup(const NS::String* string); + + void setLabel(const NS::String* label); + + void updateFence(const MTL::Fence* fence, MTL::Stages afterEncoderStages); + + void waitForFence(const MTL::Fence* fence, MTL::Stages beforeEncoderStages); +}; + +} +_MTL_INLINE void MTL4::CommandEncoder::barrierAfterEncoderStages(MTL::Stages afterEncoderStages, MTL::Stages beforeEncoderStages, MTL4::VisibilityOptions visibilityOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(barrierAfterEncoderStages_beforeEncoderStages_visibilityOptions_), afterEncoderStages, beforeEncoderStages, visibilityOptions); +} + +_MTL_INLINE void MTL4::CommandEncoder::barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages, MTL4::VisibilityOptions visibilityOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(barrierAfterQueueStages_beforeStages_visibilityOptions_), afterQueueStages, beforeStages, visibilityOptions); +} + +_MTL_INLINE void MTL4::CommandEncoder::barrierAfterStages(MTL::Stages afterStages, MTL::Stages beforeQueueStages, MTL4::VisibilityOptions visibilityOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(barrierAfterStages_beforeQueueStages_visibilityOptions_), afterStages, beforeQueueStages, visibilityOptions); +} + +_MTL_INLINE MTL4::CommandBuffer* MTL4::CommandEncoder::commandBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBuffer)); +} + +_MTL_INLINE void MTL4::CommandEncoder::endEncoding() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(endEncoding)); +} + +_MTL_INLINE void MTL4::CommandEncoder::insertDebugSignpost(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(insertDebugSignpost_), string); +} + +_MTL_INLINE NS::String* MTL4::CommandEncoder::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::CommandEncoder::popDebugGroup() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(popDebugGroup)); +} + +_MTL_INLINE void MTL4::CommandEncoder::pushDebugGroup(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string); +} + +_MTL_INLINE void MTL4::CommandEncoder::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::CommandEncoder::updateFence(const MTL::Fence* fence, MTL::Stages afterEncoderStages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_afterEncoderStages_), fence, afterEncoderStages); +} + +_MTL_INLINE void MTL4::CommandEncoder::waitForFence(const MTL::Fence* fence, MTL::Stages beforeEncoderStages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_beforeEncoderStages_), fence, beforeEncoderStages); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CommandQueue.hpp b/thirdparty/metal-cpp/Metal/MTL4CommandQueue.hpp new file mode 100644 index 0000000000..cbd21c7a20 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CommandQueue.hpp @@ -0,0 +1,283 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CommandQueue.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4CommitFeedback.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResourceStateCommandEncoder.hpp" +#include "MTLTypes.hpp" +#include +#include + +namespace MTL +{ +class Buffer; +class Device; +class Drawable; +class Event; +class Heap; +class ResidencySet; +class Texture; +} + +namespace MTL4 +{ +class CommandBuffer; +class CommandQueueDescriptor; +class CommitOptions; +struct CopySparseBufferMappingOperation; +struct CopySparseTextureMappingOperation; +struct UpdateSparseBufferMappingOperation; +struct UpdateSparseTextureMappingOperation; +_MTL_ENUM(NS::Integer, CommandQueueError) { + CommandQueueErrorNone = 0, + CommandQueueErrorTimeout = 1, + CommandQueueErrorNotPermitted = 2, + CommandQueueErrorOutOfMemory = 3, + CommandQueueErrorDeviceRemoved = 4, + CommandQueueErrorAccessRevoked = 5, + CommandQueueErrorInternal = 6, +}; + +struct UpdateSparseTextureMappingOperation +{ + MTL::SparseTextureMappingMode mode; + MTL::Region textureRegion; + NS::UInteger textureLevel; + NS::UInteger textureSlice; + NS::UInteger heapOffset; +} _MTL_PACKED; + +struct CopySparseTextureMappingOperation +{ + MTL::Region sourceRegion; + NS::UInteger sourceLevel; + NS::UInteger sourceSlice; + MTL::Origin destinationOrigin; + NS::UInteger destinationLevel; + NS::UInteger destinationSlice; +} _MTL_PACKED; + +struct UpdateSparseBufferMappingOperation +{ + MTL::SparseTextureMappingMode mode; + NS::Range bufferRange; + NS::UInteger heapOffset; +} _MTL_PACKED; + +struct CopySparseBufferMappingOperation +{ + NS::Range sourceRange; + NS::UInteger destinationOffset; +} _MTL_PACKED; + +class CommitOptions : public NS::Referencing +{ +public: + void addFeedbackHandler(const MTL4::CommitFeedbackHandler block); + void addFeedbackHandler(const MTL4::CommitFeedbackHandlerFunction& function); + + static CommitOptions* alloc(); + + CommitOptions* init(); +}; +class CommandQueueDescriptor : public NS::Copying +{ +public: + static CommandQueueDescriptor* alloc(); + + dispatch_queue_t feedbackQueue() const; + + CommandQueueDescriptor* init(); + + NS::String* label() const; + + void setFeedbackQueue(const dispatch_queue_t feedbackQueue); + + void setLabel(const NS::String* label); +}; +class CommandQueue : public NS::Referencing +{ +public: + void addResidencySet(const MTL::ResidencySet* residencySet); + void addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + void commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count); + void commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count, const MTL4::CommitOptions* options); + + void copyBufferMappingsFromBuffer(const MTL::Buffer* sourceBuffer, const MTL::Buffer* destinationBuffer, const MTL4::CopySparseBufferMappingOperation* operations, NS::UInteger count); + + void copyTextureMappingsFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture, const MTL4::CopySparseTextureMappingOperation* operations, NS::UInteger count); + + MTL::Device* device() const; + + NS::String* label() const; + + void removeResidencySet(const MTL::ResidencySet* residencySet); + void removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + void signalDrawable(const MTL::Drawable* drawable); + + void signalEvent(const MTL::Event* event, uint64_t value); + + void updateBufferMappings(const MTL::Buffer* buffer, const MTL::Heap* heap, const MTL4::UpdateSparseBufferMappingOperation* operations, NS::UInteger count); + + void updateTextureMappings(const MTL::Texture* texture, const MTL::Heap* heap, const MTL4::UpdateSparseTextureMappingOperation* operations, NS::UInteger count); + + void wait(const MTL::Event* event, uint64_t value); + void wait(const MTL::Drawable* drawable); +}; + +} + +_MTL_INLINE void MTL4::CommitOptions::addFeedbackHandler(const MTL4::CommitFeedbackHandler block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addFeedbackHandler_), block); +} + +_MTL_INLINE void MTL4::CommitOptions::addFeedbackHandler(const MTL4::CommitFeedbackHandlerFunction& function) +{ + __block MTL4::CommitFeedbackHandlerFunction blockFunction = function; + addFeedbackHandler(^(MTL4::CommitFeedback* pFeedback) { blockFunction(pFeedback); }); +} + +_MTL_INLINE MTL4::CommitOptions* MTL4::CommitOptions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CommitOptions)); +} + +_MTL_INLINE MTL4::CommitOptions* MTL4::CommitOptions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::CommandQueueDescriptor* MTL4::CommandQueueDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CommandQueueDescriptor)); +} + +_MTL_INLINE dispatch_queue_t MTL4::CommandQueueDescriptor::feedbackQueue() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(feedbackQueue)); +} + +_MTL_INLINE MTL4::CommandQueueDescriptor* MTL4::CommandQueueDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::CommandQueueDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::CommandQueueDescriptor::setFeedbackQueue(const dispatch_queue_t feedbackQueue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFeedbackQueue_), feedbackQueue); +} + +_MTL_INLINE void MTL4::CommandQueueDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::CommandQueue::addResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addResidencySet_), residencySet); +} + +_MTL_INLINE void MTL4::CommandQueue::addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addResidencySets_count_), residencySets, count); +} + +_MTL_INLINE void MTL4::CommandQueue::commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(commit_count_), commandBuffers, count); +} + +_MTL_INLINE void MTL4::CommandQueue::commit(const MTL4::CommandBuffer* const commandBuffers[], NS::UInteger count, const MTL4::CommitOptions* options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(commit_count_options_), commandBuffers, count, options); +} + +_MTL_INLINE void MTL4::CommandQueue::copyBufferMappingsFromBuffer(const MTL::Buffer* sourceBuffer, const MTL::Buffer* destinationBuffer, const MTL4::CopySparseBufferMappingOperation* operations, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyBufferMappingsFromBuffer_toBuffer_operations_count_), sourceBuffer, destinationBuffer, operations, count); +} + +_MTL_INLINE void MTL4::CommandQueue::copyTextureMappingsFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture, const MTL4::CopySparseTextureMappingOperation* operations, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyTextureMappingsFromTexture_toTexture_operations_count_), sourceTexture, destinationTexture, operations, count); +} + +_MTL_INLINE MTL::Device* MTL4::CommandQueue::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL4::CommandQueue::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL4::CommandQueue::removeResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeResidencySet_), residencySet); +} + +_MTL_INLINE void MTL4::CommandQueue::removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeResidencySets_count_), residencySets, count); +} + +_MTL_INLINE void MTL4::CommandQueue::signalDrawable(const MTL::Drawable* drawable) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(signalDrawable_), drawable); +} + +_MTL_INLINE void MTL4::CommandQueue::signalEvent(const MTL::Event* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(signalEvent_value_), event, value); +} + +_MTL_INLINE void MTL4::CommandQueue::updateBufferMappings(const MTL::Buffer* buffer, const MTL::Heap* heap, const MTL4::UpdateSparseBufferMappingOperation* operations, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateBufferMappings_heap_operations_count_), buffer, heap, operations, count); +} + +_MTL_INLINE void MTL4::CommandQueue::updateTextureMappings(const MTL::Texture* texture, const MTL::Heap* heap, const MTL4::UpdateSparseTextureMappingOperation* operations, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateTextureMappings_heap_operations_count_), texture, heap, operations, count); +} + +_MTL_INLINE void MTL4::CommandQueue::wait(const MTL::Event* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForEvent_value_), event, value); +} + +_MTL_INLINE void MTL4::CommandQueue::wait(const MTL::Drawable* drawable) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForDrawable_), drawable); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CommitFeedback.hpp b/thirdparty/metal-cpp/Metal/MTL4CommitFeedback.hpp new file mode 100644 index 0000000000..6b8181f711 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CommitFeedback.hpp @@ -0,0 +1,62 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CommitFeedback.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +#include + +namespace MTL4 +{ +class CommitFeedback; + +using CommitFeedbackHandler = void (^)(MTL4::CommitFeedback*); +using CommitFeedbackHandlerFunction = std::function; + +class CommitFeedback : public NS::Referencing +{ +public: + CFTimeInterval GPUEndTime() const; + + CFTimeInterval GPUStartTime() const; + + NS::Error* error() const; +}; + +} +_MTL_INLINE CFTimeInterval MTL4::CommitFeedback::GPUEndTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(GPUEndTime)); +} + +_MTL_INLINE CFTimeInterval MTL4::CommitFeedback::GPUStartTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(GPUStartTime)); +} + +_MTL_INLINE NS::Error* MTL4::CommitFeedback::error() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(error)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4Compiler.hpp b/thirdparty/metal-cpp/Metal/MTL4Compiler.hpp new file mode 100644 index 0000000000..94249b2978 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4Compiler.hpp @@ -0,0 +1,345 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4Compiler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLDevice.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +#include + +namespace MTL4 +{ +class BinaryFunction; +class BinaryFunctionDescriptor; +class CompilerDescriptor; +class CompilerTask; +class CompilerTaskOptions; +class ComputePipelineDescriptor; +class LibraryDescriptor; +class MachineLearningPipelineDescriptor; +class MachineLearningPipelineState; +class PipelineDataSetSerializer; +class PipelineDescriptor; +class PipelineStageDynamicLinkingDescriptor; +class RenderPipelineDynamicLinkingDescriptor; +} + +namespace MTL +{ +class ComputePipelineState; +class Device; +class DynamicLibrary; +class Library; +class RenderPipelineState; + +using NewDynamicLibraryCompletionHandler = void (^)(MTL::DynamicLibrary*, NS::Error*); +using NewDynamicLibraryCompletionHandlerFunction = std::function; +} + +namespace MTL4 +{ +using NewComputePipelineStateCompletionHandler = void (^)(MTL::ComputePipelineState*, NS::Error*); +using NewComputePipelineStateCompletionHandlerFunction = std::function; +using NewRenderPipelineStateCompletionHandler = void (^)(MTL::RenderPipelineState*, NS::Error*); +using NewRenderPipelineStateCompletionHandlerFunction = std::function; +using NewBinaryFunctionCompletionHandler = void (^)(MTL4::BinaryFunction*, NS::Error*); +using NewBinaryFunctionCompletionHandlerFunction = std::function; +using NewMachineLearningPipelineStateCompletionHandler = void (^)(MTL4::MachineLearningPipelineState*, NS::Error*); +using NewMachineLearningPipelineStateCompletionHandlerFunction = std::function; + +class CompilerDescriptor : public NS::Copying +{ +public: + static CompilerDescriptor* alloc(); + + CompilerDescriptor* init(); + + NS::String* label() const; + + PipelineDataSetSerializer* pipelineDataSetSerializer() const; + + void setLabel(const NS::String* label); + + void setPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializer* pipelineDataSetSerializer); +}; +class CompilerTaskOptions : public NS::Copying +{ +public: + static CompilerTaskOptions* alloc(); + + CompilerTaskOptions* init(); + + NS::Array* lookupArchives() const; + void setLookupArchives(const NS::Array* lookupArchives); +}; +class Compiler : public NS::Referencing +{ +public: + MTL::Device* device() const; + + NS::String* label() const; + + BinaryFunction* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error); + CompilerTask* newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL4::NewBinaryFunctionCompletionHandler completionHandler); + + MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error); + MTL::ComputePipelineState* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error); + CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler); + CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler); + CompilerTask* newComputePipelineState(const MTL4::ComputePipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewComputePipelineStateCompletionHandlerFunction& function); + + MTL::DynamicLibrary* newDynamicLibrary(const MTL::Library* library, NS::Error** error); + MTL::DynamicLibrary* newDynamicLibrary(const NS::URL* url, NS::Error** error); + CompilerTask* newDynamicLibrary(const MTL::Library* library, const MTL::NewDynamicLibraryCompletionHandler completionHandler); + CompilerTask* newDynamicLibrary(const NS::URL* url, const MTL::NewDynamicLibraryCompletionHandler completionHandler); + CompilerTask* newDynamicLibrary(const MTL::Library* pLibrary, const MTL::NewDynamicLibraryCompletionHandlerFunction& function); + CompilerTask* newDynamicLibrary(const NS::URL* pURL, const MTL::NewDynamicLibraryCompletionHandlerFunction& function); + + MTL::Library* newLibrary(const MTL4::LibraryDescriptor* descriptor, NS::Error** error); + CompilerTask* newLibrary(const MTL4::LibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler); + CompilerTask* newLibrary(const MTL4::LibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& function); + + MachineLearningPipelineState* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, NS::Error** error); + CompilerTask* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandler completionHandler); + CompilerTask* newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* pDescriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction& function); + + MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error); + MTL::RenderPipelineState* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error); + CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler); + CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler); + CompilerTask* newRenderPipelineState(const MTL4::PipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function); + MTL::RenderPipelineState* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, NS::Error** error); + CompilerTask* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, const MTL::NewRenderPipelineStateCompletionHandler completionHandler); + CompilerTask* newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* pDescriptor, const MTL::RenderPipelineState* pPipeline, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function); + + PipelineDataSetSerializer* pipelineDataSetSerializer() const; +}; + +} +_MTL_INLINE MTL4::CompilerDescriptor* MTL4::CompilerDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CompilerDescriptor)); +} + +_MTL_INLINE MTL4::CompilerDescriptor* MTL4::CompilerDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::CompilerDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::PipelineDataSetSerializer* MTL4::CompilerDescriptor::pipelineDataSetSerializer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pipelineDataSetSerializer)); +} + +_MTL_INLINE void MTL4::CompilerDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::CompilerDescriptor::setPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializer* pipelineDataSetSerializer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPipelineDataSetSerializer_), pipelineDataSetSerializer); +} + +_MTL_INLINE MTL4::CompilerTaskOptions* MTL4::CompilerTaskOptions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CompilerTaskOptions)); +} + +_MTL_INLINE MTL4::CompilerTaskOptions* MTL4::CompilerTaskOptions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL4::CompilerTaskOptions::lookupArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(lookupArchives)); +} + +_MTL_INLINE void MTL4::CompilerTaskOptions::setLookupArchives(const NS::Array* lookupArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLookupArchives_), lookupArchives); +} + +_MTL_INLINE MTL::Device* MTL4::Compiler::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL4::Compiler::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::BinaryFunction* MTL4::Compiler::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newBinaryFunction(const MTL4::BinaryFunctionDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL4::NewBinaryFunctionCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* descriptor, const MTL4::PipelineStageDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewComputePipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newComputePipelineState(const MTL4::ComputePipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewComputePipelineStateCompletionHandlerFunction& function) +{ + __block MTL4::NewComputePipelineStateCompletionHandlerFunction blockFunction = function; + return newComputePipelineState(pDescriptor, options, ^(MTL::ComputePipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); }); +} + +_MTL_INLINE MTL::DynamicLibrary* MTL4::Compiler::newDynamicLibrary(const MTL::Library* library, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibrary_error_), library, error); +} + +_MTL_INLINE MTL::DynamicLibrary* MTL4::Compiler::newDynamicLibrary(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_error_), url, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const MTL::Library* library, const MTL::NewDynamicLibraryCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibrary_completionHandler_), library, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const NS::URL* url, const MTL::NewDynamicLibraryCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_completionHandler_), url, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const MTL::Library* pLibrary, const MTL::NewDynamicLibraryCompletionHandlerFunction& function) +{ + __block MTL::NewDynamicLibraryCompletionHandlerFunction blockFunction = function; + return newDynamicLibrary(pLibrary, ^(MTL::DynamicLibrary* pLibraryRef, NS::Error* pError) { blockFunction(pLibraryRef, pError); }); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newDynamicLibrary(const NS::URL* pURL, const MTL::NewDynamicLibraryCompletionHandlerFunction& function) +{ + __block MTL::NewDynamicLibraryCompletionHandlerFunction blockFunction = function; + return newDynamicLibrary(pURL, ^(MTL::DynamicLibrary* pLibrary, NS::Error* pError) { blockFunction(pLibrary, pError); }); +} + +_MTL_INLINE MTL::Library* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newLibrary(const MTL4::LibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& function) +{ + __block MTL::NewLibraryCompletionHandlerFunction blockFunction = function; + return newLibrary(pDescriptor, ^(MTL::Library* pLibrary, NS::Error* pError) { blockFunction(pLibrary, pError); }); +} + +_MTL_INLINE MTL4::MachineLearningPipelineState* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newMachineLearningPipelineStateWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* descriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newMachineLearningPipelineStateWithDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newMachineLearningPipelineState(const MTL4::MachineLearningPipelineDescriptor* pDescriptor, const MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction& function) +{ + __block MTL4::NewMachineLearningPipelineStateCompletionHandlerFunction blockFunction = function; + return newMachineLearningPipelineState(pDescriptor, ^(MTL4::MachineLearningPipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); }); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_error_), descriptor, compilerTaskOptions, error); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_completionHandler_), descriptor, compilerTaskOptions, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* descriptor, const MTL4::RenderPipelineDynamicLinkingDescriptor* dynamicLinkingDescriptor, const MTL4::CompilerTaskOptions* compilerTaskOptions, const MTL::NewRenderPipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_), descriptor, dynamicLinkingDescriptor, compilerTaskOptions, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineState(const MTL4::PipelineDescriptor* pDescriptor, const MTL4::CompilerTaskOptions* options, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function) +{ + __block MTL4::NewRenderPipelineStateCompletionHandlerFunction blockFunction = function; + return newRenderPipelineState(pDescriptor, options, ^(MTL::RenderPipelineState* pPipeline, NS::Error* pError) { blockFunction(pPipeline, pError); }); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_error_), descriptor, pipeline, error); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* descriptor, const MTL::RenderPipelineState* pipeline, const MTL::NewRenderPipelineStateCompletionHandler completionHandler) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_completionHandler_), descriptor, pipeline, completionHandler); +} + +_MTL_INLINE MTL4::CompilerTask* MTL4::Compiler::newRenderPipelineStateBySpecialization(const MTL4::PipelineDescriptor* pDescriptor, const MTL::RenderPipelineState* pPipeline, const MTL4::NewRenderPipelineStateCompletionHandlerFunction& function) +{ + __block MTL4::NewRenderPipelineStateCompletionHandlerFunction blockFunction = function; + return newRenderPipelineStateBySpecialization(pDescriptor, pPipeline, ^(MTL::RenderPipelineState* pPipelineRef, NS::Error* pError) { blockFunction(pPipelineRef, pError); }); +} + +_MTL_INLINE MTL4::PipelineDataSetSerializer* MTL4::Compiler::pipelineDataSetSerializer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pipelineDataSetSerializer)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4CompilerTask.hpp b/thirdparty/metal-cpp/Metal/MTL4CompilerTask.hpp new file mode 100644 index 0000000000..a1ee9cdf58 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4CompilerTask.hpp @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4CompilerTask.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class Compiler; +_MTL_ENUM(NS::Integer, CompilerTaskStatus) { + CompilerTaskStatusNone = 0, + CompilerTaskStatusScheduled = 1, + CompilerTaskStatusCompiling = 2, + CompilerTaskStatusFinished = 3, +}; + +class CompilerTask : public NS::Referencing +{ +public: + Compiler* compiler() const; + + CompilerTaskStatus status() const; + + void waitUntilCompleted(); +}; + +} + +_MTL_INLINE MTL4::Compiler* MTL4::CompilerTask::compiler() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(compiler)); +} + +_MTL_INLINE MTL4::CompilerTaskStatus MTL4::CompilerTask::status() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(status)); +} + +_MTL_INLINE void MTL4::CompilerTask::waitUntilCompleted() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitUntilCompleted)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4ComputeCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTL4ComputeCommandEncoder.hpp new file mode 100644 index 0000000000..7ef19da26a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4ComputeCommandEncoder.hpp @@ -0,0 +1,300 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4ComputeCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4CommandEncoder.hpp" +#include "MTL4Counters.hpp" +#include "MTLAccelerationStructure.hpp" +#include "MTLAccelerationStructureTypes.hpp" +#include "MTLBlitCommandEncoder.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLGPUAddress.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL4 +{ +class AccelerationStructureDescriptor; +class ArgumentTable; +class CounterHeap; +} + +namespace MTL +{ +class AccelerationStructure; +class Buffer; +class ComputePipelineState; +class IndirectCommandBuffer; +class Tensor; +class TensorExtents; +class Texture; +} + +namespace MTL4 +{ +class ComputeCommandEncoder : public NS::Referencing +{ +public: + void buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL4::BufferRange scratchBuffer); + + void copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure); + + void copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure); + + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size); + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin); + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options); + + void copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions); + + void copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options); + + void copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex); + + void dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup); + void dispatchThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerThreadgroup); + + void dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup); + void dispatchThreads(MTL::GPUAddress indirectBuffer); + + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange); + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, MTL::GPUAddress indirectRangeBuffer); + + void fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value); + + void generateMipmaps(const MTL::Texture* texture); + + void optimizeContentsForCPUAccess(const MTL::Texture* texture); + void optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level); + + void optimizeContentsForGPUAccess(const MTL::Texture* texture); + void optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level); + + void optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range); + + void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer); + void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer, MTL::AccelerationStructureRefitOptions options); + + void resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range); + + void setArgumentTable(const MTL4::ArgumentTable* argumentTable); + + void setComputePipelineState(const MTL::ComputePipelineState* state); + + void setImageblockWidth(NS::UInteger width, NS::UInteger height); + + void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); + + MTL::Stages stages(); + + void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL4::BufferRange buffer); + + void writeTimestamp(MTL4::TimestampGranularity granularity, const MTL4::CounterHeap* counterHeap, NS::UInteger index); +}; + +} +_MTL_INLINE void MTL4::ComputeCommandEncoder::buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL4::BufferRange scratchBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(buildAccelerationStructure_descriptor_scratchBuffer_), accelerationStructure, descriptor, scratchBuffer); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_), sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTensor_sourceOrigin_sourceDimensions_toTensor_destinationOrigin_destinationDimensions_), sourceTensor, sourceOrigin, sourceDimensions, destinationTensor, destinationOrigin, destinationDimensions); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_toTexture_), sourceTexture, destinationTexture); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_), sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_), source, sourceRange, destination, destinationIndex); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadgroupsWithIndirectBuffer_threadsPerThreadgroup_), indirectBuffer, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::dispatchThreads(MTL::GPUAddress indirectBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadsWithIndirectBuffer_), indirectBuffer); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, MTL::GPUAddress indirectRangeBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_), indirectCommandbuffer, indirectRangeBuffer); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(fillBuffer_range_value_), buffer, range, value); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::generateMipmaps(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(generateMipmapsForTexture_), texture); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_), texture); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_slice_level_), texture, slice, level); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_), texture); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_slice_level_), texture, slice, level); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeIndirectCommandBuffer_withRange_), indirectCommandBuffer, range); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL4::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL4::BufferRange scratchBuffer, MTL::AccelerationStructureRefitOptions options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_options_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, options); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resetCommandsInBuffer_withRange_), buffer, range); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentTable_), argumentTable); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::setComputePipelineState(const MTL::ComputePipelineState* state) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputePipelineState_), state); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::setImageblockWidth(NS::UInteger width, NS::UInteger height) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index); +} + +_MTL_INLINE MTL::Stages MTL4::ComputeCommandEncoder::stages() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stages)); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL4::BufferRange buffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_), accelerationStructure, buffer); +} + +_MTL_INLINE void MTL4::ComputeCommandEncoder::writeTimestamp(MTL4::TimestampGranularity granularity, const MTL4::CounterHeap* counterHeap, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeTimestampWithGranularity_intoHeap_atIndex_), granularity, counterHeap, index); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4ComputePipeline.hpp b/thirdparty/metal-cpp/Metal/MTL4ComputePipeline.hpp new file mode 100644 index 0000000000..a808431aa5 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4ComputePipeline.hpp @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4ComputePipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4PipelineState.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL4 +{ +class ComputePipelineDescriptor; +class FunctionDescriptor; +class StaticLinkingDescriptor; + +class ComputePipelineDescriptor : public NS::Copying +{ +public: + static ComputePipelineDescriptor* alloc(); + + FunctionDescriptor* computeFunctionDescriptor() const; + + ComputePipelineDescriptor* init(); + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + MTL::Size requiredThreadsPerThreadgroup() const; + + void reset(); + + void setComputeFunctionDescriptor(const MTL4::FunctionDescriptor* computeFunctionDescriptor); + + void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup); + + void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup); + + void setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor); + + void setSupportBinaryLinking(bool supportBinaryLinking); + + void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers); + + void setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth); + + StaticLinkingDescriptor* staticLinkingDescriptor() const; + + bool supportBinaryLinking() const; + + IndirectCommandBufferSupportState supportIndirectCommandBuffers() const; + + bool threadGroupSizeIsMultipleOfThreadExecutionWidth() const; +}; + +} +_MTL_INLINE MTL4::ComputePipelineDescriptor* MTL4::ComputePipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4ComputePipelineDescriptor)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::ComputePipelineDescriptor::computeFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeFunctionDescriptor)); +} + +_MTL_INLINE MTL4::ComputePipelineDescriptor* MTL4::ComputePipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL4::ComputePipelineDescriptor::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE MTL::Size MTL4::ComputePipelineDescriptor::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setComputeFunctionDescriptor(const MTL4::FunctionDescriptor* computeFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputeFunctionDescriptor_), computeFunctionDescriptor); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStaticLinkingDescriptor_), staticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setSupportBinaryLinking(bool supportBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportBinaryLinking_), supportBinaryLinking); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE void MTL4::ComputePipelineDescriptor::setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_), threadGroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::ComputePipelineDescriptor::staticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(staticLinkingDescriptor)); +} + +_MTL_INLINE bool MTL4::ComputePipelineDescriptor::supportBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportBinaryLinking)); +} + +_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::ComputePipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE bool MTL4::ComputePipelineDescriptor::threadGroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4Counters.hpp b/thirdparty/metal-cpp/Metal/MTL4Counters.hpp new file mode 100644 index 0000000000..b507b766c5 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4Counters.hpp @@ -0,0 +1,138 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4Counters.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +#include + +namespace MTL4 +{ +class CounterHeapDescriptor; +_MTL_ENUM(NS::Integer, CounterHeapType) { + CounterHeapTypeInvalid, + CounterHeapTypeTimestamp, +}; + +_MTL_ENUM(NS::Integer, TimestampGranularity) { + TimestampGranularityRelaxed = 0, + TimestampGranularityPrecise = 1, +}; + +struct TimestampHeapEntry +{ + uint64_t timestamp; +} _MTL_PACKED; + +class CounterHeapDescriptor : public NS::Copying +{ +public: + static CounterHeapDescriptor* alloc(); + + NS::UInteger count() const; + + CounterHeapDescriptor* init(); + + void setCount(NS::UInteger count); + + void setType(MTL4::CounterHeapType type); + CounterHeapType type() const; +}; +class CounterHeap : public NS::Referencing +{ +public: + NS::UInteger count() const; + void invalidateCounterRange(NS::Range range); + + NS::String* label() const; + + NS::Data* resolveCounterRange(NS::Range range); + + void setLabel(const NS::String* label); + + CounterHeapType type() const; +}; + +} + +_MTL_INLINE MTL4::CounterHeapDescriptor* MTL4::CounterHeapDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4CounterHeapDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL4::CounterHeapDescriptor::count() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(count)); +} + +_MTL_INLINE MTL4::CounterHeapDescriptor* MTL4::CounterHeapDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::CounterHeapDescriptor::setCount(NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCount_), count); +} + +_MTL_INLINE void MTL4::CounterHeapDescriptor::setType(MTL4::CounterHeapType type) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setType_), type); +} + +_MTL_INLINE MTL4::CounterHeapType MTL4::CounterHeapDescriptor::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE NS::UInteger MTL4::CounterHeap::count() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(count)); +} + +_MTL_INLINE void MTL4::CounterHeap::invalidateCounterRange(NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(invalidateCounterRange_), range); +} + +_MTL_INLINE NS::String* MTL4::CounterHeap::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::Data* MTL4::CounterHeap::resolveCounterRange(NS::Range range) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveCounterRange_), range); +} + +_MTL_INLINE void MTL4::CounterHeap::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL4::CounterHeapType MTL4::CounterHeap::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4FunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4FunctionDescriptor.hpp new file mode 100644 index 0000000000..9049677ebc --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4FunctionDescriptor.hpp @@ -0,0 +1,49 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal//MTL4FunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; + +class FunctionDescriptor : public NS::Copying +{ +public: + static FunctionDescriptor* alloc(); + + FunctionDescriptor* init(); +}; + +} +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::FunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4FunctionDescriptor)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::FunctionDescriptor::init() +{ + return NS::Object::init(); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4LibraryDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4LibraryDescriptor.hpp new file mode 100644 index 0000000000..bc491b693b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4LibraryDescriptor.hpp @@ -0,0 +1,98 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4LibraryDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class LibraryDescriptor; +} + +namespace MTL +{ +class CompileOptions; +} + +namespace MTL4 +{ +class LibraryDescriptor : public NS::Copying +{ +public: + static LibraryDescriptor* alloc(); + + LibraryDescriptor* init(); + + NS::String* name() const; + + MTL::CompileOptions* options() const; + + void setName(const NS::String* name); + + void setOptions(const MTL::CompileOptions* options); + + void setSource(const NS::String* source); + NS::String* source() const; +}; + +} +_MTL_INLINE MTL4::LibraryDescriptor* MTL4::LibraryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4LibraryDescriptor)); +} + +_MTL_INLINE MTL4::LibraryDescriptor* MTL4::LibraryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::LibraryDescriptor::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::CompileOptions* MTL4::LibraryDescriptor::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE void MTL4::LibraryDescriptor::setName(const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setName_), name); +} + +_MTL_INLINE void MTL4::LibraryDescriptor::setOptions(const MTL::CompileOptions* options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptions_), options); +} + +_MTL_INLINE void MTL4::LibraryDescriptor::setSource(const NS::String* source) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSource_), source); +} + +_MTL_INLINE NS::String* MTL4::LibraryDescriptor::source() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(source)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4LibraryFunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4LibraryFunctionDescriptor.hpp new file mode 100644 index 0000000000..1dec4bf288 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4LibraryFunctionDescriptor.hpp @@ -0,0 +1,86 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4LibraryFunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4FunctionDescriptor.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class LibraryFunctionDescriptor; +} + +namespace MTL +{ +class Library; +} + +namespace MTL4 +{ +class LibraryFunctionDescriptor : public NS::Copying +{ +public: + static LibraryFunctionDescriptor* alloc(); + + LibraryFunctionDescriptor* init(); + + MTL::Library* library() const; + + NS::String* name() const; + + void setLibrary(const MTL::Library* library); + + void setName(const NS::String* name); +}; + +} +_MTL_INLINE MTL4::LibraryFunctionDescriptor* MTL4::LibraryFunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4LibraryFunctionDescriptor)); +} + +_MTL_INLINE MTL4::LibraryFunctionDescriptor* MTL4::LibraryFunctionDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Library* MTL4::LibraryFunctionDescriptor::library() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(library)); +} + +_MTL_INLINE NS::String* MTL4::LibraryFunctionDescriptor::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE void MTL4::LibraryFunctionDescriptor::setLibrary(const MTL::Library* library) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLibrary_), library); +} + +_MTL_INLINE void MTL4::LibraryFunctionDescriptor::setName(const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setName_), name); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4LinkingDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4LinkingDescriptor.hpp new file mode 100644 index 0000000000..ef5900b1fa --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4LinkingDescriptor.hpp @@ -0,0 +1,204 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4LinkingDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class PipelineStageDynamicLinkingDescriptor; +class RenderPipelineDynamicLinkingDescriptor; +class StaticLinkingDescriptor; + +class StaticLinkingDescriptor : public NS::Copying +{ +public: + static StaticLinkingDescriptor* alloc(); + + NS::Array* functionDescriptors() const; + + NS::Dictionary* groups() const; + + StaticLinkingDescriptor* init(); + + NS::Array* privateFunctionDescriptors() const; + + void setFunctionDescriptors(const NS::Array* functionDescriptors); + + void setGroups(const NS::Dictionary* groups); + + void setPrivateFunctionDescriptors(const NS::Array* privateFunctionDescriptors); +}; +class PipelineStageDynamicLinkingDescriptor : public NS::Copying +{ +public: + static PipelineStageDynamicLinkingDescriptor* alloc(); + + NS::Array* binaryLinkedFunctions() const; + + PipelineStageDynamicLinkingDescriptor* init(); + + NS::UInteger maxCallStackDepth() const; + + NS::Array* preloadedLibraries() const; + + void setBinaryLinkedFunctions(const NS::Array* binaryLinkedFunctions); + + void setMaxCallStackDepth(NS::UInteger maxCallStackDepth); + + void setPreloadedLibraries(const NS::Array* preloadedLibraries); +}; +class RenderPipelineDynamicLinkingDescriptor : public NS::Copying +{ +public: + static RenderPipelineDynamicLinkingDescriptor* alloc(); + + PipelineStageDynamicLinkingDescriptor* fragmentLinkingDescriptor() const; + + RenderPipelineDynamicLinkingDescriptor* init(); + + PipelineStageDynamicLinkingDescriptor* meshLinkingDescriptor() const; + + PipelineStageDynamicLinkingDescriptor* objectLinkingDescriptor() const; + + PipelineStageDynamicLinkingDescriptor* tileLinkingDescriptor() const; + + PipelineStageDynamicLinkingDescriptor* vertexLinkingDescriptor() const; +}; + +} +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::StaticLinkingDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4StaticLinkingDescriptor)); +} + +_MTL_INLINE NS::Array* MTL4::StaticLinkingDescriptor::functionDescriptors() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionDescriptors)); +} + +_MTL_INLINE NS::Dictionary* MTL4::StaticLinkingDescriptor::groups() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(groups)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::StaticLinkingDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL4::StaticLinkingDescriptor::privateFunctionDescriptors() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(privateFunctionDescriptors)); +} + +_MTL_INLINE void MTL4::StaticLinkingDescriptor::setFunctionDescriptors(const NS::Array* functionDescriptors) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionDescriptors_), functionDescriptors); +} + +_MTL_INLINE void MTL4::StaticLinkingDescriptor::setGroups(const NS::Dictionary* groups) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setGroups_), groups); +} + +_MTL_INLINE void MTL4::StaticLinkingDescriptor::setPrivateFunctionDescriptors(const NS::Array* privateFunctionDescriptors) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrivateFunctionDescriptors_), privateFunctionDescriptors); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::PipelineStageDynamicLinkingDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4PipelineStageDynamicLinkingDescriptor)); +} + +_MTL_INLINE NS::Array* MTL4::PipelineStageDynamicLinkingDescriptor::binaryLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryLinkedFunctions)); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::PipelineStageDynamicLinkingDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL4::PipelineStageDynamicLinkingDescriptor::maxCallStackDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCallStackDepth)); +} + +_MTL_INLINE NS::Array* MTL4::PipelineStageDynamicLinkingDescriptor::preloadedLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(preloadedLibraries)); +} + +_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setBinaryLinkedFunctions(const NS::Array* binaryLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryLinkedFunctions_), binaryLinkedFunctions); +} + +_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth); +} + +_MTL_INLINE void MTL4::PipelineStageDynamicLinkingDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries); +} + +_MTL_INLINE MTL4::RenderPipelineDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPipelineDynamicLinkingDescriptor)); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::fragmentLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentLinkingDescriptor)); +} + +_MTL_INLINE MTL4::RenderPipelineDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::meshLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshLinkingDescriptor)); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::objectLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectLinkingDescriptor)); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::tileLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileLinkingDescriptor)); +} + +_MTL_INLINE MTL4::PipelineStageDynamicLinkingDescriptor* MTL4::RenderPipelineDynamicLinkingDescriptor::vertexLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexLinkingDescriptor)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4MachineLearningCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTL4MachineLearningCommandEncoder.hpp new file mode 100644 index 0000000000..4d3cff66eb --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4MachineLearningCommandEncoder.hpp @@ -0,0 +1,66 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4MachineLearningCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4CommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class ArgumentTable; +class MachineLearningPipelineState; +} + +namespace MTL +{ +class Heap; +} + +namespace MTL4 +{ +class MachineLearningCommandEncoder : public NS::Referencing +{ +public: + void dispatchNetwork(const MTL::Heap* heap); + + void setArgumentTable(const MTL4::ArgumentTable* argumentTable); + + void setPipelineState(const MTL4::MachineLearningPipelineState* pipelineState); +}; + +} +_MTL_INLINE void MTL4::MachineLearningCommandEncoder::dispatchNetwork(const MTL::Heap* heap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchNetworkWithIntermediatesHeap_), heap); +} + +_MTL_INLINE void MTL4::MachineLearningCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentTable_), argumentTable); +} + +_MTL_INLINE void MTL4::MachineLearningCommandEncoder::setPipelineState(const MTL4::MachineLearningPipelineState* pipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPipelineState_), pipelineState); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4MachineLearningPipeline.hpp b/thirdparty/metal-cpp/Metal/MTL4MachineLearningPipeline.hpp new file mode 100644 index 0000000000..713569f946 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4MachineLearningPipeline.hpp @@ -0,0 +1,172 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4MachineLearningPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4PipelineState.hpp" +#include "MTLAllocation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; +class MachineLearningPipelineDescriptor; +class MachineLearningPipelineReflection; +} + +namespace MTL +{ +class Device; +class TensorExtents; +} + +namespace MTL4 +{ +class MachineLearningPipelineDescriptor : public NS::Copying +{ +public: + static MachineLearningPipelineDescriptor* alloc(); + + MachineLearningPipelineDescriptor* init(); + + MTL::TensorExtents* inputDimensionsAtBufferIndex(NS::Integer bufferIndex); + + NS::String* label() const; + + FunctionDescriptor* machineLearningFunctionDescriptor() const; + + void reset(); + + void setInputDimensions(const MTL::TensorExtents* dimensions, NS::Integer bufferIndex); + void setInputDimensions(const NS::Array* dimensions, NS::Range range); + + void setLabel(const NS::String* label); + + void setMachineLearningFunctionDescriptor(const MTL4::FunctionDescriptor* machineLearningFunctionDescriptor); +}; +class MachineLearningPipelineReflection : public NS::Referencing +{ +public: + static MachineLearningPipelineReflection* alloc(); + + NS::Array* bindings() const; + + MachineLearningPipelineReflection* init(); +}; +class MachineLearningPipelineState : public NS::Referencing +{ +public: + MTL::Device* device() const; + + NS::UInteger intermediatesHeapSize() const; + + NS::String* label() const; + + MachineLearningPipelineReflection* reflection() const; +}; + +} +_MTL_INLINE MTL4::MachineLearningPipelineDescriptor* MTL4::MachineLearningPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4MachineLearningPipelineDescriptor)); +} + +_MTL_INLINE MTL4::MachineLearningPipelineDescriptor* MTL4::MachineLearningPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::TensorExtents* MTL4::MachineLearningPipelineDescriptor::inputDimensionsAtBufferIndex(NS::Integer bufferIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inputDimensionsAtBufferIndex_), bufferIndex); +} + +_MTL_INLINE NS::String* MTL4::MachineLearningPipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MachineLearningPipelineDescriptor::machineLearningFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(machineLearningFunctionDescriptor)); +} + +_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setInputDimensions(const MTL::TensorExtents* dimensions, NS::Integer bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInputDimensions_atBufferIndex_), dimensions, bufferIndex); +} + +_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setInputDimensions(const NS::Array* dimensions, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInputDimensions_withRange_), dimensions, range); +} + +_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::MachineLearningPipelineDescriptor::setMachineLearningFunctionDescriptor(const MTL4::FunctionDescriptor* machineLearningFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMachineLearningFunctionDescriptor_), machineLearningFunctionDescriptor); +} + +_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineReflection::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4MachineLearningPipelineReflection)); +} + +_MTL_INLINE NS::Array* MTL4::MachineLearningPipelineReflection::bindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bindings)); +} + +_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineReflection::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Device* MTL4::MachineLearningPipelineState::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::UInteger MTL4::MachineLearningPipelineState::intermediatesHeapSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(intermediatesHeapSize)); +} + +_MTL_INLINE NS::String* MTL4::MachineLearningPipelineState::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::MachineLearningPipelineReflection* MTL4::MachineLearningPipelineState::reflection() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(reflection)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4MeshRenderPipeline.hpp b/thirdparty/metal-cpp/Metal/MTL4MeshRenderPipeline.hpp new file mode 100644 index 0000000000..f66dffe2bc --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4MeshRenderPipeline.hpp @@ -0,0 +1,413 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4MeshRenderPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4PipelineState.hpp" +#include "MTL4RenderPipeline.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; +class MeshRenderPipelineDescriptor; +class RenderPipelineColorAttachmentDescriptorArray; +class StaticLinkingDescriptor; + +class MeshRenderPipelineDescriptor : public NS::Copying +{ +public: + static MeshRenderPipelineDescriptor* alloc(); + + AlphaToCoverageState alphaToCoverageState() const; + + AlphaToOneState alphaToOneState() const; + + LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState() const; + + RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + FunctionDescriptor* fragmentFunctionDescriptor() const; + + StaticLinkingDescriptor* fragmentStaticLinkingDescriptor() const; + + MeshRenderPipelineDescriptor* init(); + + bool isRasterizationEnabled() const; + + NS::UInteger maxTotalThreadgroupsPerMeshGrid() const; + + NS::UInteger maxTotalThreadsPerMeshThreadgroup() const; + + NS::UInteger maxTotalThreadsPerObjectThreadgroup() const; + + NS::UInteger maxVertexAmplificationCount() const; + + FunctionDescriptor* meshFunctionDescriptor() const; + + StaticLinkingDescriptor* meshStaticLinkingDescriptor() const; + + bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const; + + FunctionDescriptor* objectFunctionDescriptor() const; + + StaticLinkingDescriptor* objectStaticLinkingDescriptor() const; + + bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const; + + NS::UInteger payloadMemoryLength() const; + + NS::UInteger rasterSampleCount() const; + + [[deprecated("please use isRasterizationEnabled instead")]] + bool rasterizationEnabled() const; + + MTL::Size requiredThreadsPerMeshThreadgroup() const; + + MTL::Size requiredThreadsPerObjectThreadgroup() const; + + void reset(); + + void setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState); + + void setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState); + + void setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState); + + void setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor); + + void setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor); + + void setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid); + + void setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup); + + void setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup); + + void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount); + + void setMeshFunctionDescriptor(const MTL4::FunctionDescriptor* meshFunctionDescriptor); + + void setMeshStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* meshStaticLinkingDescriptor); + + void setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth); + + void setObjectFunctionDescriptor(const MTL4::FunctionDescriptor* objectFunctionDescriptor); + + void setObjectStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* objectStaticLinkingDescriptor); + + void setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth); + + void setPayloadMemoryLength(NS::UInteger payloadMemoryLength); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRasterizationEnabled(bool rasterizationEnabled); + + void setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup); + + void setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup); + + void setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking); + + void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers); + + void setSupportMeshBinaryLinking(bool supportMeshBinaryLinking); + + void setSupportObjectBinaryLinking(bool supportObjectBinaryLinking); + + bool supportFragmentBinaryLinking() const; + + IndirectCommandBufferSupportState supportIndirectCommandBuffers() const; + + bool supportMeshBinaryLinking() const; + + bool supportObjectBinaryLinking() const; +}; + +} +_MTL_INLINE MTL4::MeshRenderPipelineDescriptor* MTL4::MeshRenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4MeshRenderPipelineDescriptor)); +} + +_MTL_INLINE MTL4::AlphaToCoverageState MTL4::MeshRenderPipelineDescriptor::alphaToCoverageState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaToCoverageState)); +} + +_MTL_INLINE MTL4::AlphaToOneState MTL4::MeshRenderPipelineDescriptor::alphaToOneState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaToOneState)); +} + +_MTL_INLINE MTL4::LogicalToPhysicalColorAttachmentMappingState MTL4::MeshRenderPipelineDescriptor::colorAttachmentMappingState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachmentMappingState)); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::MeshRenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::fragmentFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentFunctionDescriptor)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::fragmentStaticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentStaticLinkingDescriptor)); +} + +_MTL_INLINE MTL4::MeshRenderPipelineDescriptor* MTL4::MeshRenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::isRasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadgroupsPerMeshGrid() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxTotalThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::maxVertexAmplificationCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::meshFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshFunctionDescriptor)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::meshStaticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshStaticLinkingDescriptor)); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::MeshRenderPipelineDescriptor::objectFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectFunctionDescriptor)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::MeshRenderPipelineDescriptor::objectStaticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectStaticLinkingDescriptor)); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::payloadMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(payloadMemoryLength)); +} + +_MTL_INLINE NS::UInteger MTL4::MeshRenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::rasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE MTL::Size MTL4::MeshRenderPipelineDescriptor::requiredThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE MTL::Size MTL4::MeshRenderPipelineDescriptor::requiredThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToCoverageState_), alphaToCoverageState); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToOneState_), alphaToOneState); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorAttachmentMappingState_), colorAttachmentMappingState); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentFunctionDescriptor_), fragmentFunctionDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentStaticLinkingDescriptor_), fragmentStaticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadgroupsPerMeshGrid_), maxTotalThreadgroupsPerMeshGrid); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerMeshThreadgroup_), maxTotalThreadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerObjectThreadgroup_), maxTotalThreadsPerObjectThreadgroup); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshFunctionDescriptor(const MTL4::FunctionDescriptor* meshFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshFunctionDescriptor_), meshFunctionDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* meshStaticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshStaticLinkingDescriptor_), meshStaticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_), meshThreadgroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectFunctionDescriptor(const MTL4::FunctionDescriptor* objectFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectFunctionDescriptor_), objectFunctionDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* objectStaticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectStaticLinkingDescriptor_), objectStaticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_), objectThreadgroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setPayloadMemoryLength(NS::UInteger payloadMemoryLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPayloadMemoryLength_), payloadMemoryLength); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerMeshThreadgroup_), requiredThreadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerObjectThreadgroup_), requiredThreadsPerObjectThreadgroup); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportFragmentBinaryLinking_), supportFragmentBinaryLinking); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportMeshBinaryLinking(bool supportMeshBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportMeshBinaryLinking_), supportMeshBinaryLinking); +} + +_MTL_INLINE void MTL4::MeshRenderPipelineDescriptor::setSupportObjectBinaryLinking(bool supportObjectBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportObjectBinaryLinking_), supportObjectBinaryLinking); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportFragmentBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportFragmentBinaryLinking)); +} + +_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::MeshRenderPipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportMeshBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportMeshBinaryLinking)); +} + +_MTL_INLINE bool MTL4::MeshRenderPipelineDescriptor::supportObjectBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportObjectBinaryLinking)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4PipelineDataSetSerializer.hpp b/thirdparty/metal-cpp/Metal/MTL4PipelineDataSetSerializer.hpp new file mode 100644 index 0000000000..9dbd6103a4 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4PipelineDataSetSerializer.hpp @@ -0,0 +1,85 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4PipelineDataSetSerializer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class PipelineDataSetSerializerDescriptor; + +_MTL_OPTIONS(NS::UInteger, PipelineDataSetSerializerConfiguration) { + PipelineDataSetSerializerConfigurationCaptureDescriptors = 1, + PipelineDataSetSerializerConfigurationCaptureBinaries = 1 << 1, +}; + +class PipelineDataSetSerializerDescriptor : public NS::Copying +{ +public: + static PipelineDataSetSerializerDescriptor* alloc(); + + PipelineDataSetSerializerConfiguration configuration() const; + + PipelineDataSetSerializerDescriptor* init(); + + void setConfiguration(MTL4::PipelineDataSetSerializerConfiguration configuration); +}; +class PipelineDataSetSerializer : public NS::Referencing +{ +public: + bool serializeAsArchiveAndFlushToURL(const NS::URL* url, NS::Error** error); + + NS::Data* serializeAsPipelinesScript(NS::Error** error); +}; + +} +_MTL_INLINE MTL4::PipelineDataSetSerializerDescriptor* MTL4::PipelineDataSetSerializerDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4PipelineDataSetSerializerDescriptor)); +} + +_MTL_INLINE MTL4::PipelineDataSetSerializerConfiguration MTL4::PipelineDataSetSerializerDescriptor::configuration() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(configuration)); +} + +_MTL_INLINE MTL4::PipelineDataSetSerializerDescriptor* MTL4::PipelineDataSetSerializerDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::PipelineDataSetSerializerDescriptor::setConfiguration(MTL4::PipelineDataSetSerializerConfiguration configuration) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConfiguration_), configuration); +} + +_MTL_INLINE bool MTL4::PipelineDataSetSerializer::serializeAsArchiveAndFlushToURL(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(serializeAsArchiveAndFlushToURL_error_), url, error); +} + +_MTL_INLINE NS::Data* MTL4::PipelineDataSetSerializer::serializeAsPipelinesScript(NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(serializeAsPipelinesScriptWithError_), error); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4PipelineState.hpp b/thirdparty/metal-cpp/Metal/MTL4PipelineState.hpp new file mode 100644 index 0000000000..cecefa8a14 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4PipelineState.hpp @@ -0,0 +1,150 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4PipelineState.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPipeline.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class PipelineDescriptor; +class PipelineOptions; +_MTL_ENUM(NS::Integer, AlphaToOneState) { + AlphaToOneStateDisabled = 0, + AlphaToOneStateEnabled = 1, +}; + +_MTL_ENUM(NS::Integer, AlphaToCoverageState) { + AlphaToCoverageStateDisabled = 0, + AlphaToCoverageStateEnabled = 1, +}; + +_MTL_ENUM(NS::Integer, BlendState) { + BlendStateDisabled = 0, + BlendStateEnabled = 1, + BlendStateUnspecialized = 2, +}; + +_MTL_ENUM(NS::Integer, IndirectCommandBufferSupportState) { + IndirectCommandBufferSupportStateDisabled = 0, + IndirectCommandBufferSupportStateEnabled = 1, +}; + +_MTL_OPTIONS(NS::UInteger, ShaderReflection) { + ShaderReflectionNone = 0, + ShaderReflectionBindingInfo = 1, + ShaderReflectionBufferTypeInfo = 1 << 1, +}; + +class PipelineOptions : public NS::Copying +{ +public: + static PipelineOptions* alloc(); + + PipelineOptions* init(); + + void setShaderReflection(MTL4::ShaderReflection shaderReflection); + + void setShaderValidation(MTL::ShaderValidation shaderValidation); + + ShaderReflection shaderReflection() const; + + MTL::ShaderValidation shaderValidation() const; +}; +class PipelineDescriptor : public NS::Copying +{ +public: + static PipelineDescriptor* alloc(); + + PipelineDescriptor* init(); + + NS::String* label() const; + + PipelineOptions* options() const; + + void setLabel(const NS::String* label); + + void setOptions(const MTL4::PipelineOptions* options); +}; + +} +_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineOptions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4PipelineOptions)); +} + +_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineOptions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::PipelineOptions::setShaderReflection(MTL4::ShaderReflection shaderReflection) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderReflection_), shaderReflection); +} + +_MTL_INLINE void MTL4::PipelineOptions::setShaderValidation(MTL::ShaderValidation shaderValidation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation); +} + +_MTL_INLINE MTL4::ShaderReflection MTL4::PipelineOptions::shaderReflection() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderReflection)); +} + +_MTL_INLINE MTL::ShaderValidation MTL4::PipelineOptions::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE MTL4::PipelineDescriptor* MTL4::PipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4PipelineDescriptor)); +} + +_MTL_INLINE MTL4::PipelineDescriptor* MTL4::PipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL4::PipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL4::PipelineOptions* MTL4::PipelineDescriptor::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE void MTL4::PipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL4::PipelineDescriptor::setOptions(const MTL4::PipelineOptions* options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptions_), options); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4RenderCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTL4RenderCommandEncoder.hpp new file mode 100644 index 0000000000..0dd01f4d39 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4RenderCommandEncoder.hpp @@ -0,0 +1,340 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4RenderCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4CommandEncoder.hpp" +#include "MTL4Counters.hpp" +#include "MTLArgument.hpp" +#include "MTLDefines.hpp" +#include "MTLGPUAddress.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderCommandEncoder.hpp" +#include "MTLRenderPass.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL4 +{ +class ArgumentTable; +class CounterHeap; +} + +namespace MTL +{ +class DepthStencilState; +class IndirectCommandBuffer; +class LogicalToPhysicalColorAttachmentMap; +class RenderPipelineState; +struct ScissorRect; +struct VertexAmplificationViewMapping; +struct Viewport; + +} +namespace MTL4 +{ +_MTL_OPTIONS(NS::UInteger, RenderEncoderOptions) { + RenderEncoderOptionNone = 0, + RenderEncoderOptionSuspending = 1, + RenderEncoderOptionResuming = 1 << 1, +}; + +class RenderCommandEncoder : public NS::Referencing +{ +public: + void dispatchThreadsPerTile(MTL::Size threadsPerTile); + + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, MTL::GPUAddress indirectBuffer); + + void drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + void drawMeshThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount); + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount); + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance); + void drawPrimitives(MTL::PrimitiveType primitiveType, MTL::GPUAddress indirectBuffer); + + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange); + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, MTL::GPUAddress indirectRangeBuffer); + + void setArgumentTable(const MTL4::ArgumentTable* argumentTable, MTL::RenderStages stages); + + void setBlendColor(float red, float green, float blue, float alpha); + + void setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping); + + void setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex); + + void setCullMode(MTL::CullMode cullMode); + + void setDepthBias(float depthBias, float slopeScale, float clamp); + + void setDepthClipMode(MTL::DepthClipMode depthClipMode); + + void setDepthStencilState(const MTL::DepthStencilState* depthStencilState); + + void setDepthStoreAction(MTL::StoreAction storeAction); + + void setDepthTestBounds(float minBound, float maxBound); + + void setFrontFacingWinding(MTL::Winding frontFacingWinding); + + void setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); + + void setRenderPipelineState(const MTL::RenderPipelineState* pipelineState); + + void setScissorRect(MTL::ScissorRect rect); + void setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count); + + void setStencilReferenceValue(uint32_t referenceValue); + void setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue); + + void setStencilStoreAction(MTL::StoreAction storeAction); + + void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index); + + void setTriangleFillMode(MTL::TriangleFillMode fillMode); + + void setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings); + + void setViewport(MTL::Viewport viewport); + void setViewports(const MTL::Viewport* viewports, NS::UInteger count); + + void setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset); + + NS::UInteger tileHeight() const; + + NS::UInteger tileWidth() const; + + void writeTimestamp(MTL4::TimestampGranularity granularity, MTL::RenderStages stage, const MTL4::CounterHeap* counterHeap, NS::UInteger index); +}; + +} +_MTL_INLINE void MTL4::RenderCommandEncoder::dispatchThreadsPerTile(MTL::Size threadsPerTile) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadsPerTile_), threadsPerTile); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength, instanceCount); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferLength, instanceCount, baseVertex, baseInstance); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, MTL::GPUAddress indexBuffer, NS::UInteger indexBufferLength, MTL::GPUAddress indirectBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferLength_indirectBuffer_), primitiveType, indexType, indexBuffer, indexBufferLength, indirectBuffer); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreadgroups(MTL::GPUAddress indirectBuffer, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreadgroupsWithIndirectBuffer_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), indirectBuffer, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_), primitiveType, vertexStart, vertexCount); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_), primitiveType, vertexStart, vertexCount, instanceCount); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, MTL::GPUAddress indirectBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_indirectBuffer_), primitiveType, indirectBuffer); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, MTL::GPUAddress indirectRangeBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_), indirectCommandBuffer, indirectRangeBuffer); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setArgumentTable(const MTL4::ArgumentTable* argumentTable, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentTable_atStages_), argumentTable, stages); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setBlendColor(float red, float green, float blue, float alpha) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBlendColorRed_green_blue_alpha_), red, green, blue, alpha); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorAttachmentMap_), mapping); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setCullMode(MTL::CullMode cullMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthBias(float depthBias, float slopeScale, float clamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthClipMode(MTL::DepthClipMode depthClipMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setDepthTestBounds(float minBound, float maxBound) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthTestMinBound_maxBound_), minBound, maxBound); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setFrontFacingWinding(MTL::Winding frontFacingWinding) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWinding); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setScissorRect(MTL::ScissorRect rect) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScissorRect_), rect); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScissorRects_count_), scissorRects, count); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilReferenceValue(uint32_t referenceValue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilReferenceValue_), referenceValue); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilFrontReferenceValue_backReferenceValue_), frontReferenceValue, backReferenceValue); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_offset_atIndex_), length, offset, index); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setTriangleFillMode(MTL::TriangleFillMode fillMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexAmplificationCount_viewMappings_), count, viewMappings); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setViewport(MTL::Viewport viewport) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setViewport_), viewport); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setViewports(const MTL::Viewport* viewports, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setViewports_count_), viewports, count); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultMode_offset_), mode, offset); +} + +_MTL_INLINE NS::UInteger MTL4::RenderCommandEncoder::tileHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileHeight)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderCommandEncoder::tileWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileWidth)); +} + +_MTL_INLINE void MTL4::RenderCommandEncoder::writeTimestamp(MTL4::TimestampGranularity granularity, MTL::RenderStages stage, const MTL4::CounterHeap* counterHeap, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeTimestampWithGranularity_afterStage_intoHeap_atIndex_), granularity, stage, counterHeap, index); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4RenderPass.hpp b/thirdparty/metal-cpp/Metal/MTL4RenderPass.hpp new file mode 100644 index 0000000000..c5aa9ed61b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4RenderPass.hpp @@ -0,0 +1,280 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4RenderPass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderPass.hpp" + +namespace MTL4 +{ +class RenderPassDescriptor; +} + +namespace MTL +{ +class Buffer; +class RasterizationRateMap; +class RenderPassColorAttachmentDescriptorArray; +class RenderPassDepthAttachmentDescriptor; +class RenderPassStencilAttachmentDescriptor; +struct SamplePosition; +} + +namespace MTL4 +{ +class RenderPassDescriptor : public NS::Copying +{ +public: + static RenderPassDescriptor* alloc(); + + MTL::RenderPassColorAttachmentDescriptorArray* colorAttachments() const; + + NS::UInteger defaultRasterSampleCount() const; + + MTL::RenderPassDepthAttachmentDescriptor* depthAttachment() const; + + NS::UInteger getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count); + + NS::UInteger imageblockSampleLength() const; + + RenderPassDescriptor* init(); + + MTL::RasterizationRateMap* rasterizationRateMap() const; + + NS::UInteger renderTargetArrayLength() const; + + NS::UInteger renderTargetHeight() const; + + NS::UInteger renderTargetWidth() const; + + void setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount); + + void setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment); + + void setImageblockSampleLength(NS::UInteger imageblockSampleLength); + + void setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap); + + void setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength); + + void setRenderTargetHeight(NS::UInteger renderTargetHeight); + + void setRenderTargetWidth(NS::UInteger renderTargetWidth); + + void setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count); + + void setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment); + + void setSupportColorAttachmentMapping(bool supportColorAttachmentMapping); + + void setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength); + + void setTileHeight(NS::UInteger tileHeight); + + void setTileWidth(NS::UInteger tileWidth); + + void setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer); + + void setVisibilityResultType(MTL::VisibilityResultType visibilityResultType); + + MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment() const; + + bool supportColorAttachmentMapping() const; + + NS::UInteger threadgroupMemoryLength() const; + + NS::UInteger tileHeight() const; + + NS::UInteger tileWidth() const; + + MTL::Buffer* visibilityResultBuffer() const; + + MTL::VisibilityResultType visibilityResultType() const; +}; + +} +_MTL_INLINE MTL4::RenderPassDescriptor* MTL4::RenderPassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPassDescriptor)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL4::RenderPassDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::defaultRasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(defaultRasterSampleCount)); +} + +_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL4::RenderPassDescriptor::depthAttachment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthAttachment)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(getSamplePositions_count_), positions, count); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::imageblockSampleLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(imageblockSampleLength)); +} + +_MTL_INLINE MTL4::RenderPassDescriptor* MTL4::RenderPassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RasterizationRateMap* MTL4::RenderPassDescriptor::rasterizationRateMap() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterizationRateMap)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetArrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetArrayLength)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetHeight)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::renderTargetWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetWidth)); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDefaultRasterSampleCount_), defaultRasterSampleCount); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthAttachment_), depthAttachment); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setImageblockSampleLength(NS::UInteger imageblockSampleLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setImageblockSampleLength_), imageblockSampleLength); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationRateMap_), rasterizationRateMap); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetArrayLength_), renderTargetArrayLength); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetHeight(NS::UInteger renderTargetHeight) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetHeight_), renderTargetHeight); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setRenderTargetWidth(NS::UInteger renderTargetWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetWidth_), renderTargetWidth); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplePositions_count_), positions, count); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilAttachment_), stencilAttachment); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setSupportColorAttachmentMapping(bool supportColorAttachmentMapping) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportColorAttachmentMapping_), supportColorAttachmentMapping); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_), threadgroupMemoryLength); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setTileHeight(NS::UInteger tileHeight) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileHeight_), tileHeight); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setTileWidth(NS::UInteger tileWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileWidth_), tileWidth); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultBuffer_), visibilityResultBuffer); +} + +_MTL_INLINE void MTL4::RenderPassDescriptor::setVisibilityResultType(MTL::VisibilityResultType visibilityResultType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultType_), visibilityResultType); +} + +_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL4::RenderPassDescriptor::stencilAttachment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilAttachment)); +} + +_MTL_INLINE bool MTL4::RenderPassDescriptor::supportColorAttachmentMapping() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportColorAttachmentMapping)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::threadgroupMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryLength)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::tileHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileHeight)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPassDescriptor::tileWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileWidth)); +} + +_MTL_INLINE MTL::Buffer* MTL4::RenderPassDescriptor::visibilityResultBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(visibilityResultBuffer)); +} + +_MTL_INLINE MTL::VisibilityResultType MTL4::RenderPassDescriptor::visibilityResultType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(visibilityResultType)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4RenderPipeline.hpp b/thirdparty/metal-cpp/Metal/MTL4RenderPipeline.hpp new file mode 100644 index 0000000000..fc2e5e6f66 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4RenderPipeline.hpp @@ -0,0 +1,587 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4RenderPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4PipelineState.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPixelFormat.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderPipeline.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; +class RenderPipelineBinaryFunctionsDescriptor; +class RenderPipelineColorAttachmentDescriptor; +class RenderPipelineColorAttachmentDescriptorArray; +class RenderPipelineDescriptor; +class StaticLinkingDescriptor; +} + +namespace MTL +{ +class VertexDescriptor; +} + +namespace MTL4 +{ +_MTL_ENUM(NS::Integer, LogicalToPhysicalColorAttachmentMappingState) { + LogicalToPhysicalColorAttachmentMappingStateIdentity = 0, + LogicalToPhysicalColorAttachmentMappingStateInherited = 1, +}; + +class RenderPipelineColorAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPipelineColorAttachmentDescriptor* alloc(); + + MTL::BlendOperation alphaBlendOperation() const; + + BlendState blendingState() const; + + MTL::BlendFactor destinationAlphaBlendFactor() const; + + MTL::BlendFactor destinationRGBBlendFactor() const; + + RenderPipelineColorAttachmentDescriptor* init(); + + MTL::PixelFormat pixelFormat() const; + + void reset(); + + MTL::BlendOperation rgbBlendOperation() const; + + void setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation); + + void setBlendingState(MTL4::BlendState blendingState); + + void setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor); + + void setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor); + + void setPixelFormat(MTL::PixelFormat pixelFormat); + + void setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation); + + void setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor); + + void setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor); + + void setWriteMask(MTL::ColorWriteMask writeMask); + + MTL::BlendFactor sourceAlphaBlendFactor() const; + + MTL::BlendFactor sourceRGBBlendFactor() const; + + MTL::ColorWriteMask writeMask() const; +}; + +class RenderPipelineColorAttachmentDescriptorArray : public NS::Copying +{ +public: + static RenderPipelineColorAttachmentDescriptorArray* alloc(); + + RenderPipelineColorAttachmentDescriptorArray* init(); + + RenderPipelineColorAttachmentDescriptor* object(NS::UInteger attachmentIndex); + + void reset(); + + void setObject(const MTL4::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; + +class RenderPipelineBinaryFunctionsDescriptor : public NS::Copying +{ +public: + static RenderPipelineBinaryFunctionsDescriptor* alloc(); + + NS::Array* fragmentAdditionalBinaryFunctions() const; + + RenderPipelineBinaryFunctionsDescriptor* init(); + + NS::Array* meshAdditionalBinaryFunctions() const; + + NS::Array* objectAdditionalBinaryFunctions() const; + + void reset(); + + void setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions); + + void setMeshAdditionalBinaryFunctions(const NS::Array* meshAdditionalBinaryFunctions); + + void setObjectAdditionalBinaryFunctions(const NS::Array* objectAdditionalBinaryFunctions); + + void setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions); + + void setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions); + + NS::Array* tileAdditionalBinaryFunctions() const; + + NS::Array* vertexAdditionalBinaryFunctions() const; +}; + +class RenderPipelineDescriptor : public NS::Copying +{ +public: + static RenderPipelineDescriptor* alloc(); + + AlphaToCoverageState alphaToCoverageState() const; + + AlphaToOneState alphaToOneState() const; + + LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState() const; + + RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + FunctionDescriptor* fragmentFunctionDescriptor() const; + + StaticLinkingDescriptor* fragmentStaticLinkingDescriptor() const; + + RenderPipelineDescriptor* init(); + + MTL::PrimitiveTopologyClass inputPrimitiveTopology() const; + + bool isRasterizationEnabled() const; + + NS::UInteger maxVertexAmplificationCount() const; + + NS::UInteger rasterSampleCount() const; + + [[deprecated("please use isRasterizationEnabled instead")]] + bool rasterizationEnabled() const; + + void reset(); + + void setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState); + + void setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState); + + void setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState); + + void setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor); + + void setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor); + + void setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology); + + void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRasterizationEnabled(bool rasterizationEnabled); + + void setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking); + + void setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers); + + void setSupportVertexBinaryLinking(bool supportVertexBinaryLinking); + + void setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor); + + void setVertexFunctionDescriptor(const MTL4::FunctionDescriptor* vertexFunctionDescriptor); + + void setVertexStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* vertexStaticLinkingDescriptor); + + bool supportFragmentBinaryLinking() const; + + IndirectCommandBufferSupportState supportIndirectCommandBuffers() const; + + bool supportVertexBinaryLinking() const; + + MTL::VertexDescriptor* vertexDescriptor() const; + + FunctionDescriptor* vertexFunctionDescriptor() const; + + StaticLinkingDescriptor* vertexStaticLinkingDescriptor() const; +}; + +} +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPipelineColorAttachmentDescriptor)); +} + +_MTL_INLINE MTL::BlendOperation MTL4::RenderPipelineColorAttachmentDescriptor::alphaBlendOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaBlendOperation)); +} + +_MTL_INLINE MTL4::BlendState MTL4::RenderPipelineColorAttachmentDescriptor::blendingState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(blendingState)); +} + +_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::destinationAlphaBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(destinationAlphaBlendFactor)); +} + +_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::destinationRGBBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(destinationRGBBlendFactor)); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::PixelFormat MTL4::RenderPipelineColorAttachmentDescriptor::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE MTL::BlendOperation MTL4::RenderPipelineColorAttachmentDescriptor::rgbBlendOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rgbBlendOperation)); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaBlendOperation_), alphaBlendOperation); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setBlendingState(MTL4::BlendState blendingState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBlendingState_), blendingState); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDestinationAlphaBlendFactor_), destinationAlphaBlendFactor); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDestinationRGBBlendFactor_), destinationRGBBlendFactor); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRgbBlendOperation_), rgbBlendOperation); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSourceAlphaBlendFactor_), sourceAlphaBlendFactor); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSourceRGBBlendFactor_), sourceRGBBlendFactor); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptor::setWriteMask(MTL::ColorWriteMask writeMask) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask); +} + +_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::sourceAlphaBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sourceAlphaBlendFactor)); +} + +_MTL_INLINE MTL::BlendFactor MTL4::RenderPipelineColorAttachmentDescriptor::sourceRGBBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sourceRGBBlendFactor)); +} + +_MTL_INLINE MTL::ColorWriteMask MTL4::RenderPipelineColorAttachmentDescriptor::writeMask() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(writeMask)); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineColorAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPipelineColorAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineColorAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptor* MTL4::RenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptorArray::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::RenderPipelineColorAttachmentDescriptorArray::setObject(const MTL4::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL4::RenderPipelineBinaryFunctionsDescriptor* MTL4::RenderPipelineBinaryFunctionsDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPipelineBinaryFunctionsDescriptor)); +} + +_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::fragmentAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentAdditionalBinaryFunctions)); +} + +_MTL_INLINE MTL4::RenderPipelineBinaryFunctionsDescriptor* MTL4::RenderPipelineBinaryFunctionsDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::meshAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshAdditionalBinaryFunctions)); +} + +_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::objectAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAdditionalBinaryFunctions)); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentAdditionalBinaryFunctions_), fragmentAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setMeshAdditionalBinaryFunctions(const NS::Array* meshAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshAdditionalBinaryFunctions_), meshAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setObjectAdditionalBinaryFunctions(const NS::Array* objectAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectAdditionalBinaryFunctions_), objectAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileAdditionalBinaryFunctions_), tileAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL4::RenderPipelineBinaryFunctionsDescriptor::setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexAdditionalBinaryFunctions_), vertexAdditionalBinaryFunctions); +} + +_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::tileAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileAdditionalBinaryFunctions)); +} + +_MTL_INLINE NS::Array* MTL4::RenderPipelineBinaryFunctionsDescriptor::vertexAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexAdditionalBinaryFunctions)); +} + +_MTL_INLINE MTL4::RenderPipelineDescriptor* MTL4::RenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4RenderPipelineDescriptor)); +} + +_MTL_INLINE MTL4::AlphaToCoverageState MTL4::RenderPipelineDescriptor::alphaToCoverageState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaToCoverageState)); +} + +_MTL_INLINE MTL4::AlphaToOneState MTL4::RenderPipelineDescriptor::alphaToOneState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaToOneState)); +} + +_MTL_INLINE MTL4::LogicalToPhysicalColorAttachmentMappingState MTL4::RenderPipelineDescriptor::colorAttachmentMappingState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachmentMappingState)); +} + +_MTL_INLINE MTL4::RenderPipelineColorAttachmentDescriptorArray* MTL4::RenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::RenderPipelineDescriptor::fragmentFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentFunctionDescriptor)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::RenderPipelineDescriptor::fragmentStaticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentStaticLinkingDescriptor)); +} + +_MTL_INLINE MTL4::RenderPipelineDescriptor* MTL4::RenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::PrimitiveTopologyClass MTL4::RenderPipelineDescriptor::inputPrimitiveTopology() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inputPrimitiveTopology)); +} + +_MTL_INLINE bool MTL4::RenderPipelineDescriptor::isRasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPipelineDescriptor::maxVertexAmplificationCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount)); +} + +_MTL_INLINE NS::UInteger MTL4::RenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE bool MTL4::RenderPipelineDescriptor::rasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setAlphaToCoverageState(MTL4::AlphaToCoverageState alphaToCoverageState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToCoverageState_), alphaToCoverageState); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setAlphaToOneState(MTL4::AlphaToOneState alphaToOneState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToOneState_), alphaToOneState); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setColorAttachmentMappingState(MTL4::LogicalToPhysicalColorAttachmentMappingState colorAttachmentMappingState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorAttachmentMappingState_), colorAttachmentMappingState); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setFragmentFunctionDescriptor(const MTL4::FunctionDescriptor* fragmentFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentFunctionDescriptor_), fragmentFunctionDescriptor); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setFragmentStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* fragmentStaticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentStaticLinkingDescriptor_), fragmentStaticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInputPrimitiveTopology_), inputPrimitiveTopology); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportFragmentBinaryLinking(bool supportFragmentBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportFragmentBinaryLinking_), supportFragmentBinaryLinking); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportIndirectCommandBuffers(MTL4::IndirectCommandBufferSupportState supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setSupportVertexBinaryLinking(bool supportVertexBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportVertexBinaryLinking_), supportVertexBinaryLinking); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexDescriptor_), vertexDescriptor); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexFunctionDescriptor(const MTL4::FunctionDescriptor* vertexFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFunctionDescriptor_), vertexFunctionDescriptor); +} + +_MTL_INLINE void MTL4::RenderPipelineDescriptor::setVertexStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* vertexStaticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexStaticLinkingDescriptor_), vertexStaticLinkingDescriptor); +} + +_MTL_INLINE bool MTL4::RenderPipelineDescriptor::supportFragmentBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportFragmentBinaryLinking)); +} + +_MTL_INLINE MTL4::IndirectCommandBufferSupportState MTL4::RenderPipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE bool MTL4::RenderPipelineDescriptor::supportVertexBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportVertexBinaryLinking)); +} + +_MTL_INLINE MTL::VertexDescriptor* MTL4::RenderPipelineDescriptor::vertexDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexDescriptor)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::RenderPipelineDescriptor::vertexFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFunctionDescriptor)); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::RenderPipelineDescriptor::vertexStaticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexStaticLinkingDescriptor)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4SpecializedFunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4SpecializedFunctionDescriptor.hpp new file mode 100644 index 0000000000..57c0094dda --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4SpecializedFunctionDescriptor.hpp @@ -0,0 +1,100 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4SpecializedFunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4FunctionDescriptor.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; +class SpecializedFunctionDescriptor; +} + +namespace MTL +{ +class FunctionConstantValues; +} + +namespace MTL4 +{ +class SpecializedFunctionDescriptor : public NS::Copying +{ +public: + static SpecializedFunctionDescriptor* alloc(); + + MTL::FunctionConstantValues* constantValues() const; + + FunctionDescriptor* functionDescriptor() const; + + SpecializedFunctionDescriptor* init(); + + void setConstantValues(const MTL::FunctionConstantValues* constantValues); + + void setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor); + + void setSpecializedName(const NS::String* specializedName); + NS::String* specializedName() const; +}; + +} +_MTL_INLINE MTL4::SpecializedFunctionDescriptor* MTL4::SpecializedFunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4SpecializedFunctionDescriptor)); +} + +_MTL_INLINE MTL::FunctionConstantValues* MTL4::SpecializedFunctionDescriptor::constantValues() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(constantValues)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::SpecializedFunctionDescriptor::functionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionDescriptor)); +} + +_MTL_INLINE MTL4::SpecializedFunctionDescriptor* MTL4::SpecializedFunctionDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setConstantValues(const MTL::FunctionConstantValues* constantValues) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantValues_), constantValues); +} + +_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setFunctionDescriptor(const MTL4::FunctionDescriptor* functionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionDescriptor_), functionDescriptor); +} + +_MTL_INLINE void MTL4::SpecializedFunctionDescriptor::setSpecializedName(const NS::String* specializedName) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSpecializedName_), specializedName); +} + +_MTL_INLINE NS::String* MTL4::SpecializedFunctionDescriptor::specializedName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(specializedName)); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4StitchedFunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTL4StitchedFunctionDescriptor.hpp new file mode 100644 index 0000000000..ca8ea5cfd9 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4StitchedFunctionDescriptor.hpp @@ -0,0 +1,86 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4StitchedFunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4FunctionDescriptor.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL4 +{ +class StitchedFunctionDescriptor; +} + +namespace MTL +{ +class FunctionStitchingGraph; +} + +namespace MTL4 +{ +class StitchedFunctionDescriptor : public NS::Copying +{ +public: + static StitchedFunctionDescriptor* alloc(); + + NS::Array* functionDescriptors() const; + + MTL::FunctionStitchingGraph* functionGraph() const; + + StitchedFunctionDescriptor* init(); + + void setFunctionDescriptors(const NS::Array* functionDescriptors); + + void setFunctionGraph(const MTL::FunctionStitchingGraph* functionGraph); +}; + +} +_MTL_INLINE MTL4::StitchedFunctionDescriptor* MTL4::StitchedFunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4StitchedFunctionDescriptor)); +} + +_MTL_INLINE NS::Array* MTL4::StitchedFunctionDescriptor::functionDescriptors() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionDescriptors)); +} + +_MTL_INLINE MTL::FunctionStitchingGraph* MTL4::StitchedFunctionDescriptor::functionGraph() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionGraph)); +} + +_MTL_INLINE MTL4::StitchedFunctionDescriptor* MTL4::StitchedFunctionDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL4::StitchedFunctionDescriptor::setFunctionDescriptors(const NS::Array* functionDescriptors) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionDescriptors_), functionDescriptors); +} + +_MTL_INLINE void MTL4::StitchedFunctionDescriptor::setFunctionGraph(const MTL::FunctionStitchingGraph* functionGraph) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionGraph_), functionGraph); +} diff --git a/thirdparty/metal-cpp/Metal/MTL4TileRenderPipeline.hpp b/thirdparty/metal-cpp/Metal/MTL4TileRenderPipeline.hpp new file mode 100644 index 0000000000..dc74f484b4 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTL4TileRenderPipeline.hpp @@ -0,0 +1,173 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTL4TileRenderPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4PipelineState.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL4 +{ +class FunctionDescriptor; +class StaticLinkingDescriptor; +class TileRenderPipelineDescriptor; +} + +namespace MTL +{ +class TileRenderPipelineColorAttachmentDescriptorArray; +} + +namespace MTL4 +{ +class TileRenderPipelineDescriptor : public NS::Copying +{ +public: + static TileRenderPipelineDescriptor* alloc(); + + MTL::TileRenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + TileRenderPipelineDescriptor* init(); + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + NS::UInteger rasterSampleCount() const; + + MTL::Size requiredThreadsPerThreadgroup() const; + + void reset(); + + void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup); + + void setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor); + + void setSupportBinaryLinking(bool supportBinaryLinking); + + void setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize); + + void setTileFunctionDescriptor(const MTL4::FunctionDescriptor* tileFunctionDescriptor); + + StaticLinkingDescriptor* staticLinkingDescriptor() const; + + bool supportBinaryLinking() const; + + bool threadgroupSizeMatchesTileSize() const; + + FunctionDescriptor* tileFunctionDescriptor() const; +}; + +} +_MTL_INLINE MTL4::TileRenderPipelineDescriptor* MTL4::TileRenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTL4TileRenderPipelineDescriptor)); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL4::TileRenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL4::TileRenderPipelineDescriptor* MTL4::TileRenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL4::TileRenderPipelineDescriptor::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL4::TileRenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE MTL::Size MTL4::TileRenderPipelineDescriptor::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setStaticLinkingDescriptor(const MTL4::StaticLinkingDescriptor* staticLinkingDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStaticLinkingDescriptor_), staticLinkingDescriptor); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setSupportBinaryLinking(bool supportBinaryLinking) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportBinaryLinking_), supportBinaryLinking); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupSizeMatchesTileSize_), threadgroupSizeMatchesTileSize); +} + +_MTL_INLINE void MTL4::TileRenderPipelineDescriptor::setTileFunctionDescriptor(const MTL4::FunctionDescriptor* tileFunctionDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileFunctionDescriptor_), tileFunctionDescriptor); +} + +_MTL_INLINE MTL4::StaticLinkingDescriptor* MTL4::TileRenderPipelineDescriptor::staticLinkingDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(staticLinkingDescriptor)); +} + +_MTL_INLINE bool MTL4::TileRenderPipelineDescriptor::supportBinaryLinking() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportBinaryLinking)); +} + +_MTL_INLINE bool MTL4::TileRenderPipelineDescriptor::threadgroupSizeMatchesTileSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize)); +} + +_MTL_INLINE MTL4::FunctionDescriptor* MTL4::TileRenderPipelineDescriptor::tileFunctionDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileFunctionDescriptor)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLAccelerationStructure.hpp b/thirdparty/metal-cpp/Metal/MTLAccelerationStructure.hpp new file mode 100644 index 0000000000..d3457c3929 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLAccelerationStructure.hpp @@ -0,0 +1,1887 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLAccelerationStructure.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAccelerationStructureTypes.hpp" +#include "MTLArgument.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLStageInputOutputDescriptor.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class AccelerationStructureBoundingBoxGeometryDescriptor; +class AccelerationStructureCurveGeometryDescriptor; +class AccelerationStructureDescriptor; +class AccelerationStructureGeometryDescriptor; +class AccelerationStructureMotionBoundingBoxGeometryDescriptor; +class AccelerationStructureMotionCurveGeometryDescriptor; +class AccelerationStructureMotionTriangleGeometryDescriptor; +class AccelerationStructureTriangleGeometryDescriptor; +class Buffer; +class IndirectInstanceAccelerationStructureDescriptor; +class InstanceAccelerationStructureDescriptor; +class MotionKeyframeData; +class PrimitiveAccelerationStructureDescriptor; +} + +namespace MTL +{ +_MTL_ENUM(NS::Integer, MatrixLayout) { + MatrixLayoutColumnMajor = 0, + MatrixLayoutRowMajor = 1, +}; + +_MTL_ENUM(uint32_t, MotionBorderMode) { + MotionBorderModeClamp = 0, + MotionBorderModeVanish = 1, +}; + +_MTL_ENUM(NS::Integer, CurveType) { + CurveTypeRound = 0, + CurveTypeFlat = 1, +}; + +_MTL_ENUM(NS::Integer, CurveBasis) { + CurveBasisBSpline = 0, + CurveBasisCatmullRom = 1, + CurveBasisLinear = 2, + CurveBasisBezier = 3, +}; + +_MTL_ENUM(NS::Integer, CurveEndCaps) { + CurveEndCapsNone = 0, + CurveEndCapsDisk = 1, + CurveEndCapsSphere = 2, +}; + +_MTL_ENUM(NS::UInteger, AccelerationStructureInstanceDescriptorType) { + AccelerationStructureInstanceDescriptorTypeDefault = 0, + AccelerationStructureInstanceDescriptorTypeUserID = 1, + AccelerationStructureInstanceDescriptorTypeMotion = 2, + AccelerationStructureInstanceDescriptorTypeIndirect = 3, + AccelerationStructureInstanceDescriptorTypeIndirectMotion = 4, +}; + +_MTL_ENUM(NS::Integer, TransformType) { + TransformTypePackedFloat4x3 = 0, + TransformTypeComponent = 1, +}; + +_MTL_OPTIONS(NS::UInteger, AccelerationStructureRefitOptions) { + AccelerationStructureRefitOptionVertexData = 1, + AccelerationStructureRefitOptionPerPrimitiveData = 1 << 1, +}; + +_MTL_OPTIONS(NS::UInteger, AccelerationStructureUsage) { + AccelerationStructureUsageNone = 0, + AccelerationStructureUsageRefit = 1, + AccelerationStructureUsagePreferFastBuild = 1 << 1, + AccelerationStructureUsageExtendedLimits = 1 << 2, + AccelerationStructureUsagePreferFastIntersection = 1 << 4, + AccelerationStructureUsageMinimizeMemory = 1 << 5, +}; + +_MTL_OPTIONS(uint32_t, AccelerationStructureInstanceOptions) { + AccelerationStructureInstanceOptionNone = 0, + AccelerationStructureInstanceOptionDisableTriangleCulling = 1, + AccelerationStructureInstanceOptionTriangleFrontFacingWindingCounterClockwise = 1 << 1, + AccelerationStructureInstanceOptionOpaque = 1 << 2, + AccelerationStructureInstanceOptionNonOpaque = 1 << 3, +}; + +struct AccelerationStructureInstanceDescriptor +{ + MTL::PackedFloat4x3 transformationMatrix; + MTL::AccelerationStructureInstanceOptions options; + uint32_t mask; + uint32_t intersectionFunctionTableOffset; + uint32_t accelerationStructureIndex; +} _MTL_PACKED; + +struct AccelerationStructureUserIDInstanceDescriptor +{ + MTL::PackedFloat4x3 transformationMatrix; + MTL::AccelerationStructureInstanceOptions options; + uint32_t mask; + uint32_t intersectionFunctionTableOffset; + uint32_t accelerationStructureIndex; + uint32_t userID; +} _MTL_PACKED; + +struct AccelerationStructureMotionInstanceDescriptor +{ + MTL::AccelerationStructureInstanceOptions options; + uint32_t mask; + uint32_t intersectionFunctionTableOffset; + uint32_t accelerationStructureIndex; + uint32_t userID; + uint32_t motionTransformsStartIndex; + uint32_t motionTransformsCount; + MTL::MotionBorderMode motionStartBorderMode; + MTL::MotionBorderMode motionEndBorderMode; + float motionStartTime; + float motionEndTime; +} _MTL_PACKED; + +struct IndirectAccelerationStructureInstanceDescriptor +{ + MTL::PackedFloat4x3 transformationMatrix; + MTL::AccelerationStructureInstanceOptions options; + uint32_t mask; + uint32_t intersectionFunctionTableOffset; + uint32_t userID; + MTL::ResourceID accelerationStructureID; +} _MTL_PACKED; + +struct IndirectAccelerationStructureMotionInstanceDescriptor +{ + MTL::AccelerationStructureInstanceOptions options; + uint32_t mask; + uint32_t intersectionFunctionTableOffset; + uint32_t userID; + MTL::ResourceID accelerationStructureID; + uint32_t motionTransformsStartIndex; + uint32_t motionTransformsCount; + MTL::MotionBorderMode motionStartBorderMode; + MTL::MotionBorderMode motionEndBorderMode; + float motionStartTime; + float motionEndTime; +} _MTL_PACKED; + +class AccelerationStructureDescriptor : public NS::Copying +{ +public: + static AccelerationStructureDescriptor* alloc(); + + AccelerationStructureDescriptor* init(); + + void setUsage(MTL::AccelerationStructureUsage usage); + AccelerationStructureUsage usage() const; +}; +class AccelerationStructureGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureGeometryDescriptor* alloc(); + + bool allowDuplicateIntersectionFunctionInvocation() const; + + AccelerationStructureGeometryDescriptor* init(); + + NS::UInteger intersectionFunctionTableOffset() const; + + NS::String* label() const; + + bool opaque() const; + + Buffer* primitiveDataBuffer() const; + NS::UInteger primitiveDataBufferOffset() const; + + NS::UInteger primitiveDataElementSize() const; + + NS::UInteger primitiveDataStride() const; + + void setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation); + + void setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset); + + void setLabel(const NS::String* label); + + void setOpaque(bool opaque); + + void setPrimitiveDataBuffer(const MTL::Buffer* primitiveDataBuffer); + void setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset); + + void setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize); + + void setPrimitiveDataStride(NS::UInteger primitiveDataStride); +}; +class PrimitiveAccelerationStructureDescriptor : public NS::Copying +{ +public: + static PrimitiveAccelerationStructureDescriptor* alloc(); + + static PrimitiveAccelerationStructureDescriptor* descriptor(); + NS::Array* geometryDescriptors() const; + + PrimitiveAccelerationStructureDescriptor* init(); + + MotionBorderMode motionEndBorderMode() const; + + float motionEndTime() const; + + NS::UInteger motionKeyframeCount() const; + + MotionBorderMode motionStartBorderMode() const; + + float motionStartTime() const; + + void setGeometryDescriptors(const NS::Array* geometryDescriptors); + + void setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode); + + void setMotionEndTime(float motionEndTime); + + void setMotionKeyframeCount(NS::UInteger motionKeyframeCount); + + void setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode); + + void setMotionStartTime(float motionStartTime); +}; +class AccelerationStructureTriangleGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureTriangleGeometryDescriptor* alloc(); + + static AccelerationStructureTriangleGeometryDescriptor* descriptor(); + + Buffer* indexBuffer() const; + NS::UInteger indexBufferOffset() const; + + IndexType indexType() const; + + AccelerationStructureTriangleGeometryDescriptor* init(); + + void setIndexBuffer(const MTL::Buffer* indexBuffer); + void setIndexBufferOffset(NS::UInteger indexBufferOffset); + + void setIndexType(MTL::IndexType indexType); + + void setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer); + void setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset); + + void setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout); + + void setTriangleCount(NS::UInteger triangleCount); + + void setVertexBuffer(const MTL::Buffer* vertexBuffer); + void setVertexBufferOffset(NS::UInteger vertexBufferOffset); + + void setVertexFormat(MTL::AttributeFormat vertexFormat); + + void setVertexStride(NS::UInteger vertexStride); + + Buffer* transformationMatrixBuffer() const; + NS::UInteger transformationMatrixBufferOffset() const; + + MatrixLayout transformationMatrixLayout() const; + + NS::UInteger triangleCount() const; + + Buffer* vertexBuffer() const; + NS::UInteger vertexBufferOffset() const; + + AttributeFormat vertexFormat() const; + + NS::UInteger vertexStride() const; +}; +class AccelerationStructureBoundingBoxGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureBoundingBoxGeometryDescriptor* alloc(); + + Buffer* boundingBoxBuffer() const; + NS::UInteger boundingBoxBufferOffset() const; + + NS::UInteger boundingBoxCount() const; + + NS::UInteger boundingBoxStride() const; + + static AccelerationStructureBoundingBoxGeometryDescriptor* descriptor(); + + AccelerationStructureBoundingBoxGeometryDescriptor* init(); + + void setBoundingBoxBuffer(const MTL::Buffer* boundingBoxBuffer); + void setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset); + + void setBoundingBoxCount(NS::UInteger boundingBoxCount); + + void setBoundingBoxStride(NS::UInteger boundingBoxStride); +}; +class MotionKeyframeData : public NS::Referencing +{ +public: + static MotionKeyframeData* alloc(); + + Buffer* buffer() const; + + static MotionKeyframeData* data(); + + MotionKeyframeData* init(); + + NS::UInteger offset() const; + + void setBuffer(const MTL::Buffer* buffer); + + void setOffset(NS::UInteger offset); +}; +class AccelerationStructureMotionTriangleGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionTriangleGeometryDescriptor* alloc(); + + static AccelerationStructureMotionTriangleGeometryDescriptor* descriptor(); + + Buffer* indexBuffer() const; + NS::UInteger indexBufferOffset() const; + + IndexType indexType() const; + + AccelerationStructureMotionTriangleGeometryDescriptor* init(); + + void setIndexBuffer(const MTL::Buffer* indexBuffer); + void setIndexBufferOffset(NS::UInteger indexBufferOffset); + + void setIndexType(MTL::IndexType indexType); + + void setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer); + void setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset); + + void setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout); + + void setTriangleCount(NS::UInteger triangleCount); + + void setVertexBuffers(const NS::Array* vertexBuffers); + + void setVertexFormat(MTL::AttributeFormat vertexFormat); + + void setVertexStride(NS::UInteger vertexStride); + + Buffer* transformationMatrixBuffer() const; + NS::UInteger transformationMatrixBufferOffset() const; + + MatrixLayout transformationMatrixLayout() const; + + NS::UInteger triangleCount() const; + + NS::Array* vertexBuffers() const; + + AttributeFormat vertexFormat() const; + + NS::UInteger vertexStride() const; +}; +class AccelerationStructureMotionBoundingBoxGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionBoundingBoxGeometryDescriptor* alloc(); + + NS::Array* boundingBoxBuffers() const; + + NS::UInteger boundingBoxCount() const; + + NS::UInteger boundingBoxStride() const; + + static AccelerationStructureMotionBoundingBoxGeometryDescriptor* descriptor(); + + AccelerationStructureMotionBoundingBoxGeometryDescriptor* init(); + + void setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers); + + void setBoundingBoxCount(NS::UInteger boundingBoxCount); + + void setBoundingBoxStride(NS::UInteger boundingBoxStride); +}; +class AccelerationStructureCurveGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureCurveGeometryDescriptor* alloc(); + + Buffer* controlPointBuffer() const; + NS::UInteger controlPointBufferOffset() const; + + NS::UInteger controlPointCount() const; + + AttributeFormat controlPointFormat() const; + + NS::UInteger controlPointStride() const; + + CurveBasis curveBasis() const; + + CurveEndCaps curveEndCaps() const; + + CurveType curveType() const; + + static AccelerationStructureCurveGeometryDescriptor* descriptor(); + + Buffer* indexBuffer() const; + NS::UInteger indexBufferOffset() const; + + IndexType indexType() const; + + AccelerationStructureCurveGeometryDescriptor* init(); + + Buffer* radiusBuffer() const; + NS::UInteger radiusBufferOffset() const; + + AttributeFormat radiusFormat() const; + + NS::UInteger radiusStride() const; + + NS::UInteger segmentControlPointCount() const; + + NS::UInteger segmentCount() const; + + void setControlPointBuffer(const MTL::Buffer* controlPointBuffer); + void setControlPointBufferOffset(NS::UInteger controlPointBufferOffset); + + void setControlPointCount(NS::UInteger controlPointCount); + + void setControlPointFormat(MTL::AttributeFormat controlPointFormat); + + void setControlPointStride(NS::UInteger controlPointStride); + + void setCurveBasis(MTL::CurveBasis curveBasis); + + void setCurveEndCaps(MTL::CurveEndCaps curveEndCaps); + + void setCurveType(MTL::CurveType curveType); + + void setIndexBuffer(const MTL::Buffer* indexBuffer); + void setIndexBufferOffset(NS::UInteger indexBufferOffset); + + void setIndexType(MTL::IndexType indexType); + + void setRadiusBuffer(const MTL::Buffer* radiusBuffer); + void setRadiusBufferOffset(NS::UInteger radiusBufferOffset); + + void setRadiusFormat(MTL::AttributeFormat radiusFormat); + + void setRadiusStride(NS::UInteger radiusStride); + + void setSegmentControlPointCount(NS::UInteger segmentControlPointCount); + + void setSegmentCount(NS::UInteger segmentCount); +}; +class AccelerationStructureMotionCurveGeometryDescriptor : public NS::Copying +{ +public: + static AccelerationStructureMotionCurveGeometryDescriptor* alloc(); + + NS::Array* controlPointBuffers() const; + + NS::UInteger controlPointCount() const; + + AttributeFormat controlPointFormat() const; + + NS::UInteger controlPointStride() const; + + CurveBasis curveBasis() const; + + CurveEndCaps curveEndCaps() const; + + CurveType curveType() const; + + static AccelerationStructureMotionCurveGeometryDescriptor* descriptor(); + + Buffer* indexBuffer() const; + NS::UInteger indexBufferOffset() const; + + IndexType indexType() const; + + AccelerationStructureMotionCurveGeometryDescriptor* init(); + + NS::Array* radiusBuffers() const; + + AttributeFormat radiusFormat() const; + + NS::UInteger radiusStride() const; + + NS::UInteger segmentControlPointCount() const; + + NS::UInteger segmentCount() const; + + void setControlPointBuffers(const NS::Array* controlPointBuffers); + + void setControlPointCount(NS::UInteger controlPointCount); + + void setControlPointFormat(MTL::AttributeFormat controlPointFormat); + + void setControlPointStride(NS::UInteger controlPointStride); + + void setCurveBasis(MTL::CurveBasis curveBasis); + + void setCurveEndCaps(MTL::CurveEndCaps curveEndCaps); + + void setCurveType(MTL::CurveType curveType); + + void setIndexBuffer(const MTL::Buffer* indexBuffer); + void setIndexBufferOffset(NS::UInteger indexBufferOffset); + + void setIndexType(MTL::IndexType indexType); + + void setRadiusBuffers(const NS::Array* radiusBuffers); + + void setRadiusFormat(MTL::AttributeFormat radiusFormat); + + void setRadiusStride(NS::UInteger radiusStride); + + void setSegmentControlPointCount(NS::UInteger segmentControlPointCount); + + void setSegmentCount(NS::UInteger segmentCount); +}; +class InstanceAccelerationStructureDescriptor : public NS::Copying +{ +public: + static InstanceAccelerationStructureDescriptor* alloc(); + + static InstanceAccelerationStructureDescriptor* descriptor(); + + InstanceAccelerationStructureDescriptor* init(); + + NS::UInteger instanceCount() const; + + Buffer* instanceDescriptorBuffer() const; + NS::UInteger instanceDescriptorBufferOffset() const; + + NS::UInteger instanceDescriptorStride() const; + + AccelerationStructureInstanceDescriptorType instanceDescriptorType() const; + + MatrixLayout instanceTransformationMatrixLayout() const; + + NS::Array* instancedAccelerationStructures() const; + + Buffer* motionTransformBuffer() const; + NS::UInteger motionTransformBufferOffset() const; + + NS::UInteger motionTransformCount() const; + + NS::UInteger motionTransformStride() const; + + TransformType motionTransformType() const; + + void setInstanceCount(NS::UInteger instanceCount); + + void setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer); + void setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset); + + void setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride); + + void setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType); + + void setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout); + + void setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures); + + void setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer); + void setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset); + + void setMotionTransformCount(NS::UInteger motionTransformCount); + + void setMotionTransformStride(NS::UInteger motionTransformStride); + + void setMotionTransformType(MTL::TransformType motionTransformType); +}; +class IndirectInstanceAccelerationStructureDescriptor : public NS::Copying +{ +public: + static IndirectInstanceAccelerationStructureDescriptor* alloc(); + + static IndirectInstanceAccelerationStructureDescriptor* descriptor(); + + IndirectInstanceAccelerationStructureDescriptor* init(); + + Buffer* instanceCountBuffer() const; + NS::UInteger instanceCountBufferOffset() const; + + Buffer* instanceDescriptorBuffer() const; + NS::UInteger instanceDescriptorBufferOffset() const; + + NS::UInteger instanceDescriptorStride() const; + + AccelerationStructureInstanceDescriptorType instanceDescriptorType() const; + + MatrixLayout instanceTransformationMatrixLayout() const; + + NS::UInteger maxInstanceCount() const; + + NS::UInteger maxMotionTransformCount() const; + + Buffer* motionTransformBuffer() const; + NS::UInteger motionTransformBufferOffset() const; + + Buffer* motionTransformCountBuffer() const; + NS::UInteger motionTransformCountBufferOffset() const; + + NS::UInteger motionTransformStride() const; + + TransformType motionTransformType() const; + + void setInstanceCountBuffer(const MTL::Buffer* instanceCountBuffer); + void setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset); + + void setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer); + void setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset); + + void setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride); + + void setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType); + + void setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout); + + void setMaxInstanceCount(NS::UInteger maxInstanceCount); + + void setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount); + + void setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer); + void setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset); + + void setMotionTransformCountBuffer(const MTL::Buffer* motionTransformCountBuffer); + void setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset); + + void setMotionTransformStride(NS::UInteger motionTransformStride); + + void setMotionTransformType(MTL::TransformType motionTransformType); +}; +class AccelerationStructure : public NS::Referencing +{ +public: + ResourceID gpuResourceID() const; + + NS::UInteger size() const; +}; + +} + +_MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::AccelerationStructureDescriptor::setUsage(MTL::AccelerationStructureUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setUsage_), usage); +} + +_MTL_INLINE MTL::AccelerationStructureUsage MTL::AccelerationStructureDescriptor::usage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usage)); +} + +_MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureGeometryDescriptor)); +} + +_MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::allowDuplicateIntersectionFunctionInvocation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allowDuplicateIntersectionFunctionInvocation)); +} + +_MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::intersectionFunctionTableOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(intersectionFunctionTableOffset)); +} + +_MTL_INLINE NS::String* MTL::AccelerationStructureGeometryDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::opaque() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(opaque)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureGeometryDescriptor::primitiveDataBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataElementSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataElementSize)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(primitiveDataStride)); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAllowDuplicateIntersectionFunctionInvocation_), allowDuplicateIntersectionFunctionInvocation); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTableOffset_), intersectionFunctionTableOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setOpaque(bool opaque) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaque_), opaque); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBuffer(const MTL::Buffer* primitiveDataBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataBuffer_), primitiveDataBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataBufferOffset_), primitiveDataBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataElementSize_), primitiveDataElementSize); +} + +_MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataStride(NS::UInteger primitiveDataStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrimitiveDataStride_), primitiveDataStride); +} + +_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE NS::Array* MTL::PrimitiveAccelerationStructureDescriptor::geometryDescriptors() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(geometryDescriptors)); +} + +_MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionEndBorderMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionEndBorderMode)); +} + +_MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionEndTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionEndTime)); +} + +_MTL_INLINE NS::UInteger MTL::PrimitiveAccelerationStructureDescriptor::motionKeyframeCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionKeyframeCount)); +} + +_MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionStartBorderMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionStartBorderMode)); +} + +_MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionStartTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionStartTime)); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setGeometryDescriptors(const NS::Array* geometryDescriptors) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setGeometryDescriptors_), geometryDescriptors); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionEndBorderMode_), motionEndBorderMode); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndTime(float motionEndTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionEndTime_), motionEndTime); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionKeyframeCount(NS::UInteger motionKeyframeCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionKeyframeCount_), motionKeyframeCount); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionStartBorderMode_), motionStartBorderMode); +} + +_MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartTime(float motionStartTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionStartTime_), motionStartTime); +} + +_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor)); +} + +_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::indexBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBufferOffset)); +} + +_MTL_INLINE MTL::IndexType MTL::AccelerationStructureTriangleGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBuffer(const MTL::Buffer* vertexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_), vertexBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBufferOffset(NS::UInteger vertexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_), vertexBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset)); +} + +_MTL_INLINE MTL::MatrixLayout MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::triangleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(triangleCount)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBufferOffset)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureTriangleGeometryDescriptor::vertexFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexStride)); +} + +_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxCount)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxStride)); +} + +_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBuffer(const MTL::Buffer* boundingBoxBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffer_), boundingBoxBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxBufferOffset_), boundingBoxBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount); +} + +_MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride); +} + +_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLMotionKeyframeData)); +} + +_MTL_INLINE MTL::Buffer* MTL::MotionKeyframeData::buffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(buffer)); +} + +_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::data() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLMotionKeyframeData), _MTL_PRIVATE_SEL(data)); +} + +_MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::MotionKeyframeData::offset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(offset)); +} + +_MTL_INLINE void MTL::MotionKeyframeData::setBuffer(const MTL::Buffer* buffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffer_), buffer); +} + +_MTL_INLINE void MTL::MotionKeyframeData::setOffset(NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOffset_), offset); +} + +_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBufferOffset)); +} + +_MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexBuffers(const NS::Array* vertexBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffers_), vertexBuffers); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset)); +} + +_MTL_INLINE MTL::MatrixLayout MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(transformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::triangleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(triangleCount)); +} + +_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBuffers)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexStride)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxBuffers)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxCount)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(boundingBoxStride)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffers_), boundingBoxBuffers); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride); +} + +_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointCount)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::controlPointFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointStride)); +} + +_MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureCurveGeometryDescriptor::curveBasis() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveBasis)); +} + +_MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureCurveGeometryDescriptor::curveEndCaps() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveEndCaps)); +} + +_MTL_INLINE MTL::CurveType MTL::AccelerationStructureCurveGeometryDescriptor::curveType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveType)); +} + +_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::indexBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBufferOffset)); +} + +_MTL_INLINE MTL::IndexType MTL::AccelerationStructureCurveGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::radiusBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusBufferOffset)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::radiusFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusStride)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentControlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentControlPointCount)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentCount)); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBuffer(const MTL::Buffer* controlPointBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointBuffer_), controlPointBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBufferOffset(NS::UInteger controlPointBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointBufferOffset_), controlPointBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveType_), curveType); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBuffer(const MTL::Buffer* radiusBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusBuffer_), radiusBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBufferOffset(NS::UInteger radiusBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusBufferOffset_), radiusBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount); +} + +_MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount); +} + +_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointBuffers)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointCount)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlPointStride)); +} + +_MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveBasis() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveBasis)); +} + +_MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveEndCaps() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveEndCaps)); +} + +_MTL_INLINE MTL::CurveType MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(curveType)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBufferOffset)); +} + +_MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusBuffers)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusFormat)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(radiusStride)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentControlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentControlPointCount)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(segmentCount)); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointBuffers(const NS::Array* controlPointBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointBuffers_), controlPointBuffers); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCurveType_), curveType); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusBuffers(const NS::Array* radiusBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusBuffers_), radiusBuffers); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount); +} + +_MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount); +} + +_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceCount)); +} + +_MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorStride)); +} + +_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorType)); +} + +_MTL_INLINE MTL::MatrixLayout MTL::InstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout)); +} + +_MTL_INLINE NS::Array* MTL::InstanceAccelerationStructureDescriptor::instancedAccelerationStructures() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instancedAccelerationStructures)); +} + +_MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::motionTransformBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformCount)); +} + +_MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformStride)); +} + +_MTL_INLINE MTL::TransformType MTL::InstanceAccelerationStructureDescriptor::motionTransformType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformType)); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceCount(NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceCount_), instanceCount); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstancedAccelerationStructures_), instancedAccelerationStructures); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformCount(NS::UInteger motionTransformCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformCount_), motionTransformCount); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride); +} + +_MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType); +} + +_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor)); +} + +_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::descriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor)); +} + +_MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceCountBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceCountBufferOffset)); +} + +_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorStride)); +} + +_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceDescriptorType)); +} + +_MTL_INLINE MTL::MatrixLayout MTL::IndirectInstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxInstanceCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxInstanceCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxMotionTransformCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxMotionTransformCount)); +} + +_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset)); +} + +_MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformCountBuffer)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformCountBufferOffset)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformStride)); +} + +_MTL_INLINE MTL::TransformType MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(motionTransformType)); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBuffer(const MTL::Buffer* instanceCountBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceCountBuffer_), instanceCountBuffer); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceCountBufferOffset_), instanceCountBufferOffset); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxInstanceCount(NS::UInteger maxInstanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxInstanceCount_), maxInstanceCount); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxMotionTransformCount_), maxMotionTransformCount); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBuffer(const MTL::Buffer* motionTransformCountBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformCountBuffer_), motionTransformCountBuffer); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformCountBufferOffset_), motionTransformCountBufferOffset); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride); +} + +_MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType); +} + +_MTL_INLINE MTL::ResourceID MTL::AccelerationStructure::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructure::size() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(size)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp new file mode 100644 index 0000000000..5f82344ae4 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLAccelerationStructureCommandEncoder.hpp @@ -0,0 +1,260 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLAccelerationStructureCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAccelerationStructure.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDataType.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class AccelerationStructure; +class AccelerationStructureDescriptor; +class AccelerationStructurePassDescriptor; +class AccelerationStructurePassSampleBufferAttachmentDescriptor; +class AccelerationStructurePassSampleBufferAttachmentDescriptorArray; +class Buffer; +class CounterSampleBuffer; +class Fence; +class Heap; +class Resource; + +class AccelerationStructureCommandEncoder : public NS::Referencing +{ +public: + void buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset); + + void copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure); + + void copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure); + + void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset); + void refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options); + + void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier); + + void updateFence(const MTL::Fence* fence); + + void useHeap(const MTL::Heap* heap); + void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count); + + void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage); + void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage); + + void waitForFence(const MTL::Fence* fence); + + void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset); + void writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType); +}; +class AccelerationStructurePassSampleBufferAttachmentDescriptor : public NS::Copying +{ +public: + static AccelerationStructurePassSampleBufferAttachmentDescriptor* alloc(); + + NS::UInteger endOfEncoderSampleIndex() const; + + AccelerationStructurePassSampleBufferAttachmentDescriptor* init(); + + CounterSampleBuffer* sampleBuffer() const; + + void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex); + + void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer); + + void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex); + NS::UInteger startOfEncoderSampleIndex() const; +}; +class AccelerationStructurePassSampleBufferAttachmentDescriptorArray : public NS::Referencing +{ +public: + static AccelerationStructurePassSampleBufferAttachmentDescriptorArray* alloc(); + + AccelerationStructurePassSampleBufferAttachmentDescriptorArray* init(); + + AccelerationStructurePassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class AccelerationStructurePassDescriptor : public NS::Copying +{ +public: + static AccelerationStructurePassDescriptor* accelerationStructurePassDescriptor(); + + static AccelerationStructurePassDescriptor* alloc(); + + AccelerationStructurePassDescriptor* init(); + + AccelerationStructurePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const; +}; + +} +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::buildAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_), accelerationStructure, descriptor, scratchBuffer, scratchBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::copyAndCompactAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructure* destinationAccelerationStructure) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_), sourceAccelerationStructure, destinationAccelerationStructure); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::refitAccelerationStructure(const MTL::AccelerationStructure* sourceAccelerationStructure, const MTL::AccelerationStructureDescriptor* descriptor, const MTL::AccelerationStructure* destinationAccelerationStructure, const MTL::Buffer* scratchBuffer, NS::UInteger scratchBufferOffset, MTL::AccelerationStructureRefitOptions options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_), sourceAccelerationStructure, descriptor, destinationAccelerationStructure, scratchBuffer, scratchBufferOffset, options); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::updateFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_), fence); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeap(const MTL::Heap* heap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeap_), heap); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::waitForFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_), fence); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_), accelerationStructure, buffer, offset); +} + +_MTL_INLINE void MTL::AccelerationStructureCommandEncoder::writeCompactedAccelerationStructureSize(const MTL::AccelerationStructure* accelerationStructure, const MTL::Buffer* buffer, NS::UInteger offset, MTL::DataType sizeDataType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_), accelerationStructure, buffer, offset, sizeDataType); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::sampleBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBuffer)); +} + +_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex); +} + +_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer); +} + +_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex); +} + +_MTL_INLINE NS::UInteger MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::AccelerationStructurePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::accelerationStructurePassDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor), _MTL_PRIVATE_SEL(accelerationStructurePassDescriptor)); +} + +_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAccelerationStructurePassDescriptor)); +} + +_MTL_INLINE MTL::AccelerationStructurePassDescriptor* MTL::AccelerationStructurePassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::AccelerationStructurePassSampleBufferAttachmentDescriptorArray* MTL::AccelerationStructurePassDescriptor::sampleBufferAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBufferAttachments)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLAccelerationStructureTypes.hpp b/thirdparty/metal-cpp/Metal/MTLAccelerationStructureTypes.hpp new file mode 100644 index 0000000000..a08b1e962a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLAccelerationStructureTypes.hpp @@ -0,0 +1,292 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLAccelerationStructureTypes.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLDefines.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLStageInputOutputDescriptor.hpp" + +#include "../Foundation/Foundation.hpp" +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL +{ + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnested-anon-types" +struct PackedFloat3 +{ + PackedFloat3(); + PackedFloat3(float x, float y, float z); + + float& operator[](int idx); + float operator[](int idx) const; + + union + { + struct + { + float x; + float y; + float z; + }; + + float elements[3]; + }; +} _MTL_PACKED; +#pragma clang diagnostic pop + +struct PackedFloat4x3 +{ + PackedFloat4x3(); + PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3); + + PackedFloat3& operator[](int idx); + const PackedFloat3& operator[](int idx) const; + + PackedFloat3 columns[4]; +} _MTL_PACKED; + +struct AxisAlignedBoundingBox +{ + AxisAlignedBoundingBox(); + AxisAlignedBoundingBox(PackedFloat3 p); + AxisAlignedBoundingBox(PackedFloat3 min, PackedFloat3 max); + + PackedFloat3 min; + PackedFloat3 max; +} _MTL_PACKED; + +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnested-anon-types" +struct PackedFloatQuaternion +{ + PackedFloatQuaternion(); + PackedFloatQuaternion(float x, float y, float z, float w); + + float& operator[](int idx); + const float& operator[](int idx) const; + + union + { + struct + { + float x; + float y; + float z; + float w; + }; + + float elements[4]; + }; + +} _MTL_PACKED; +#pragma clang diagnostic pop + +struct ComponentTransform +{ + PackedFloat3 scale; + PackedFloat3 shear; + PackedFloat3 pivot; + PackedFloatQuaternion rotation; + PackedFloat3 translation; +} _MTL_PACKED; + +} + +namespace MTL4 +{ + +struct BufferRange +{ + BufferRange() = default; + BufferRange(uint64_t bufferAddress); + BufferRange(uint64_t bufferAddress, uint64_t length); + + static MTL4::BufferRange Make(uint64_t bufferAddress, uint64_t length); + + uint64_t bufferAddress; + uint64_t length; +} _MTL_PACKED; + +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloat3::PackedFloat3() + : x(0.0f) + , y(0.0f) + , z(0.0f) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloat3::PackedFloat3(float _x, float _y, float _z) + : x(_x) + , y(_y) + , z(_z) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE float& MTL::PackedFloat3::operator[](int idx) +{ + return elements[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE float MTL::PackedFloat3::operator[](int idx) const +{ + return elements[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3() +{ + columns[0] = PackedFloat3(0.0f, 0.0f, 0.0f); + columns[1] = PackedFloat3(0.0f, 0.0f, 0.0f); + columns[2] = PackedFloat3(0.0f, 0.0f, 0.0f); + columns[3] = PackedFloat3(0.0f, 0.0f, 0.0f); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloat4x3::PackedFloat4x3(const PackedFloat3& col0, const PackedFloat3& col1, const PackedFloat3& col2, const PackedFloat3& col3) +{ + columns[0] = col0; + columns[1] = col1; + columns[2] = col2; + columns[3] = col3; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx) +{ + return columns[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE const MTL::PackedFloat3& MTL::PackedFloat4x3::operator[](int idx) const +{ + return columns[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#if __apple_build_version__ > 16000026 +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wnan-infinity-disabled" +#endif // __apple_build_version__ > 16000026 +_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox() + : min(INFINITY, INFINITY, INFINITY) + , max(-INFINITY, -INFINITY, -INFINITY) +{ +} +#if __apple_build_version__ > 16000026 +#pragma clang diagnostic pop +#endif // if __apple_build_version__ > 16000026 + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 p) + : min(p) + , max(p) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::AxisAlignedBoundingBox::AxisAlignedBoundingBox(PackedFloat3 _min, PackedFloat3 _max) + : min(_min) + , max(_max) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloatQuaternion::PackedFloatQuaternion() + : x(0.0f) + , y(0.0f) + , z(0.0f) + , w(0.0f) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::PackedFloatQuaternion::PackedFloatQuaternion(float x, float y, float z, float w) + : x(x) + , y(y) + , z(z) + , w(w) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE float& MTL::PackedFloatQuaternion::operator[](int idx) +{ + return elements[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE const float& MTL::PackedFloatQuaternion::operator[](int idx) const +{ + return elements[idx]; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL4::BufferRange::BufferRange(uint64_t bufferAddress) +: bufferAddress(bufferAddress) +, length(-1) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL4::BufferRange::BufferRange(uint64_t bufferAddress, uint64_t length) +: bufferAddress(bufferAddress) +, length(length) +{ +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL4::BufferRange MTL4::BufferRange::Make(uint64_t bufferAddress, uint64_t length) +{ + return MTL4::BufferRange(bufferAddress, length); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + diff --git a/thirdparty/metal-cpp/Metal/MTLAllocation.hpp b/thirdparty/metal-cpp/Metal/MTLAllocation.hpp new file mode 100644 index 0000000000..ba2010588a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLAllocation.hpp @@ -0,0 +1,40 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLAllocation.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Allocation : public NS::Referencing +{ +public: + NS::UInteger allocatedSize() const; +}; + +} +_MTL_INLINE NS::UInteger MTL::Allocation::allocatedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allocatedSize)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLArgument.hpp b/thirdparty/metal-cpp/Metal/MTLArgument.hpp new file mode 100644 index 0000000000..f91bd917de --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLArgument.hpp @@ -0,0 +1,787 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLArgument.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDataType.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTensor.hpp" +#include "MTLTexture.hpp" + +namespace MTL +{ +class Argument; +class ArrayType; +class PointerType; +class StructMember; +class StructType; +class TensorExtents; +class TensorReferenceType; +class TextureReferenceType; +class Type; +_MTL_ENUM(NS::UInteger, IndexType) { + IndexTypeUInt16 = 0, + IndexTypeUInt32 = 1, +}; + +_MTL_ENUM(NS::Integer, BindingType) { + BindingTypeBuffer = 0, + BindingTypeThreadgroupMemory = 1, + BindingTypeTexture = 2, + BindingTypeSampler = 3, + BindingTypeImageblockData = 16, + BindingTypeImageblock = 17, + BindingTypeVisibleFunctionTable = 24, + BindingTypePrimitiveAccelerationStructure = 25, + BindingTypeInstanceAccelerationStructure = 26, + BindingTypeIntersectionFunctionTable = 27, + BindingTypeObjectPayload = 34, + BindingTypeTensor = 37, +}; + +_MTL_ENUM(NS::UInteger, ArgumentType) { + ArgumentTypeBuffer = 0, + ArgumentTypeThreadgroupMemory = 1, + ArgumentTypeTexture = 2, + ArgumentTypeSampler = 3, + ArgumentTypeImageblockData = 16, + ArgumentTypeImageblock = 17, + ArgumentTypeVisibleFunctionTable = 24, + ArgumentTypePrimitiveAccelerationStructure = 25, + ArgumentTypeInstanceAccelerationStructure = 26, + ArgumentTypeIntersectionFunctionTable = 27, +}; + +_MTL_ENUM(NS::UInteger, BindingAccess) { + BindingAccessReadOnly = 0, + BindingAccessReadWrite = 1, + BindingAccessWriteOnly = 2, + ArgumentAccessReadOnly = 0, + ArgumentAccessReadWrite = 1, + ArgumentAccessWriteOnly = 2, +}; + +class Type : public NS::Referencing +{ +public: + static Type* alloc(); + + DataType dataType() const; + + Type* init(); +}; +class StructMember : public NS::Referencing +{ +public: + static StructMember* alloc(); + + NS::UInteger argumentIndex() const; + + ArrayType* arrayType(); + + DataType dataType() const; + + StructMember* init(); + + NS::String* name() const; + + NS::UInteger offset() const; + + PointerType* pointerType(); + + StructType* structType(); + + TensorReferenceType* tensorReferenceType(); + + TextureReferenceType* textureReferenceType(); +}; +class StructType : public NS::Referencing +{ +public: + static StructType* alloc(); + + StructType* init(); + + StructMember* memberByName(const NS::String* name); + + NS::Array* members() const; +}; +class ArrayType : public NS::Referencing +{ +public: + static ArrayType* alloc(); + + NS::UInteger argumentIndexStride() const; + + NS::UInteger arrayLength() const; + + ArrayType* elementArrayType(); + + PointerType* elementPointerType(); + + StructType* elementStructType(); + + TensorReferenceType* elementTensorReferenceType(); + + TextureReferenceType* elementTextureReferenceType(); + + DataType elementType() const; + + ArrayType* init(); + + NS::UInteger stride() const; +}; +class PointerType : public NS::Referencing +{ +public: + BindingAccess access() const; + + NS::UInteger alignment() const; + + static PointerType* alloc(); + + NS::UInteger dataSize() const; + + ArrayType* elementArrayType(); + + bool elementIsArgumentBuffer() const; + + StructType* elementStructType(); + + DataType elementType() const; + + PointerType* init(); +}; +class TextureReferenceType : public NS::Referencing +{ +public: + BindingAccess access() const; + + static TextureReferenceType* alloc(); + + TextureReferenceType* init(); + + bool isDepthTexture() const; + + DataType textureDataType() const; + + TextureType textureType() const; +}; +class TensorReferenceType : public NS::Referencing +{ +public: + BindingAccess access() const; + + static TensorReferenceType* alloc(); + + TensorExtents* dimensions() const; + + DataType indexType() const; + + TensorReferenceType* init(); + + TensorDataType tensorDataType() const; +}; +class Argument : public NS::Referencing +{ +public: + BindingAccess access() const; + + [[deprecated("please use isActive instead")]] + bool active() const; + + static Argument* alloc(); + + NS::UInteger arrayLength() const; + + NS::UInteger bufferAlignment() const; + + NS::UInteger bufferDataSize() const; + + DataType bufferDataType() const; + + PointerType* bufferPointerType() const; + + StructType* bufferStructType() const; + + NS::UInteger index() const; + + Argument* init(); + + bool isActive() const; + + bool isDepthTexture() const; + + NS::String* name() const; + + DataType textureDataType() const; + + TextureType textureType() const; + + NS::UInteger threadgroupMemoryAlignment() const; + + NS::UInteger threadgroupMemoryDataSize() const; + + ArgumentType type() const; +}; +class Binding : public NS::Referencing +{ +public: + BindingAccess access() const; + + [[deprecated("please use isArgument instead")]] + bool argument() const; + + NS::UInteger index() const; + + bool isArgument() const; + + bool isUsed() const; + + NS::String* name() const; + + BindingType type() const; + + [[deprecated("please use isUsed instead")]] + bool used() const; +}; +class BufferBinding : public NS::Referencing +{ +public: + NS::UInteger bufferAlignment() const; + + NS::UInteger bufferDataSize() const; + + DataType bufferDataType() const; + + PointerType* bufferPointerType() const; + + StructType* bufferStructType() const; +}; +class ThreadgroupBinding : public NS::Referencing +{ +public: + NS::UInteger threadgroupMemoryAlignment() const; + + NS::UInteger threadgroupMemoryDataSize() const; +}; +class TextureBinding : public NS::Referencing +{ +public: + NS::UInteger arrayLength() const; + + [[deprecated("please use isDepthTexture instead")]] + bool depthTexture() const; + bool isDepthTexture() const; + + DataType textureDataType() const; + + TextureType textureType() const; +}; +class ObjectPayloadBinding : public NS::Referencing +{ +public: + NS::UInteger objectPayloadAlignment() const; + + NS::UInteger objectPayloadDataSize() const; +}; +class TensorBinding : public NS::Referencing +{ +public: + TensorExtents* dimensions() const; + + DataType indexType() const; + + TensorDataType tensorDataType() const; +}; + +} +_MTL_INLINE MTL::Type* MTL::Type::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLType)); +} + +_MTL_INLINE MTL::DataType MTL::Type::dataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataType)); +} + +_MTL_INLINE MTL::Type* MTL::Type::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::StructMember* MTL::StructMember::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLStructMember)); +} + +_MTL_INLINE NS::UInteger MTL::StructMember::argumentIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(argumentIndex)); +} + +_MTL_INLINE MTL::ArrayType* MTL::StructMember::arrayType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayType)); +} + +_MTL_INLINE MTL::DataType MTL::StructMember::dataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataType)); +} + +_MTL_INLINE MTL::StructMember* MTL::StructMember::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::StructMember::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE NS::UInteger MTL::StructMember::offset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(offset)); +} + +_MTL_INLINE MTL::PointerType* MTL::StructMember::pointerType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pointerType)); +} + +_MTL_INLINE MTL::StructType* MTL::StructMember::structType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(structType)); +} + +_MTL_INLINE MTL::TensorReferenceType* MTL::StructMember::tensorReferenceType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tensorReferenceType)); +} + +_MTL_INLINE MTL::TextureReferenceType* MTL::StructMember::textureReferenceType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureReferenceType)); +} + +_MTL_INLINE MTL::StructType* MTL::StructType::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLStructType)); +} + +_MTL_INLINE MTL::StructType* MTL::StructType::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::StructMember* MTL::StructType::memberByName(const NS::String* name) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(memberByName_), name); +} + +_MTL_INLINE NS::Array* MTL::StructType::members() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(members)); +} + +_MTL_INLINE MTL::ArrayType* MTL::ArrayType::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLArrayType)); +} + +_MTL_INLINE NS::UInteger MTL::ArrayType::argumentIndexStride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(argumentIndexStride)); +} + +_MTL_INLINE NS::UInteger MTL::ArrayType::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE MTL::ArrayType* MTL::ArrayType::elementArrayType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementArrayType)); +} + +_MTL_INLINE MTL::PointerType* MTL::ArrayType::elementPointerType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementPointerType)); +} + +_MTL_INLINE MTL::StructType* MTL::ArrayType::elementStructType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementStructType)); +} + +_MTL_INLINE MTL::TensorReferenceType* MTL::ArrayType::elementTensorReferenceType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementTensorReferenceType)); +} + +_MTL_INLINE MTL::TextureReferenceType* MTL::ArrayType::elementTextureReferenceType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementTextureReferenceType)); +} + +_MTL_INLINE MTL::DataType MTL::ArrayType::elementType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementType)); +} + +_MTL_INLINE MTL::ArrayType* MTL::ArrayType::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::ArrayType::stride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stride)); +} + +_MTL_INLINE MTL::BindingAccess MTL::PointerType::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE NS::UInteger MTL::PointerType::alignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alignment)); +} + +_MTL_INLINE MTL::PointerType* MTL::PointerType::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLPointerType)); +} + +_MTL_INLINE NS::UInteger MTL::PointerType::dataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataSize)); +} + +_MTL_INLINE MTL::ArrayType* MTL::PointerType::elementArrayType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementArrayType)); +} + +_MTL_INLINE bool MTL::PointerType::elementIsArgumentBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementIsArgumentBuffer)); +} + +_MTL_INLINE MTL::StructType* MTL::PointerType::elementStructType() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementStructType)); +} + +_MTL_INLINE MTL::DataType MTL::PointerType::elementType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(elementType)); +} + +_MTL_INLINE MTL::PointerType* MTL::PointerType::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::BindingAccess MTL::TextureReferenceType::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTextureReferenceType)); +} + +_MTL_INLINE MTL::TextureReferenceType* MTL::TextureReferenceType::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::TextureReferenceType::isDepthTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthTexture)); +} + +_MTL_INLINE MTL::DataType MTL::TextureReferenceType::textureDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureDataType)); +} + +_MTL_INLINE MTL::TextureType MTL::TextureReferenceType::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE MTL::BindingAccess MTL::TensorReferenceType::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE MTL::TensorReferenceType* MTL::TensorReferenceType::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTensorReferenceType)); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorReferenceType::dimensions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dimensions)); +} + +_MTL_INLINE MTL::DataType MTL::TensorReferenceType::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::TensorReferenceType* MTL::TensorReferenceType::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::TensorDataType MTL::TensorReferenceType::tensorDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tensorDataType)); +} + +_MTL_INLINE MTL::BindingAccess MTL::Argument::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE bool MTL::Argument::active() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE MTL::Argument* MTL::Argument::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLArgument)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::bufferAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferAlignment)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::bufferDataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferDataSize)); +} + +_MTL_INLINE MTL::DataType MTL::Argument::bufferDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferDataType)); +} + +_MTL_INLINE MTL::PointerType* MTL::Argument::bufferPointerType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferPointerType)); +} + +_MTL_INLINE MTL::StructType* MTL::Argument::bufferStructType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferStructType)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::index() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(index)); +} + +_MTL_INLINE MTL::Argument* MTL::Argument::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::Argument::isActive() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE bool MTL::Argument::isDepthTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthTexture)); +} + +_MTL_INLINE NS::String* MTL::Argument::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::DataType MTL::Argument::textureDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureDataType)); +} + +_MTL_INLINE MTL::TextureType MTL::Argument::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment)); +} + +_MTL_INLINE NS::UInteger MTL::Argument::threadgroupMemoryDataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize)); +} + +_MTL_INLINE MTL::ArgumentType MTL::Argument::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE MTL::BindingAccess MTL::Binding::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE bool MTL::Binding::argument() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isArgument)); +} + +_MTL_INLINE NS::UInteger MTL::Binding::index() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(index)); +} + +_MTL_INLINE bool MTL::Binding::isArgument() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isArgument)); +} + +_MTL_INLINE bool MTL::Binding::isUsed() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isUsed)); +} + +_MTL_INLINE NS::String* MTL::Binding::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::BindingType MTL::Binding::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE bool MTL::Binding::used() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isUsed)); +} + +_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferAlignment)); +} + +_MTL_INLINE NS::UInteger MTL::BufferBinding::bufferDataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferDataSize)); +} + +_MTL_INLINE MTL::DataType MTL::BufferBinding::bufferDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferDataType)); +} + +_MTL_INLINE MTL::PointerType* MTL::BufferBinding::bufferPointerType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferPointerType)); +} + +_MTL_INLINE MTL::StructType* MTL::BufferBinding::bufferStructType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferStructType)); +} + +_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryAlignment)); +} + +_MTL_INLINE NS::UInteger MTL::ThreadgroupBinding::threadgroupMemoryDataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryDataSize)); +} + +_MTL_INLINE NS::UInteger MTL::TextureBinding::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE bool MTL::TextureBinding::depthTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthTexture)); +} + +_MTL_INLINE bool MTL::TextureBinding::isDepthTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthTexture)); +} + +_MTL_INLINE MTL::DataType MTL::TextureBinding::textureDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureDataType)); +} + +_MTL_INLINE MTL::TextureType MTL::TextureBinding::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectPayloadAlignment)); +} + +_MTL_INLINE NS::UInteger MTL::ObjectPayloadBinding::objectPayloadDataSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectPayloadDataSize)); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorBinding::dimensions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dimensions)); +} + +_MTL_INLINE MTL::DataType MTL::TensorBinding::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::TensorDataType MTL::TensorBinding::tensorDataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tensorDataType)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLArgumentEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLArgumentEncoder.hpp new file mode 100644 index 0000000000..83dbbc201a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLArgumentEncoder.hpp @@ -0,0 +1,235 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLArgumentEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLDepthStencil.hpp" + +namespace MTL +{ +class AccelerationStructure; +class ArgumentEncoder; +class Buffer; +class ComputePipelineState; +class Device; +class IndirectCommandBuffer; +class IntersectionFunctionTable; +class RenderPipelineState; +class SamplerState; +class Texture; +class VisibleFunctionTable; + +static const NS::UInteger AttributeStrideStatic = NS::UIntegerMax; + +class ArgumentEncoder : public NS::Referencing +{ +public: + NS::UInteger alignment() const; + + void* constantData(NS::UInteger index); + + Device* device() const; + + NS::UInteger encodedLength() const; + + NS::String* label() const; + + ArgumentEncoder* newArgumentEncoder(NS::UInteger index); + + void setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger index); + + void setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger offset); + void setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement); + + void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range); + + void setComputePipelineState(const MTL::ComputePipelineState* pipeline, NS::UInteger index); + void setComputePipelineStates(const MTL::ComputePipelineState* const pipelines[], NS::Range range); + + void setDepthStencilState(const MTL::DepthStencilState* depthStencilState, NS::UInteger index); + void setDepthStencilStates(const MTL::DepthStencilState* const depthStencilStates[], NS::Range range); + + void setIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index); + void setIndirectCommandBuffers(const MTL::IndirectCommandBuffer* const buffers[], NS::Range range); + + void setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index); + void setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range); + + void setLabel(const NS::String* label); + + void setRenderPipelineState(const MTL::RenderPipelineState* pipeline, NS::UInteger index); + void setRenderPipelineStates(const MTL::RenderPipelineState* const pipelines[], NS::Range range); + + void setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + + void setTexture(const MTL::Texture* texture, NS::UInteger index); + void setTextures(const MTL::Texture* const textures[], NS::Range range); + + void setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger index); + void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range); +}; + +} + +_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::alignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alignment)); +} + +_MTL_INLINE void* MTL::ArgumentEncoder::constantData(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(constantDataAtIndex_), index); +} + +_MTL_INLINE MTL::Device* MTL::ArgumentEncoder::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::UInteger MTL::ArgumentEncoder::encodedLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(encodedLength)); +} + +_MTL_INLINE NS::String* MTL::ArgumentEncoder::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::ArgumentEncoder* MTL::ArgumentEncoder::newArgumentEncoder(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentEncoderForBufferAtIndex_), index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atIndex_), accelerationStructure, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentBuffer_offset_), argumentBuffer, offset); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setArgumentBuffer(const MTL::Buffer* argumentBuffer, NS::UInteger startOffset, NS::UInteger arrayElement) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentBuffer_startOffset_arrayElement_), argumentBuffer, startOffset, arrayElement); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineState(const MTL::ComputePipelineState* pipeline, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputePipelineState_atIndex_), pipeline, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setComputePipelineStates(const MTL::ComputePipelineState* const pipelines[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputePipelineStates_withRange_), pipelines, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilState_atIndex_), depthStencilState, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setDepthStencilStates(const MTL::DepthStencilState* const depthStencilStates[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilStates_withRange_), depthStencilStates, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffer_atIndex_), indirectCommandBuffer, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setIndirectCommandBuffers(const MTL::IndirectCommandBuffer* const buffers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndirectCommandBuffers_withRange_), buffers, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atIndex_), intersectionFunctionTable, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withRange_), intersectionFunctionTables, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipeline, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderPipelineState_atIndex_), pipeline, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setRenderPipelineStates(const MTL::RenderPipelineState* const pipelines[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderPipelineStates_withRange_), pipelines, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atIndex_), visibleFunctionTable, index); +} + +_MTL_INLINE void MTL::ArgumentEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withRange_), visibleFunctionTables, range); +} diff --git a/thirdparty/metal-cpp/Metal/MTLBinaryArchive.hpp b/thirdparty/metal-cpp/Metal/MTLBinaryArchive.hpp new file mode 100644 index 0000000000..c3f1689582 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLBinaryArchive.hpp @@ -0,0 +1,152 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLBinaryArchive.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class BinaryArchiveDescriptor; +class ComputePipelineDescriptor; +class Device; +class FunctionDescriptor; +class Library; +class MeshRenderPipelineDescriptor; +class RenderPipelineDescriptor; +class StitchedLibraryDescriptor; +class TileRenderPipelineDescriptor; +_MTL_ENUM(NS::UInteger, BinaryArchiveError) { + BinaryArchiveErrorNone = 0, + BinaryArchiveErrorInvalidFile = 1, + BinaryArchiveErrorUnexpectedElement = 2, + BinaryArchiveErrorCompilationFailure = 3, + BinaryArchiveErrorInternalError = 4, +}; + +_MTL_CONST(NS::ErrorDomain, BinaryArchiveDomain); +class BinaryArchiveDescriptor : public NS::Copying +{ +public: + static BinaryArchiveDescriptor* alloc(); + + BinaryArchiveDescriptor* init(); + + void setUrl(const NS::URL* url); + NS::URL* url() const; +}; +class BinaryArchive : public NS::Referencing +{ +public: + bool addComputePipelineFunctions(const MTL::ComputePipelineDescriptor* descriptor, NS::Error** error); + + bool addFunction(const MTL::FunctionDescriptor* descriptor, const MTL::Library* library, NS::Error** error); + + bool addLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error); + + bool addMeshRenderPipelineFunctions(const MTL::MeshRenderPipelineDescriptor* descriptor, NS::Error** error); + + bool addRenderPipelineFunctions(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error); + + bool addTileRenderPipelineFunctions(const MTL::TileRenderPipelineDescriptor* descriptor, NS::Error** error); + + Device* device() const; + + NS::String* label() const; + + bool serializeToURL(const NS::URL* url, NS::Error** error); + + void setLabel(const NS::String* label); +}; + +} +_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, BinaryArchiveDomain); +_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBinaryArchiveDescriptor)); +} + +_MTL_INLINE MTL::BinaryArchiveDescriptor* MTL::BinaryArchiveDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::BinaryArchiveDescriptor::setUrl(const NS::URL* url) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setUrl_), url); +} + +_MTL_INLINE NS::URL* MTL::BinaryArchiveDescriptor::url() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(url)); +} + +_MTL_INLINE bool MTL::BinaryArchive::addComputePipelineFunctions(const MTL::ComputePipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addComputePipelineFunctionsWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE bool MTL::BinaryArchive::addFunction(const MTL::FunctionDescriptor* descriptor, const MTL::Library* library, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addFunctionWithDescriptor_library_error_), descriptor, library, error); +} + +_MTL_INLINE bool MTL::BinaryArchive::addLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addLibraryWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE bool MTL::BinaryArchive::addMeshRenderPipelineFunctions(const MTL::MeshRenderPipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addMeshRenderPipelineFunctionsWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE bool MTL::BinaryArchive::addRenderPipelineFunctions(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addRenderPipelineFunctionsWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE bool MTL::BinaryArchive::addTileRenderPipelineFunctions(const MTL::TileRenderPipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::Device* MTL::BinaryArchive::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::BinaryArchive::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE bool MTL::BinaryArchive::serializeToURL(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error); +} + +_MTL_INLINE void MTL::BinaryArchive::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTLBlitCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLBlitCommandEncoder.hpp new file mode 100644 index 0000000000..319f05ef5f --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLBlitCommandEncoder.hpp @@ -0,0 +1,226 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLBlitCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class Buffer; +class CounterSampleBuffer; +class Fence; +class IndirectCommandBuffer; +class Resource; +class Tensor; +class TensorExtents; +class Texture; + +_MTL_OPTIONS(NS::UInteger, BlitOption) { + BlitOptionNone = 0, + BlitOptionDepthFromDepthStencil = 1, + BlitOptionStencilFromDepthStencil = 1 << 1, + BlitOptionRowLinearPVRTC = 1 << 2, +}; + +class BlitCommandEncoder : public NS::Referencing +{ +public: + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin); + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options); + void copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size); + + void copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions); + + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options); + void copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount); + void copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture); + + void copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex); + + void fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value); + + void generateMipmaps(const MTL::Texture* texture); + + void getTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const MTL::Buffer* countersBuffer, NS::UInteger countersBufferOffset); + + void optimizeContentsForCPUAccess(const MTL::Texture* texture); + void optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level); + + void optimizeContentsForGPUAccess(const MTL::Texture* texture); + void optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level); + + void optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range); + + void resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range); + + void resetTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice); + + void resolveCounters(const MTL::CounterSampleBuffer* sampleBuffer, NS::Range range, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset); + + void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier); + + void synchronizeResource(const MTL::Resource* resource); + + void synchronizeTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level); + + void updateFence(const MTL::Fence* fence); + + void waitForFence(const MTL::Fence* fence); +}; + +} +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin, MTL::BlitOption options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_), sourceBuffer, sourceOffset, sourceBytesPerRow, sourceBytesPerImage, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin, options); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromBuffer(const MTL::Buffer* sourceBuffer, NS::UInteger sourceOffset, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger size) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_), sourceBuffer, sourceOffset, destinationBuffer, destinationOffset, size); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTensor(const MTL::Tensor* sourceTensor, const MTL::TensorExtents* sourceOrigin, const MTL::TensorExtents* sourceDimensions, const MTL::Tensor* destinationTensor, const MTL::TensorExtents* destinationOrigin, const MTL::TensorExtents* destinationDimensions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTensor_sourceOrigin_sourceDimensions_toTensor_destinationOrigin_destinationDimensions_), sourceTensor, sourceOrigin, sourceDimensions, destinationTensor, destinationOrigin, destinationDimensions); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset, NS::UInteger destinationBytesPerRow, NS::UInteger destinationBytesPerImage, MTL::BlitOption options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationBuffer, destinationOffset, destinationBytesPerRow, destinationBytesPerImage, options); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, NS::UInteger sliceCount, NS::UInteger levelCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_), sourceTexture, sourceSlice, sourceLevel, destinationTexture, destinationSlice, destinationLevel, sliceCount, levelCount); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyFromTexture(const MTL::Texture* sourceTexture, const MTL::Texture* destinationTexture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyFromTexture_toTexture_), sourceTexture, destinationTexture); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::copyIndirectCommandBuffer(const MTL::IndirectCommandBuffer* source, NS::Range sourceRange, const MTL::IndirectCommandBuffer* destination, NS::UInteger destinationIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_), source, sourceRange, destination, destinationIndex); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::fillBuffer(const MTL::Buffer* buffer, NS::Range range, uint8_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(fillBuffer_range_value_), buffer, range, value); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::generateMipmaps(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(generateMipmapsForTexture_), texture); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::getTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice, bool resetCounters, const MTL::Buffer* countersBuffer, NS::UInteger countersBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_), texture, region, mipLevel, slice, resetCounters, countersBuffer, countersBufferOffset); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_), texture); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForCPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForCPUAccess_slice_level_), texture, slice, level); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_), texture); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::optimizeContentsForGPUAccess(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeContentsForGPUAccess_slice_level_), texture, slice, level); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::optimizeIndirectCommandBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizeIndirectCommandBuffer_withRange_), indirectCommandBuffer, range); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::resetCommandsInBuffer(const MTL::IndirectCommandBuffer* buffer, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resetCommandsInBuffer_withRange_), buffer, range); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::resetTextureAccessCounters(const MTL::Texture* texture, MTL::Region region, NS::UInteger mipLevel, NS::UInteger slice) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resetTextureAccessCounters_region_mipLevel_slice_), texture, region, mipLevel, slice); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::resolveCounters(const MTL::CounterSampleBuffer* sampleBuffer, NS::Range range, const MTL::Buffer* destinationBuffer, NS::UInteger destinationOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_), sampleBuffer, range, destinationBuffer, destinationOffset); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeResource(const MTL::Resource* resource) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(synchronizeResource_), resource); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::synchronizeTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(synchronizeTexture_slice_level_), texture, slice, level); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::updateFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_), fence); +} + +_MTL_INLINE void MTL::BlitCommandEncoder::waitForFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_), fence); +} diff --git a/thirdparty/metal-cpp/Metal/MTLBlitPass.hpp b/thirdparty/metal-cpp/Metal/MTLBlitPass.hpp new file mode 100644 index 0000000000..6b15e0b5d8 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLBlitPass.hpp @@ -0,0 +1,154 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLBlitPass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class BlitPassDescriptor; +class BlitPassSampleBufferAttachmentDescriptor; +class BlitPassSampleBufferAttachmentDescriptorArray; +class CounterSampleBuffer; + +class BlitPassSampleBufferAttachmentDescriptor : public NS::Copying +{ +public: + static BlitPassSampleBufferAttachmentDescriptor* alloc(); + + NS::UInteger endOfEncoderSampleIndex() const; + + BlitPassSampleBufferAttachmentDescriptor* init(); + + CounterSampleBuffer* sampleBuffer() const; + + void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex); + + void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer); + + void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex); + NS::UInteger startOfEncoderSampleIndex() const; +}; +class BlitPassSampleBufferAttachmentDescriptorArray : public NS::Referencing +{ +public: + static BlitPassSampleBufferAttachmentDescriptorArray* alloc(); + + BlitPassSampleBufferAttachmentDescriptorArray* init(); + + BlitPassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class BlitPassDescriptor : public NS::Copying +{ +public: + static BlitPassDescriptor* alloc(); + + static BlitPassDescriptor* blitPassDescriptor(); + + BlitPassDescriptor* init(); + + BlitPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const; +}; + +} +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::BlitPassSampleBufferAttachmentDescriptor::sampleBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBuffer)); +} + +_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex); +} + +_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer); +} + +_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex); +} + +_MTL_INLINE NS::UInteger MTL::BlitPassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassSampleBufferAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptor* MTL::BlitPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::BlitPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::BlitPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor)); +} + +_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::blitPassDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLBlitPassDescriptor), _MTL_PRIVATE_SEL(blitPassDescriptor)); +} + +_MTL_INLINE MTL::BlitPassDescriptor* MTL::BlitPassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::BlitPassSampleBufferAttachmentDescriptorArray* MTL::BlitPassDescriptor::sampleBufferAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBufferAttachments)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLBuffer.hpp b/thirdparty/metal-cpp/Metal/MTLBuffer.hpp new file mode 100644 index 0000000000..a93be1b069 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLBuffer.hpp @@ -0,0 +1,119 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLBuffer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLGPUAddress.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" + +namespace MTL +{ +class Buffer; +class Device; +class Tensor; +class TensorDescriptor; +class Texture; +class TextureDescriptor; + +class Buffer : public NS::Referencing +{ +public: + void addDebugMarker(const NS::String* marker, NS::Range range); + + void* contents(); + + void didModifyRange(NS::Range range); + + GPUAddress gpuAddress() const; + + NS::UInteger length() const; + + Buffer* newRemoteBufferViewForDevice(const MTL::Device* device); + + Tensor* newTensor(const MTL::TensorDescriptor* descriptor, NS::UInteger offset, NS::Error** error); + + Texture* newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow); + + Buffer* remoteStorageBuffer() const; + + void removeAllDebugMarkers(); + + BufferSparseTier sparseBufferTier() const; +}; + +} +_MTL_INLINE void MTL::Buffer::addDebugMarker(const NS::String* marker, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addDebugMarker_range_), marker, range); +} + +_MTL_INLINE void* MTL::Buffer::contents() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(contents)); +} + +_MTL_INLINE void MTL::Buffer::didModifyRange(NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(didModifyRange_), range); +} + +_MTL_INLINE MTL::GPUAddress MTL::Buffer::gpuAddress() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuAddress)); +} + +_MTL_INLINE NS::UInteger MTL::Buffer::length() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(length)); +} + +_MTL_INLINE MTL::Buffer* MTL::Buffer::newRemoteBufferViewForDevice(const MTL::Device* device) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRemoteBufferViewForDevice_), device); +} + +_MTL_INLINE MTL::Tensor* MTL::Buffer::newTensor(const MTL::TensorDescriptor* descriptor, NS::UInteger offset, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTensorWithDescriptor_offset_error_), descriptor, offset, error); +} + +_MTL_INLINE MTL::Texture* MTL::Buffer::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_bytesPerRow_), descriptor, offset, bytesPerRow); +} + +_MTL_INLINE MTL::Buffer* MTL::Buffer::remoteStorageBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(remoteStorageBuffer)); +} + +_MTL_INLINE void MTL::Buffer::removeAllDebugMarkers() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeAllDebugMarkers)); +} + +_MTL_INLINE MTL::BufferSparseTier MTL::Buffer::sparseBufferTier() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseBufferTier)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLCaptureManager.hpp b/thirdparty/metal-cpp/Metal/MTLCaptureManager.hpp new file mode 100644 index 0000000000..a762241830 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCaptureManager.hpp @@ -0,0 +1,217 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCaptureManager.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class CaptureDescriptor; +class CaptureManager; +class CaptureScope; +class CommandQueue; +class Device; +} + +namespace MTL4 +{ +class CommandQueue; +} + +namespace MTL +{ +_MTL_ENUM(NS::Integer, CaptureError) { + CaptureErrorNotSupported = 1, + CaptureErrorAlreadyCapturing = 2, + CaptureErrorInvalidDescriptor = 3, +}; + +_MTL_ENUM(NS::Integer, CaptureDestination) { + CaptureDestinationDeveloperTools = 1, + CaptureDestinationGPUTraceDocument = 2, +}; + +class CaptureDescriptor : public NS::Copying +{ +public: + static CaptureDescriptor* alloc(); + + NS::Object* captureObject() const; + + CaptureDestination destination() const; + + CaptureDescriptor* init(); + + NS::URL* outputURL() const; + + void setCaptureObject(NS::Object* captureObject); + + void setDestination(MTL::CaptureDestination destination); + + void setOutputURL(const NS::URL* outputURL); +}; +class CaptureManager : public NS::Referencing +{ +public: + static CaptureManager* alloc(); + + CaptureScope* defaultCaptureScope() const; + + CaptureManager* init(); + + bool isCapturing() const; + + CaptureScope* newCaptureScope(const MTL::Device* device); + CaptureScope* newCaptureScope(const MTL::CommandQueue* commandQueue); + CaptureScope* newCaptureScope(const MTL4::CommandQueue* commandQueue); + + void setDefaultCaptureScope(const MTL::CaptureScope* defaultCaptureScope); + + static CaptureManager* sharedCaptureManager(); + + bool startCapture(const MTL::CaptureDescriptor* descriptor, NS::Error** error); + void startCapture(const MTL::Device* device); + void startCapture(const MTL::CommandQueue* commandQueue); + void startCapture(const MTL::CaptureScope* captureScope); + + void stopCapture(); + + bool supportsDestination(MTL::CaptureDestination destination); +}; + +} +_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCaptureDescriptor)); +} + +_MTL_INLINE NS::Object* MTL::CaptureDescriptor::captureObject() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(captureObject)); +} + +_MTL_INLINE MTL::CaptureDestination MTL::CaptureDescriptor::destination() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(destination)); +} + +_MTL_INLINE MTL::CaptureDescriptor* MTL::CaptureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::URL* MTL::CaptureDescriptor::outputURL() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(outputURL)); +} + +_MTL_INLINE void MTL::CaptureDescriptor::setCaptureObject(NS::Object* captureObject) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCaptureObject_), captureObject); +} + +_MTL_INLINE void MTL::CaptureDescriptor::setDestination(MTL::CaptureDestination destination) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDestination_), destination); +} + +_MTL_INLINE void MTL::CaptureDescriptor::setOutputURL(const NS::URL* outputURL) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOutputURL_), outputURL); +} + +_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCaptureManager)); +} + +_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::defaultCaptureScope() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(defaultCaptureScope)); +} + +_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::CaptureManager::isCapturing() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isCapturing)); +} + +_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::Device* device) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCaptureScopeWithDevice_), device); +} + +_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL::CommandQueue* commandQueue) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCaptureScopeWithCommandQueue_), commandQueue); +} + +_MTL_INLINE MTL::CaptureScope* MTL::CaptureManager::newCaptureScope(const MTL4::CommandQueue* commandQueue) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCaptureScopeWithMTL4CommandQueue_), commandQueue); +} + +_MTL_INLINE void MTL::CaptureManager::setDefaultCaptureScope(const MTL::CaptureScope* defaultCaptureScope) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDefaultCaptureScope_), defaultCaptureScope); +} + +_MTL_INLINE MTL::CaptureManager* MTL::CaptureManager::sharedCaptureManager() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLCaptureManager), _MTL_PRIVATE_SEL(sharedCaptureManager)); +} + +_MTL_INLINE bool MTL::CaptureManager::startCapture(const MTL::CaptureDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startCaptureWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::Device* device) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(startCaptureWithDevice_), device); +} + +_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CommandQueue* commandQueue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(startCaptureWithCommandQueue_), commandQueue); +} + +_MTL_INLINE void MTL::CaptureManager::startCapture(const MTL::CaptureScope* captureScope) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(startCaptureWithScope_), captureScope); +} + +_MTL_INLINE void MTL::CaptureManager::stopCapture() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(stopCapture)); +} + +_MTL_INLINE bool MTL::CaptureManager::supportsDestination(MTL::CaptureDestination destination) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsDestination_), destination); +} diff --git a/thirdparty/metal-cpp/Metal/MTLCaptureScope.hpp b/thirdparty/metal-cpp/Metal/MTLCaptureScope.hpp new file mode 100644 index 0000000000..96ade67d47 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCaptureScope.hpp @@ -0,0 +1,91 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCaptureScope.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLDefines.hpp" +#include "MTLPrivate.hpp" + +#include "../Foundation/Foundation.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL +{ +class CaptureScope : public NS::Referencing +{ +public: + class Device* device() const; + + NS::String* label() const; + void setLabel(const NS::String* pLabel); + + class CommandQueue* commandQueue() const; + + void beginScope(); + void endScope(); +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::Device* MTL::CaptureScope::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE NS::String* MTL::CaptureScope::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE void MTL::CaptureScope::setLabel(const NS::String* pLabel) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), pLabel); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE MTL::CommandQueue* MTL::CaptureScope::commandQueue() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandQueue)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE void MTL::CaptureScope::beginScope() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(beginScope)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTL_INLINE void MTL::CaptureScope::endScope() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endScope)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Metal/MTLCommandBuffer.hpp b/thirdparty/metal-cpp/Metal/MTLCommandBuffer.hpp new file mode 100644 index 0000000000..c504573d33 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCommandBuffer.hpp @@ -0,0 +1,464 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCommandBuffer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include +#include + +#include + +namespace MTL +{ +class AccelerationStructureCommandEncoder; +class AccelerationStructurePassDescriptor; +class BlitCommandEncoder; +class BlitPassDescriptor; +class CommandBuffer; +class CommandBufferDescriptor; +class CommandQueue; +class ComputeCommandEncoder; +class ComputePassDescriptor; +class Device; +class Drawable; +class Event; +class LogContainer; +class LogState; +class ParallelRenderCommandEncoder; +class RenderCommandEncoder; +class RenderPassDescriptor; +class ResidencySet; +class ResourceStateCommandEncoder; +class ResourceStatePassDescriptor; +_MTL_ENUM(NS::UInteger, CommandBufferStatus) { + CommandBufferStatusNotEnqueued = 0, + CommandBufferStatusEnqueued = 1, + CommandBufferStatusCommitted = 2, + CommandBufferStatusScheduled = 3, + CommandBufferStatusCompleted = 4, + CommandBufferStatusError = 5, +}; + +_MTL_ENUM(NS::UInteger, CommandBufferError) { + CommandBufferErrorNone = 0, + CommandBufferErrorInternal = 1, + CommandBufferErrorTimeout = 2, + CommandBufferErrorPageFault = 3, + CommandBufferErrorBlacklisted = 4, + CommandBufferErrorAccessRevoked = 4, + CommandBufferErrorNotPermitted = 7, + CommandBufferErrorOutOfMemory = 8, + CommandBufferErrorInvalidResource = 9, + CommandBufferErrorMemoryless = 10, + CommandBufferErrorDeviceRemoved = 11, + CommandBufferErrorStackOverflow = 12, +}; + +_MTL_ENUM(NS::Integer, CommandEncoderErrorState) { + CommandEncoderErrorStateUnknown = 0, + CommandEncoderErrorStateCompleted = 1, + CommandEncoderErrorStateAffected = 2, + CommandEncoderErrorStatePending = 3, + CommandEncoderErrorStateFaulted = 4, +}; + +_MTL_ENUM(NS::UInteger, DispatchType) { + DispatchTypeSerial = 0, + DispatchTypeConcurrent = 1, +}; + +_MTL_OPTIONS(NS::UInteger, CommandBufferErrorOption) { + CommandBufferErrorOptionNone = 0, + CommandBufferErrorOptionEncoderExecutionStatus = 1, +}; + +using CommandBufferHandler = void (^)(CommandBuffer*); +using HandlerFunction = std::function; + +class CommandBufferDescriptor : public NS::Copying +{ +public: + static CommandBufferDescriptor* alloc(); + + CommandBufferErrorOption errorOptions() const; + + CommandBufferDescriptor* init(); + + LogState* logState() const; + + bool retainedReferences() const; + + void setErrorOptions(MTL::CommandBufferErrorOption errorOptions); + + void setLogState(const MTL::LogState* logState); + + void setRetainedReferences(bool retainedReferences); +}; +class CommandBufferEncoderInfo : public NS::Referencing +{ +public: + NS::Array* debugSignposts() const; + + CommandEncoderErrorState errorState() const; + + NS::String* label() const; +}; +class CommandBuffer : public NS::Referencing +{ +public: + CFTimeInterval GPUEndTime() const; + + CFTimeInterval GPUStartTime() const; + + AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder(); + AccelerationStructureCommandEncoder* accelerationStructureCommandEncoder(const MTL::AccelerationStructurePassDescriptor* descriptor); + + void addCompletedHandler(const MTL::CommandBufferHandler block); + void addCompletedHandler(const MTL::HandlerFunction& function); + + void addScheduledHandler(const MTL::CommandBufferHandler block); + void addScheduledHandler(const MTL::HandlerFunction& function); + + BlitCommandEncoder* blitCommandEncoder(); + BlitCommandEncoder* blitCommandEncoder(const MTL::BlitPassDescriptor* blitPassDescriptor); + + CommandQueue* commandQueue() const; + + void commit(); + + ComputeCommandEncoder* computeCommandEncoder(const MTL::ComputePassDescriptor* computePassDescriptor); + ComputeCommandEncoder* computeCommandEncoder(); + ComputeCommandEncoder* computeCommandEncoder(MTL::DispatchType dispatchType); + + Device* device() const; + + void encodeSignalEvent(const MTL::Event* event, uint64_t value); + + void encodeWait(const MTL::Event* event, uint64_t value); + + void enqueue(); + + NS::Error* error() const; + CommandBufferErrorOption errorOptions() const; + + CFTimeInterval kernelEndTime() const; + + CFTimeInterval kernelStartTime() const; + + NS::String* label() const; + + LogContainer* logs() const; + + ParallelRenderCommandEncoder* parallelRenderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor); + + void popDebugGroup(); + + void presentDrawable(const MTL::Drawable* drawable); + void presentDrawableAfterMinimumDuration(const MTL::Drawable* drawable, CFTimeInterval duration); + + void presentDrawableAtTime(const MTL::Drawable* drawable, CFTimeInterval presentationTime); + + void pushDebugGroup(const NS::String* string); + + RenderCommandEncoder* renderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor); + + ResourceStateCommandEncoder* resourceStateCommandEncoder(); + ResourceStateCommandEncoder* resourceStateCommandEncoder(const MTL::ResourceStatePassDescriptor* resourceStatePassDescriptor); + + bool retainedReferences() const; + + void setLabel(const NS::String* label); + + CommandBufferStatus status() const; + + void useResidencySet(const MTL::ResidencySet* residencySet); + void useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + void waitUntilCompleted(); + + void waitUntilScheduled(); +}; + +} +_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCommandBufferDescriptor)); +} + +_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBufferDescriptor::errorOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(errorOptions)); +} + +_MTL_INLINE MTL::CommandBufferDescriptor* MTL::CommandBufferDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::LogState* MTL::CommandBufferDescriptor::logState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(logState)); +} + +_MTL_INLINE bool MTL::CommandBufferDescriptor::retainedReferences() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(retainedReferences)); +} + +_MTL_INLINE void MTL::CommandBufferDescriptor::setErrorOptions(MTL::CommandBufferErrorOption errorOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setErrorOptions_), errorOptions); +} + +_MTL_INLINE void MTL::CommandBufferDescriptor::setLogState(const MTL::LogState* logState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLogState_), logState); +} + +_MTL_INLINE void MTL::CommandBufferDescriptor::setRetainedReferences(bool retainedReferences) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRetainedReferences_), retainedReferences); +} + +_MTL_INLINE NS::Array* MTL::CommandBufferEncoderInfo::debugSignposts() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(debugSignposts)); +} + +_MTL_INLINE MTL::CommandEncoderErrorState MTL::CommandBufferEncoderInfo::errorState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(errorState)); +} + +_MTL_INLINE NS::String* MTL::CommandBufferEncoderInfo::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUEndTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(GPUEndTime)); +} + +_MTL_INLINE CFTimeInterval MTL::CommandBuffer::GPUStartTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(GPUStartTime)); +} + +_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoder)); +} + +_MTL_INLINE MTL::AccelerationStructureCommandEncoder* MTL::CommandBuffer::accelerationStructureCommandEncoder(const MTL::AccelerationStructurePassDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(accelerationStructureCommandEncoderWithDescriptor_), descriptor); +} + +_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const MTL::CommandBufferHandler block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block); +} + +_MTL_INLINE void MTL::CommandBuffer::addCompletedHandler(const MTL::HandlerFunction& function) +{ + __block HandlerFunction blockFunction = function; + addCompletedHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); }); +} + +_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const MTL::CommandBufferHandler block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addScheduledHandler_), block); +} + +_MTL_INLINE void MTL::CommandBuffer::addScheduledHandler(const MTL::HandlerFunction& function) +{ + __block HandlerFunction blockFunction = function; + addScheduledHandler(^(MTL::CommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); }); +} + +_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(blitCommandEncoder)); +} + +_MTL_INLINE MTL::BlitCommandEncoder* MTL::CommandBuffer::blitCommandEncoder(const MTL::BlitPassDescriptor* blitPassDescriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(blitCommandEncoderWithDescriptor_), blitPassDescriptor); +} + +_MTL_INLINE MTL::CommandQueue* MTL::CommandBuffer::commandQueue() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandQueue)); +} + +_MTL_INLINE void MTL::CommandBuffer::commit() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(commit)); +} + +_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(const MTL::ComputePassDescriptor* computePassDescriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDescriptor_), computePassDescriptor); +} + +_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeCommandEncoder)); +} + +_MTL_INLINE MTL::ComputeCommandEncoder* MTL::CommandBuffer::computeCommandEncoder(MTL::DispatchType dispatchType) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeCommandEncoderWithDispatchType_), dispatchType); +} + +_MTL_INLINE MTL::Device* MTL::CommandBuffer::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE void MTL::CommandBuffer::encodeSignalEvent(const MTL::Event* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(encodeSignalEvent_value_), event, value); +} + +_MTL_INLINE void MTL::CommandBuffer::encodeWait(const MTL::Event* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(encodeWaitForEvent_value_), event, value); +} + +_MTL_INLINE void MTL::CommandBuffer::enqueue() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(enqueue)); +} + +_MTL_INLINE NS::Error* MTL::CommandBuffer::error() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(error)); +} + +_MTL_INLINE MTL::CommandBufferErrorOption MTL::CommandBuffer::errorOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(errorOptions)); +} + +_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelEndTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(kernelEndTime)); +} + +_MTL_INLINE CFTimeInterval MTL::CommandBuffer::kernelStartTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(kernelStartTime)); +} + +_MTL_INLINE NS::String* MTL::CommandBuffer::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::LogContainer* MTL::CommandBuffer::logs() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(logs)); +} + +_MTL_INLINE MTL::ParallelRenderCommandEncoder* MTL::CommandBuffer::parallelRenderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(parallelRenderCommandEncoderWithDescriptor_), renderPassDescriptor); +} + +_MTL_INLINE void MTL::CommandBuffer::popDebugGroup() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(popDebugGroup)); +} + +_MTL_INLINE void MTL::CommandBuffer::presentDrawable(const MTL::Drawable* drawable) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(presentDrawable_), drawable); +} + +_MTL_INLINE void MTL::CommandBuffer::presentDrawableAfterMinimumDuration(const MTL::Drawable* drawable, CFTimeInterval duration) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(presentDrawable_afterMinimumDuration_), drawable, duration); +} + +_MTL_INLINE void MTL::CommandBuffer::presentDrawableAtTime(const MTL::Drawable* drawable, CFTimeInterval presentationTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(presentDrawable_atTime_), drawable, presentationTime); +} + +_MTL_INLINE void MTL::CommandBuffer::pushDebugGroup(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string); +} + +_MTL_INLINE MTL::RenderCommandEncoder* MTL::CommandBuffer::renderCommandEncoder(const MTL::RenderPassDescriptor* renderPassDescriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderCommandEncoderWithDescriptor_), renderPassDescriptor); +} + +_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoder)); +} + +_MTL_INLINE MTL::ResourceStateCommandEncoder* MTL::CommandBuffer::resourceStateCommandEncoder(const MTL::ResourceStatePassDescriptor* resourceStatePassDescriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceStateCommandEncoderWithDescriptor_), resourceStatePassDescriptor); +} + +_MTL_INLINE bool MTL::CommandBuffer::retainedReferences() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(retainedReferences)); +} + +_MTL_INLINE void MTL::CommandBuffer::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::CommandBufferStatus MTL::CommandBuffer::status() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(status)); +} + +_MTL_INLINE void MTL::CommandBuffer::useResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResidencySet_), residencySet); +} + +_MTL_INLINE void MTL::CommandBuffer::useResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResidencySets_count_), residencySets, count); +} + +_MTL_INLINE void MTL::CommandBuffer::waitUntilCompleted() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitUntilCompleted)); +} + +_MTL_INLINE void MTL::CommandBuffer::waitUntilScheduled() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitUntilScheduled)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLCommandEncoder.hpp new file mode 100644 index 0000000000..a230ff5df2 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCommandEncoder.hpp @@ -0,0 +1,117 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Device; + +_MTL_OPTIONS(NS::UInteger, ResourceUsage) { + ResourceUsageRead = 1, + ResourceUsageWrite = 1 << 1, + ResourceUsageSample = 1 << 2, +}; + +_MTL_OPTIONS(NS::UInteger, BarrierScope) { + BarrierScopeBuffers = 1, + BarrierScopeTextures = 1 << 1, + BarrierScopeRenderTargets = 1 << 2, +}; + +_MTL_OPTIONS(NS::UInteger, Stages) { + StageVertex = 1, + StageFragment = 1 << 1, + StageTile = 1 << 2, + StageObject = 1 << 3, + StageMesh = 1 << 4, + StageResourceState = 1 << 26, + StageDispatch = 1 << 27, + StageBlit = 1 << 28, + StageAccelerationStructure = 1 << 29, + StageMachineLearning = 1 << 30, + StageAll = 9223372036854775807, +}; + +class CommandEncoder : public NS::Referencing +{ +public: + void barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages); + + Device* device() const; + + void endEncoding(); + + void insertDebugSignpost(const NS::String* string); + + NS::String* label() const; + + void popDebugGroup(); + + void pushDebugGroup(const NS::String* string); + + void setLabel(const NS::String* label); +}; + +} +_MTL_INLINE void MTL::CommandEncoder::barrierAfterQueueStages(MTL::Stages afterQueueStages, MTL::Stages beforeStages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(barrierAfterQueueStages_beforeStages_), afterQueueStages, beforeStages); +} + +_MTL_INLINE MTL::Device* MTL::CommandEncoder::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE void MTL::CommandEncoder::endEncoding() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(endEncoding)); +} + +_MTL_INLINE void MTL::CommandEncoder::insertDebugSignpost(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(insertDebugSignpost_), string); +} + +_MTL_INLINE NS::String* MTL::CommandEncoder::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::CommandEncoder::popDebugGroup() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(popDebugGroup)); +} + +_MTL_INLINE void MTL::CommandEncoder::pushDebugGroup(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string); +} + +_MTL_INLINE void MTL::CommandEncoder::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTLCommandQueue.hpp b/thirdparty/metal-cpp/Metal/MTLCommandQueue.hpp new file mode 100644 index 0000000000..5d3bf164ac --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCommandQueue.hpp @@ -0,0 +1,158 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCommandQueue.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class CommandBuffer; +class CommandBufferDescriptor; +class CommandQueueDescriptor; +class Device; +class LogState; +class ResidencySet; + +class CommandQueue : public NS::Referencing +{ +public: + void addResidencySet(const MTL::ResidencySet* residencySet); + void addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + CommandBuffer* commandBuffer(); + CommandBuffer* commandBuffer(const MTL::CommandBufferDescriptor* descriptor); + CommandBuffer* commandBufferWithUnretainedReferences(); + + Device* device() const; + + void insertDebugCaptureBoundary(); + + NS::String* label() const; + + void removeResidencySet(const MTL::ResidencySet* residencySet); + void removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count); + + void setLabel(const NS::String* label); +}; +class CommandQueueDescriptor : public NS::Copying +{ +public: + static CommandQueueDescriptor* alloc(); + + CommandQueueDescriptor* init(); + + LogState* logState() const; + + NS::UInteger maxCommandBufferCount() const; + + void setLogState(const MTL::LogState* logState); + + void setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount); +}; + +} +_MTL_INLINE void MTL::CommandQueue::addResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addResidencySet_), residencySet); +} + +_MTL_INLINE void MTL::CommandQueue::addResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addResidencySets_count_), residencySets, count); +} + +_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBuffer)); +} + +_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBuffer(const MTL::CommandBufferDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBufferWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::CommandBuffer* MTL::CommandQueue::commandBufferWithUnretainedReferences() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences)); +} + +_MTL_INLINE MTL::Device* MTL::CommandQueue::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE void MTL::CommandQueue::insertDebugCaptureBoundary() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(insertDebugCaptureBoundary)); +} + +_MTL_INLINE NS::String* MTL::CommandQueue::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::CommandQueue::removeResidencySet(const MTL::ResidencySet* residencySet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeResidencySet_), residencySet); +} + +_MTL_INLINE void MTL::CommandQueue::removeResidencySets(const MTL::ResidencySet* const residencySets[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeResidencySets_count_), residencySets, count); +} + +_MTL_INLINE void MTL::CommandQueue::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::CommandQueueDescriptor* MTL::CommandQueueDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCommandQueueDescriptor)); +} + +_MTL_INLINE MTL::CommandQueueDescriptor* MTL::CommandQueueDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::LogState* MTL::CommandQueueDescriptor::logState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(logState)); +} + +_MTL_INLINE NS::UInteger MTL::CommandQueueDescriptor::maxCommandBufferCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCommandBufferCount)); +} + +_MTL_INLINE void MTL::CommandQueueDescriptor::setLogState(const MTL::LogState* logState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLogState_), logState); +} + +_MTL_INLINE void MTL::CommandQueueDescriptor::setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCommandBufferCount_), maxCommandBufferCount); +} diff --git a/thirdparty/metal-cpp/Metal/MTLComputeCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLComputeCommandEncoder.hpp new file mode 100644 index 0000000000..2f555e572e --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLComputeCommandEncoder.hpp @@ -0,0 +1,324 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLComputeCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandBuffer.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class AccelerationStructure; +class Buffer; +class ComputePipelineState; +class CounterSampleBuffer; +class Fence; +class Heap; +class IndirectCommandBuffer; +class IntersectionFunctionTable; +class Resource; +class SamplerState; +class Texture; +class VisibleFunctionTable; + +struct DispatchThreadgroupsIndirectArguments +{ + uint32_t threadgroupsPerGrid[3]; +} _MTL_PACKED; + +struct DispatchThreadsIndirectArguments +{ + uint32_t threadsPerGrid[3]; + uint32_t threadsPerThreadgroup[3]; +} _MTL_PACKED; + +struct StageInRegionIndirectArguments +{ + uint32_t stageInOrigin[3]; + uint32_t stageInSize[3]; +} _MTL_PACKED; + +class ComputeCommandEncoder : public NS::Referencing +{ +public: + void dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup); + void dispatchThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup); + + void dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup); + + DispatchType dispatchType() const; + + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange); + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset); + + void memoryBarrier(MTL::BarrierScope scope); + void memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count); + + void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier); + + void setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex); + + void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index); + void setBufferOffset(NS::UInteger offset, NS::UInteger index); + void setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index); + + void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range); + void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range); + + void setBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + void setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index); + + void setComputePipelineState(const MTL::ComputePipelineState* state); + + void setImageblockWidth(NS::UInteger width, NS::UInteger height); + + void setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex); + void setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range); + + void setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range); + + void setStageInRegion(MTL::Region region); + void setStageInRegion(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + + void setTexture(const MTL::Texture* texture, NS::UInteger index); + void setTextures(const MTL::Texture* const textures[], NS::Range range); + + void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); + + void setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex); + void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range); + + void updateFence(const MTL::Fence* fence); + + void useHeap(const MTL::Heap* heap); + void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count); + + void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage); + void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage); + + void waitForFence(const MTL::Fence* fence); +}; + +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::dispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE MTL::DispatchType MTL::ComputeCommandEncoder::dispatchType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchType)); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(MTL::BarrierScope scope) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_), scope); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_), resources, count); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBufferOffset_attributeStride_atIndex_), offset, stride, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBytes_length_attributeStride_atIndex_), bytes, length, stride, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setComputePipelineState(const MTL::ComputePipelineState* state) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputePipelineState_), state); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setImageblockWidth(NS::UInteger width, NS::UInteger height) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(MTL::Region region) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStageInRegion_), region); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setStageInRegion(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_), indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTable(const MTL::VisibleFunctionTable* visibleFunctionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), visibleFunctionTable, bufferIndex); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const visibleFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), visibleFunctionTables, range); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::updateFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_), fence); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::useHeap(const MTL::Heap* heap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeap_), heap); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage); +} + +_MTL_INLINE void MTL::ComputeCommandEncoder::waitForFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_), fence); +} diff --git a/thirdparty/metal-cpp/Metal/MTLComputePass.hpp b/thirdparty/metal-cpp/Metal/MTLComputePass.hpp new file mode 100644 index 0000000000..fb34f7d849 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLComputePass.hpp @@ -0,0 +1,169 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLComputePass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandBuffer.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class ComputePassDescriptor; +class ComputePassSampleBufferAttachmentDescriptor; +class ComputePassSampleBufferAttachmentDescriptorArray; +class CounterSampleBuffer; + +class ComputePassSampleBufferAttachmentDescriptor : public NS::Copying +{ +public: + static ComputePassSampleBufferAttachmentDescriptor* alloc(); + + NS::UInteger endOfEncoderSampleIndex() const; + + ComputePassSampleBufferAttachmentDescriptor* init(); + + CounterSampleBuffer* sampleBuffer() const; + + void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex); + + void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer); + + void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex); + NS::UInteger startOfEncoderSampleIndex() const; +}; +class ComputePassSampleBufferAttachmentDescriptorArray : public NS::Referencing +{ +public: + static ComputePassSampleBufferAttachmentDescriptorArray* alloc(); + + ComputePassSampleBufferAttachmentDescriptorArray* init(); + + ComputePassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class ComputePassDescriptor : public NS::Copying +{ +public: + static ComputePassDescriptor* alloc(); + + static ComputePassDescriptor* computePassDescriptor(); + + DispatchType dispatchType() const; + + ComputePassDescriptor* init(); + + ComputePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const; + + void setDispatchType(MTL::DispatchType dispatchType); +}; + +} +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::ComputePassSampleBufferAttachmentDescriptor::sampleBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBuffer)); +} + +_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex); +} + +_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer); +} + +_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex); +} + +_MTL_INLINE NS::UInteger MTL::ComputePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassSampleBufferAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptor* MTL::ComputePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::ComputePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::ComputePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLComputePassDescriptor)); +} + +_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::computePassDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLComputePassDescriptor), _MTL_PRIVATE_SEL(computePassDescriptor)); +} + +_MTL_INLINE MTL::DispatchType MTL::ComputePassDescriptor::dispatchType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchType)); +} + +_MTL_INLINE MTL::ComputePassDescriptor* MTL::ComputePassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ComputePassSampleBufferAttachmentDescriptorArray* MTL::ComputePassDescriptor::sampleBufferAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBufferAttachments)); +} + +_MTL_INLINE void MTL::ComputePassDescriptor::setDispatchType(MTL::DispatchType dispatchType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDispatchType_), dispatchType); +} diff --git a/thirdparty/metal-cpp/Metal/MTLComputePipeline.hpp b/thirdparty/metal-cpp/Metal/MTLComputePipeline.hpp new file mode 100644 index 0000000000..d200af75b2 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLComputePipeline.hpp @@ -0,0 +1,439 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLComputePipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAllocation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPipeline.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class ComputePipelineDescriptor; +class ComputePipelineReflection; +class ComputePipelineState; +class Device; +class Function; +class FunctionHandle; +class IntersectionFunctionTable; +class IntersectionFunctionTableDescriptor; +class LinkedFunctions; +class PipelineBufferDescriptorArray; +class StageInputOutputDescriptor; +class VisibleFunctionTable; +class VisibleFunctionTableDescriptor; + +} +namespace MTL4 +{ +class BinaryFunction; + +} +namespace MTL +{ +class ComputePipelineReflection : public NS::Referencing +{ +public: + static ComputePipelineReflection* alloc(); + + NS::Array* arguments() const; + + NS::Array* bindings() const; + + ComputePipelineReflection* init(); +}; +class ComputePipelineDescriptor : public NS::Copying +{ +public: + static ComputePipelineDescriptor* alloc(); + + NS::Array* binaryArchives() const; + + PipelineBufferDescriptorArray* buffers() const; + + Function* computeFunction() const; + + ComputePipelineDescriptor* init(); + + NS::Array* insertLibraries() const; + + NS::String* label() const; + + LinkedFunctions* linkedFunctions() const; + + NS::UInteger maxCallStackDepth() const; + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + NS::Array* preloadedLibraries() const; + + Size requiredThreadsPerThreadgroup() const; + + void reset(); + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setComputeFunction(const MTL::Function* computeFunction); + + void setInsertLibraries(const NS::Array* insertLibraries); + + void setLabel(const NS::String* label); + + void setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions); + + void setMaxCallStackDepth(NS::UInteger maxCallStackDepth); + + void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup); + + void setPreloadedLibraries(const NS::Array* preloadedLibraries); + + void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup); + + void setShaderValidation(MTL::ShaderValidation shaderValidation); + + void setStageInputDescriptor(const MTL::StageInputOutputDescriptor* stageInputDescriptor); + + void setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions); + + void setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers); + + void setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth); + + ShaderValidation shaderValidation() const; + + StageInputOutputDescriptor* stageInputDescriptor() const; + + bool supportAddingBinaryFunctions() const; + + bool supportIndirectCommandBuffers() const; + + bool threadGroupSizeIsMultipleOfThreadExecutionWidth() const; +}; +class ComputePipelineState : public NS::Referencing +{ +public: + Device* device() const; + + FunctionHandle* functionHandle(const NS::String* name); + FunctionHandle* functionHandle(const MTL4::BinaryFunction* function); + FunctionHandle* functionHandle(const MTL::Function* function); + + ResourceID gpuResourceID() const; + + NS::UInteger imageblockMemoryLength(MTL::Size imageblockDimensions); + + NS::String* label() const; + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + ComputePipelineState* newComputePipelineStateWithBinaryFunctions(const NS::Array* additionalBinaryFunctions, NS::Error** error); + ComputePipelineState* newComputePipelineState(const NS::Array* functions, NS::Error** error); + + IntersectionFunctionTable* newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor); + + VisibleFunctionTable* newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor); + + ComputePipelineReflection* reflection() const; + + Size requiredThreadsPerThreadgroup() const; + + ShaderValidation shaderValidation() const; + + NS::UInteger staticThreadgroupMemoryLength() const; + + bool supportIndirectCommandBuffers() const; + + NS::UInteger threadExecutionWidth() const; +}; + +} +_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLComputePipelineReflection)); +} + +_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::arguments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arguments)); +} + +_MTL_INLINE NS::Array* MTL::ComputePipelineReflection::bindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bindings)); +} + +_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineReflection::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLComputePipelineDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::ComputePipelineDescriptor::buffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(buffers)); +} + +_MTL_INLINE MTL::Function* MTL::ComputePipelineDescriptor::computeFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(computeFunction)); +} + +_MTL_INLINE MTL::ComputePipelineDescriptor* MTL::ComputePipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::insertLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(insertLibraries)); +} + +_MTL_INLINE NS::String* MTL::ComputePipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::ComputePipelineDescriptor::linkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(linkedFunctions)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxCallStackDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCallStackDepth)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineDescriptor::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE NS::Array* MTL::ComputePipelineDescriptor::preloadedLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(preloadedLibraries)); +} + +_MTL_INLINE MTL::Size MTL::ComputePipelineDescriptor::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setComputeFunction(const MTL::Function* computeFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputeFunction_), computeFunction); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setInsertLibraries(const NS::Array* insertLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInsertLibraries_), insertLibraries); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setShaderValidation(MTL::ShaderValidation shaderValidation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setStageInputDescriptor(const MTL::StageInputOutputDescriptor* stageInputDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStageInputDescriptor_), stageInputDescriptor); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE void MTL::ComputePipelineDescriptor::setThreadGroupSizeIsMultipleOfThreadExecutionWidth(bool threadGroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_), threadGroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE MTL::ShaderValidation MTL::ComputePipelineDescriptor::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::ComputePipelineDescriptor::stageInputDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stageInputDescriptor)); +} + +_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportAddingBinaryFunctions() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions)); +} + +_MTL_INLINE bool MTL::ComputePipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE bool MTL::ComputePipelineDescriptor::threadGroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth)); +} + +_MTL_INLINE MTL::Device* MTL::ComputePipelineState::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const NS::String* name) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithName_), name); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const MTL4::BinaryFunction* function) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithBinaryFunction_), function); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::ComputePipelineState::functionHandle(const MTL::Function* function) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_), function); +} + +_MTL_INLINE MTL::ResourceID MTL::ComputePipelineState::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions); +} + +_MTL_INLINE NS::String* MTL::ComputePipelineState::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineState::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL::ComputePipelineState::newComputePipelineStateWithBinaryFunctions(const NS::Array* additionalBinaryFunctions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithBinaryFunctions_error_), additionalBinaryFunctions, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL::ComputePipelineState::newComputePipelineState(const NS::Array* functions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_), functions, error); +} + +_MTL_INLINE MTL::IntersectionFunctionTable* MTL::ComputePipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::VisibleFunctionTable* MTL::ComputePipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::ComputePipelineReflection* MTL::ComputePipelineState::reflection() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(reflection)); +} + +_MTL_INLINE MTL::Size MTL::ComputePipelineState::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE MTL::ShaderValidation MTL::ComputePipelineState::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineState::staticThreadgroupMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(staticThreadgroupMemoryLength)); +} + +_MTL_INLINE bool MTL::ComputePipelineState::supportIndirectCommandBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE NS::UInteger MTL::ComputePipelineState::threadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadExecutionWidth)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLCounters.hpp b/thirdparty/metal-cpp/Metal/MTLCounters.hpp new file mode 100644 index 0000000000..6d655f158d --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLCounters.hpp @@ -0,0 +1,243 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLCounters.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include + +namespace MTL +{ +class CounterSampleBufferDescriptor; +class CounterSet; +class Device; +_MTL_ENUM(NS::Integer, CounterSampleBufferError) { + CounterSampleBufferErrorOutOfMemory = 0, + CounterSampleBufferErrorInvalid = 1, + CounterSampleBufferErrorInternal = 2, +}; + +using CommonCounter = NS::String*; +using CommonCounterSet = NS::String*; + +static const NS::UInteger CounterErrorValue = static_cast(~0ULL); +static const NS::UInteger CounterDontSample = static_cast(-1); +_MTL_CONST(NS::ErrorDomain, CounterErrorDomain); +_MTL_CONST(CommonCounter, CommonCounterTimestamp); +_MTL_CONST(CommonCounter, CommonCounterTessellationInputPatches); +_MTL_CONST(CommonCounter, CommonCounterVertexInvocations); +_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexInvocations); +_MTL_CONST(CommonCounter, CommonCounterClipperInvocations); +_MTL_CONST(CommonCounter, CommonCounterClipperPrimitivesOut); +_MTL_CONST(CommonCounter, CommonCounterFragmentInvocations); +_MTL_CONST(CommonCounter, CommonCounterFragmentsPassed); +_MTL_CONST(CommonCounter, CommonCounterComputeKernelInvocations); +_MTL_CONST(CommonCounter, CommonCounterTotalCycles); +_MTL_CONST(CommonCounter, CommonCounterVertexCycles); +_MTL_CONST(CommonCounter, CommonCounterTessellationCycles); +_MTL_CONST(CommonCounter, CommonCounterPostTessellationVertexCycles); +_MTL_CONST(CommonCounter, CommonCounterFragmentCycles); +_MTL_CONST(CommonCounter, CommonCounterRenderTargetWriteCycles); +_MTL_CONST(CommonCounterSet, CommonCounterSetTimestamp); +_MTL_CONST(CommonCounterSet, CommonCounterSetStageUtilization); +_MTL_CONST(CommonCounterSet, CommonCounterSetStatistic); +struct CounterResultTimestamp +{ + uint64_t timestamp; +} _MTL_PACKED; + +struct CounterResultStageUtilization +{ + uint64_t totalCycles; + uint64_t vertexCycles; + uint64_t tessellationCycles; + uint64_t postTessellationVertexCycles; + uint64_t fragmentCycles; + uint64_t renderTargetCycles; +} _MTL_PACKED; + +struct CounterResultStatistic +{ + uint64_t tessellationInputPatches; + uint64_t vertexInvocations; + uint64_t postTessellationVertexInvocations; + uint64_t clipperInvocations; + uint64_t clipperPrimitivesOut; + uint64_t fragmentInvocations; + uint64_t fragmentsPassed; + uint64_t computeKernelInvocations; +} _MTL_PACKED; + +class Counter : public NS::Referencing +{ +public: + NS::String* name() const; +}; +class CounterSet : public NS::Referencing +{ +public: + NS::Array* counters() const; + + NS::String* name() const; +}; +class CounterSampleBufferDescriptor : public NS::Copying +{ +public: + static CounterSampleBufferDescriptor* alloc(); + + CounterSet* counterSet() const; + + CounterSampleBufferDescriptor* init(); + + NS::String* label() const; + + NS::UInteger sampleCount() const; + + void setCounterSet(const MTL::CounterSet* counterSet); + + void setLabel(const NS::String* label); + + void setSampleCount(NS::UInteger sampleCount); + + void setStorageMode(MTL::StorageMode storageMode); + StorageMode storageMode() const; +}; +class CounterSampleBuffer : public NS::Referencing +{ +public: + Device* device() const; + + NS::String* label() const; + + NS::Data* resolveCounterRange(NS::Range range); + + NS::UInteger sampleCount() const; +}; + +} + +_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, CounterErrorDomain); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTimestamp); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTessellationInputPatches); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterVertexInvocations); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterPostTessellationVertexInvocations); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterClipperInvocations); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterClipperPrimitivesOut); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentInvocations); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentsPassed); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterComputeKernelInvocations); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTotalCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterVertexCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterTessellationCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterPostTessellationVertexCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterFragmentCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounter, CommonCounterRenderTargetWriteCycles); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetTimestamp); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetStageUtilization); +_MTL_PRIVATE_DEF_CONST(MTL::CommonCounterSet, CommonCounterSetStatistic); + +_MTL_INLINE NS::String* MTL::Counter::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE NS::Array* MTL::CounterSet::counters() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(counters)); +} + +_MTL_INLINE NS::String* MTL::CounterSet::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCounterSampleBufferDescriptor)); +} + +_MTL_INLINE MTL::CounterSet* MTL::CounterSampleBufferDescriptor::counterSet() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(counterSet)); +} + +_MTL_INLINE MTL::CounterSampleBufferDescriptor* MTL::CounterSampleBufferDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::CounterSampleBufferDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::CounterSampleBufferDescriptor::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} + +_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setCounterSet(const MTL::CounterSet* counterSet) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCounterSet_), counterSet); +} + +_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setSampleCount(NS::UInteger sampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount); +} + +_MTL_INLINE void MTL::CounterSampleBufferDescriptor::setStorageMode(MTL::StorageMode storageMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode); +} + +_MTL_INLINE MTL::StorageMode MTL::CounterSampleBufferDescriptor::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} + +_MTL_INLINE MTL::Device* MTL::CounterSampleBuffer::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::CounterSampleBuffer::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::Data* MTL::CounterSampleBuffer::resolveCounterRange(NS::Range range) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveCounterRange_), range); +} + +_MTL_INLINE NS::UInteger MTL::CounterSampleBuffer::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLDataType.hpp b/thirdparty/metal-cpp/Metal/MTLDataType.hpp new file mode 100644 index 0000000000..f0e9b25adc --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDataType.hpp @@ -0,0 +1,129 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDataType.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +_MTL_ENUM(NS::UInteger, DataType) { + DataTypeNone = 0, + DataTypeStruct = 1, + DataTypeArray = 2, + DataTypeFloat = 3, + DataTypeFloat2 = 4, + DataTypeFloat3 = 5, + DataTypeFloat4 = 6, + DataTypeFloat2x2 = 7, + DataTypeFloat2x3 = 8, + DataTypeFloat2x4 = 9, + DataTypeFloat3x2 = 10, + DataTypeFloat3x3 = 11, + DataTypeFloat3x4 = 12, + DataTypeFloat4x2 = 13, + DataTypeFloat4x3 = 14, + DataTypeFloat4x4 = 15, + DataTypeHalf = 16, + DataTypeHalf2 = 17, + DataTypeHalf3 = 18, + DataTypeHalf4 = 19, + DataTypeHalf2x2 = 20, + DataTypeHalf2x3 = 21, + DataTypeHalf2x4 = 22, + DataTypeHalf3x2 = 23, + DataTypeHalf3x3 = 24, + DataTypeHalf3x4 = 25, + DataTypeHalf4x2 = 26, + DataTypeHalf4x3 = 27, + DataTypeHalf4x4 = 28, + DataTypeInt = 29, + DataTypeInt2 = 30, + DataTypeInt3 = 31, + DataTypeInt4 = 32, + DataTypeUInt = 33, + DataTypeUInt2 = 34, + DataTypeUInt3 = 35, + DataTypeUInt4 = 36, + DataTypeShort = 37, + DataTypeShort2 = 38, + DataTypeShort3 = 39, + DataTypeShort4 = 40, + DataTypeUShort = 41, + DataTypeUShort2 = 42, + DataTypeUShort3 = 43, + DataTypeUShort4 = 44, + DataTypeChar = 45, + DataTypeChar2 = 46, + DataTypeChar3 = 47, + DataTypeChar4 = 48, + DataTypeUChar = 49, + DataTypeUChar2 = 50, + DataTypeUChar3 = 51, + DataTypeUChar4 = 52, + DataTypeBool = 53, + DataTypeBool2 = 54, + DataTypeBool3 = 55, + DataTypeBool4 = 56, + DataTypeTexture = 58, + DataTypeSampler = 59, + DataTypePointer = 60, + DataTypeR8Unorm = 62, + DataTypeR8Snorm = 63, + DataTypeR16Unorm = 64, + DataTypeR16Snorm = 65, + DataTypeRG8Unorm = 66, + DataTypeRG8Snorm = 67, + DataTypeRG16Unorm = 68, + DataTypeRG16Snorm = 69, + DataTypeRGBA8Unorm = 70, + DataTypeRGBA8Unorm_sRGB = 71, + DataTypeRGBA8Snorm = 72, + DataTypeRGBA16Unorm = 73, + DataTypeRGBA16Snorm = 74, + DataTypeRGB10A2Unorm = 75, + DataTypeRG11B10Float = 76, + DataTypeRGB9E5Float = 77, + DataTypeRenderPipeline = 78, + DataTypeComputePipeline = 79, + DataTypeIndirectCommandBuffer = 80, + DataTypeLong = 81, + DataTypeLong2 = 82, + DataTypeLong3 = 83, + DataTypeLong4 = 84, + DataTypeULong = 85, + DataTypeULong2 = 86, + DataTypeULong3 = 87, + DataTypeULong4 = 88, + DataTypeVisibleFunctionTable = 115, + DataTypeIntersectionFunctionTable = 116, + DataTypePrimitiveAccelerationStructure = 117, + DataTypeInstanceAccelerationStructure = 118, + DataTypeBFloat = 121, + DataTypeBFloat2 = 122, + DataTypeBFloat3 = 123, + DataTypeBFloat4 = 124, + DataTypeDepthStencilState = 139, + DataTypeTensor = 140, +}; + +} diff --git a/thirdparty/metal-cpp/Metal/MTLDefines.hpp b/thirdparty/metal-cpp/Metal/MTLDefines.hpp new file mode 100644 index 0000000000..4260a2b1f3 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDefines.hpp @@ -0,0 +1,41 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDefines.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "../Foundation/NSDefines.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _MTL_EXPORT _NS_EXPORT +#define _MTL_EXTERN _NS_EXTERN +#define _MTL_INLINE _NS_INLINE +#define _MTL_PACKED _NS_PACKED + +#define _MTL_CONST(type, name) _NS_CONST(type, name) +#define _MTL_ENUM(type, name) _NS_ENUM(type, name) +#define _MTL_OPTIONS(type, name) _NS_OPTIONS(type, name) + +#define _MTL_VALIDATE_SIZE(ns, name) _NS_VALIDATE_SIZE(ns, name) +#define _MTL_VALIDATE_ENUM(ns, name) _NS_VALIDATE_ENUM(ns, name) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Metal/MTLDepthStencil.hpp b/thirdparty/metal-cpp/Metal/MTLDepthStencil.hpp new file mode 100644 index 0000000000..e1116175e1 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDepthStencil.hpp @@ -0,0 +1,277 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDepthStencil.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class DepthStencilDescriptor; +class Device; +class StencilDescriptor; +_MTL_ENUM(NS::UInteger, CompareFunction) { + CompareFunctionNever = 0, + CompareFunctionLess = 1, + CompareFunctionEqual = 2, + CompareFunctionLessEqual = 3, + CompareFunctionGreater = 4, + CompareFunctionNotEqual = 5, + CompareFunctionGreaterEqual = 6, + CompareFunctionAlways = 7, +}; + +_MTL_ENUM(NS::UInteger, StencilOperation) { + StencilOperationKeep = 0, + StencilOperationZero = 1, + StencilOperationReplace = 2, + StencilOperationIncrementClamp = 3, + StencilOperationDecrementClamp = 4, + StencilOperationInvert = 5, + StencilOperationIncrementWrap = 6, + StencilOperationDecrementWrap = 7, +}; + +class StencilDescriptor : public NS::Copying +{ +public: + static StencilDescriptor* alloc(); + + StencilOperation depthFailureOperation() const; + + StencilOperation depthStencilPassOperation() const; + + StencilDescriptor* init(); + + uint32_t readMask() const; + + void setDepthFailureOperation(MTL::StencilOperation depthFailureOperation); + + void setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation); + + void setReadMask(uint32_t readMask); + + void setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction); + + void setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation); + + void setWriteMask(uint32_t writeMask); + + CompareFunction stencilCompareFunction() const; + + StencilOperation stencilFailureOperation() const; + + uint32_t writeMask() const; +}; +class DepthStencilDescriptor : public NS::Copying +{ +public: + static DepthStencilDescriptor* alloc(); + + StencilDescriptor* backFaceStencil() const; + + CompareFunction depthCompareFunction() const; + + [[deprecated("please use isDepthWriteEnabled instead")]] + bool depthWriteEnabled() const; + + StencilDescriptor* frontFaceStencil() const; + + DepthStencilDescriptor* init(); + + bool isDepthWriteEnabled() const; + + NS::String* label() const; + + void setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil); + + void setDepthCompareFunction(MTL::CompareFunction depthCompareFunction); + + void setDepthWriteEnabled(bool depthWriteEnabled); + + void setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil); + + void setLabel(const NS::String* label); +}; +class DepthStencilState : public NS::Referencing +{ +public: + Device* device() const; + + ResourceID gpuResourceID() const; + + NS::String* label() const; +}; + +} +_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLStencilDescriptor)); +} + +_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthFailureOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthFailureOperation)); +} + +_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthStencilPassOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthStencilPassOperation)); +} + +_MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE uint32_t MTL::StencilDescriptor::readMask() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(readMask)); +} + +_MTL_INLINE void MTL::StencilDescriptor::setDepthFailureOperation(MTL::StencilOperation depthFailureOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthFailureOperation_), depthFailureOperation); +} + +_MTL_INLINE void MTL::StencilDescriptor::setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilPassOperation_), depthStencilPassOperation); +} + +_MTL_INLINE void MTL::StencilDescriptor::setReadMask(uint32_t readMask) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setReadMask_), readMask); +} + +_MTL_INLINE void MTL::StencilDescriptor::setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilCompareFunction_), stencilCompareFunction); +} + +_MTL_INLINE void MTL::StencilDescriptor::setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilFailureOperation_), stencilFailureOperation); +} + +_MTL_INLINE void MTL::StencilDescriptor::setWriteMask(uint32_t writeMask) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask); +} + +_MTL_INLINE MTL::CompareFunction MTL::StencilDescriptor::stencilCompareFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilCompareFunction)); +} + +_MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::stencilFailureOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilFailureOperation)); +} + +_MTL_INLINE uint32_t MTL::StencilDescriptor::writeMask() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(writeMask)); +} + +_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLDepthStencilDescriptor)); +} + +_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::backFaceStencil() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(backFaceStencil)); +} + +_MTL_INLINE MTL::CompareFunction MTL::DepthStencilDescriptor::depthCompareFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthCompareFunction)); +} + +_MTL_INLINE bool MTL::DepthStencilDescriptor::depthWriteEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled)); +} + +_MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::frontFaceStencil() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(frontFaceStencil)); +} + +_MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::DepthStencilDescriptor::isDepthWriteEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled)); +} + +_MTL_INLINE NS::String* MTL::DepthStencilDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::DepthStencilDescriptor::setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBackFaceStencil_), backFaceStencil); +} + +_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthCompareFunction(MTL::CompareFunction depthCompareFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthCompareFunction_), depthCompareFunction); +} + +_MTL_INLINE void MTL::DepthStencilDescriptor::setDepthWriteEnabled(bool depthWriteEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthWriteEnabled_), depthWriteEnabled); +} + +_MTL_INLINE void MTL::DepthStencilDescriptor::setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFrontFaceStencil_), frontFaceStencil); +} + +_MTL_INLINE void MTL::DepthStencilDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::Device* MTL::DepthStencilState::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::ResourceID MTL::DepthStencilState::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::String* MTL::DepthStencilState::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLDevice.hpp b/thirdparty/metal-cpp/Metal/MTLDevice.hpp new file mode 100644 index 0000000000..0e867397be --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDevice.hpp @@ -0,0 +1,1493 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDevice.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTL4Counters.hpp" +#include "MTLArgument.hpp" +#include "MTLDataType.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPixelFormat.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTexture.hpp" +#include "MTLTypes.hpp" +#include +#include +#include + +#include +#include +#include + +namespace MTL +{ +class AccelerationStructure; +class AccelerationStructureDescriptor; +class Architecture; +class ArgumentDescriptor; +class ArgumentEncoder; +class BinaryArchive; +class BinaryArchiveDescriptor; +class Buffer; +class BufferBinding; +class CommandQueue; +class CommandQueueDescriptor; +class CompileOptions; +class ComputePipelineDescriptor; +class ComputePipelineReflection; +class ComputePipelineState; +class CounterSampleBuffer; +class CounterSampleBufferDescriptor; +class DepthStencilDescriptor; +class DepthStencilState; +class Device; +class DynamicLibrary; +class Event; +class Fence; +class Function; +class FunctionConstantValues; +class FunctionHandle; +class Heap; +class HeapDescriptor; +class IOCommandQueue; +class IOCommandQueueDescriptor; +class IOFileHandle; +class IndirectCommandBuffer; +class IndirectCommandBufferDescriptor; +class Library; +class LogState; +class LogStateDescriptor; +class MeshRenderPipelineDescriptor; +class RasterizationRateMap; +class RasterizationRateMapDescriptor; +struct Region; +class RenderPipelineDescriptor; +class RenderPipelineReflection; +class RenderPipelineState; +class ResidencySet; +class ResidencySetDescriptor; +class ResourceViewPoolDescriptor; +struct SamplePosition; +class SamplerDescriptor; +class SamplerState; +class SharedEvent; +class SharedEventHandle; +class SharedTextureHandle; +class StitchedLibraryDescriptor; +class Tensor; +class TensorDescriptor; +class Texture; +class TextureDescriptor; +class TextureViewPool; +class TileRenderPipelineDescriptor; + +} +namespace MTL4 +{ +class Archive; +class ArgumentTable; +class ArgumentTableDescriptor; +class BinaryFunction; +class CommandAllocator; +class CommandAllocatorDescriptor; +class CommandBuffer; +class CommandQueue; +class CommandQueueDescriptor; +class Compiler; +class CompilerDescriptor; +class CounterHeap; +class CounterHeapDescriptor; +class PipelineDataSetSerializer; +class PipelineDataSetSerializerDescriptor; + +} +namespace MTL +{ +_MTL_ENUM(NS::Integer, IOCompressionMethod) { + IOCompressionMethodZlib = 0, + IOCompressionMethodLZFSE = 1, + IOCompressionMethodLZ4 = 2, + IOCompressionMethodLZMA = 3, + IOCompressionMethodLZBitmap = 4, +}; + +_MTL_ENUM(NS::UInteger, FeatureSet) { + FeatureSet_iOS_GPUFamily1_v1 = 0, + FeatureSet_iOS_GPUFamily2_v1 = 1, + FeatureSet_iOS_GPUFamily1_v2 = 2, + FeatureSet_iOS_GPUFamily2_v2 = 3, + FeatureSet_iOS_GPUFamily3_v1 = 4, + FeatureSet_iOS_GPUFamily1_v3 = 5, + FeatureSet_iOS_GPUFamily2_v3 = 6, + FeatureSet_iOS_GPUFamily3_v2 = 7, + FeatureSet_iOS_GPUFamily1_v4 = 8, + FeatureSet_iOS_GPUFamily2_v4 = 9, + FeatureSet_iOS_GPUFamily3_v3 = 10, + FeatureSet_iOS_GPUFamily4_v1 = 11, + FeatureSet_iOS_GPUFamily1_v5 = 12, + FeatureSet_iOS_GPUFamily2_v5 = 13, + FeatureSet_iOS_GPUFamily3_v4 = 14, + FeatureSet_iOS_GPUFamily4_v2 = 15, + FeatureSet_iOS_GPUFamily5_v1 = 16, + FeatureSet_macOS_GPUFamily1_v1 = 10000, + FeatureSet_OSX_GPUFamily1_v1 = 10000, + FeatureSet_macOS_GPUFamily1_v2 = 10001, + FeatureSet_OSX_GPUFamily1_v2 = 10001, + FeatureSet_macOS_ReadWriteTextureTier2 = 10002, + FeatureSet_OSX_ReadWriteTextureTier2 = 10002, + FeatureSet_macOS_GPUFamily1_v3 = 10003, + FeatureSet_macOS_GPUFamily1_v4 = 10004, + FeatureSet_macOS_GPUFamily2_v1 = 10005, + FeatureSet_watchOS_GPUFamily1_v1 = 20000, + FeatureSet_WatchOS_GPUFamily1_v1 = 20000, + FeatureSet_watchOS_GPUFamily2_v1 = 20001, + FeatureSet_WatchOS_GPUFamily2_v1 = 20001, + FeatureSet_tvOS_GPUFamily1_v1 = 30000, + FeatureSet_TVOS_GPUFamily1_v1 = 30000, + FeatureSet_tvOS_GPUFamily1_v2 = 30001, + FeatureSet_tvOS_GPUFamily1_v3 = 30002, + FeatureSet_tvOS_GPUFamily2_v1 = 30003, + FeatureSet_tvOS_GPUFamily1_v4 = 30004, + FeatureSet_tvOS_GPUFamily2_v2 = 30005, +}; + +_MTL_ENUM(NS::Integer, GPUFamily) { + GPUFamilyApple1 = 1001, + GPUFamilyApple2 = 1002, + GPUFamilyApple3 = 1003, + GPUFamilyApple4 = 1004, + GPUFamilyApple5 = 1005, + GPUFamilyApple6 = 1006, + GPUFamilyApple7 = 1007, + GPUFamilyApple8 = 1008, + GPUFamilyApple9 = 1009, + GPUFamilyApple10 = 1010, + GPUFamilyMac1 = 2001, + GPUFamilyMac2 = 2002, + GPUFamilyCommon1 = 3001, + GPUFamilyCommon2 = 3002, + GPUFamilyCommon3 = 3003, + GPUFamilyMacCatalyst1 = 4001, + GPUFamilyMacCatalyst2 = 4002, + GPUFamilyMetal3 = 5001, + GPUFamilyMetal4 = 5002, +}; + +_MTL_ENUM(NS::UInteger, DeviceLocation) { + DeviceLocationBuiltIn = 0, + DeviceLocationSlot = 1, + DeviceLocationExternal = 2, + DeviceLocationUnspecified = NS::UIntegerMax, +}; + +_MTL_ENUM(NS::UInteger, ReadWriteTextureTier) { + ReadWriteTextureTierNone = 0, + ReadWriteTextureTier1 = 1, + ReadWriteTextureTier2 = 2, +}; + +_MTL_ENUM(NS::UInteger, ArgumentBuffersTier) { + ArgumentBuffersTier1 = 0, + ArgumentBuffersTier2 = 1, +}; + +_MTL_ENUM(NS::UInteger, SparseTextureRegionAlignmentMode) { + SparseTextureRegionAlignmentModeOutward = 0, + SparseTextureRegionAlignmentModeInward = 1, +}; + +_MTL_ENUM(NS::UInteger, CounterSamplingPoint) { + CounterSamplingPointAtStageBoundary = 0, + CounterSamplingPointAtDrawBoundary = 1, + CounterSamplingPointAtDispatchBoundary = 2, + CounterSamplingPointAtTileDispatchBoundary = 3, + CounterSamplingPointAtBlitBoundary = 4, +}; + +_MTL_OPTIONS(NS::UInteger, PipelineOption) { + PipelineOptionNone = 0, + PipelineOptionArgumentInfo = 1, + PipelineOptionBindingInfo = 1, + PipelineOptionBufferTypeInfo = 1 << 1, + PipelineOptionFailOnBinaryArchiveMiss = 1 << 2, +}; + +using DeviceNotificationName = NS::String*; +using DeviceNotificationHandlerBlock = void (^)(MTL::Device* pDevice, MTL::DeviceNotificationName notifyName); +using DeviceNotificationHandlerFunction = std::function; +using AutoreleasedComputePipelineReflection = MTL::ComputePipelineReflection*; +using AutoreleasedRenderPipelineReflection = MTL::RenderPipelineReflection*; +using NewLibraryCompletionHandler = void (^)(MTL::Library*, NS::Error*); +using NewLibraryCompletionHandlerFunction = std::function; +using NewRenderPipelineStateCompletionHandler = void (^)(MTL::RenderPipelineState*, NS::Error*); +using NewRenderPipelineStateCompletionHandlerFunction = std::function; +using NewRenderPipelineStateWithReflectionCompletionHandler = void (^)(MTL::RenderPipelineState*, MTL::RenderPipelineReflection*, NS::Error*); +using NewRenderPipelineStateWithReflectionCompletionHandlerFunction = std::function; +using NewComputePipelineStateCompletionHandler = void (^)(MTL::ComputePipelineState*, NS::Error*); +using NewComputePipelineStateCompletionHandlerFunction = std::function; +using NewComputePipelineStateWithReflectionCompletionHandler = void (^)(MTL::ComputePipelineState*, MTL::ComputePipelineReflection*, NS::Error*); +using NewComputePipelineStateWithReflectionCompletionHandlerFunction = std::function; +using Timestamp = std::uint64_t; + +_MTL_CONST(DeviceNotificationName, DeviceWasAddedNotification); +_MTL_CONST(DeviceNotificationName, DeviceRemovalRequestedNotification); +_MTL_CONST(DeviceNotificationName, DeviceWasRemovedNotification); +_MTL_CONST(NS::ErrorUserInfoKey, CommandBufferEncoderInfoErrorKey); +Device* CreateSystemDefaultDevice(); +NS::Array* CopyAllDevices(); +NS::Array* CopyAllDevicesWithObserver(NS::Object** pOutObserver, MTL::DeviceNotificationHandlerBlock handler); +NS::Array* CopyAllDevicesWithObserver(NS::Object** pOutObserver, const MTL::DeviceNotificationHandlerFunction& handler); +void RemoveDeviceObserver(const NS::Object* pObserver); +struct AccelerationStructureSizes +{ + NS::UInteger accelerationStructureSize; + NS::UInteger buildScratchBufferSize; + NS::UInteger refitScratchBufferSize; +} _MTL_PACKED; + +struct SizeAndAlign +{ + NS::UInteger size; + NS::UInteger align; +} _MTL_PACKED; + +class ArgumentDescriptor : public NS::Copying +{ +public: + BindingAccess access() const; + + static ArgumentDescriptor* alloc(); + + static ArgumentDescriptor* argumentDescriptor(); + + NS::UInteger arrayLength() const; + + NS::UInteger constantBlockAlignment() const; + + DataType dataType() const; + + NS::UInteger index() const; + + ArgumentDescriptor* init(); + + void setAccess(MTL::BindingAccess access); + + void setArrayLength(NS::UInteger arrayLength); + + void setConstantBlockAlignment(NS::UInteger constantBlockAlignment); + + void setDataType(MTL::DataType dataType); + + void setIndex(NS::UInteger index); + + void setTextureType(MTL::TextureType textureType); + TextureType textureType() const; +}; +class Architecture : public NS::Copying +{ +public: + static Architecture* alloc(); + + Architecture* init(); + + NS::String* name() const; +}; +class Device : public NS::Referencing +{ +public: + AccelerationStructureSizes accelerationStructureSizes(const MTL::AccelerationStructureDescriptor* descriptor); + + Architecture* architecture() const; + + bool areBarycentricCoordsSupported() const; + + bool areProgrammableSamplePositionsSupported() const; + + bool areRasterOrderGroupsSupported() const; + + ArgumentBuffersTier argumentBuffersSupport() const; + + [[deprecated("please use areBarycentricCoordsSupported instead")]] + bool barycentricCoordsSupported() const; + + void convertSparsePixelRegions(const MTL::Region* pixelRegions, MTL::Region* tileRegions, MTL::Size tileSize, MTL::SparseTextureRegionAlignmentMode mode, NS::UInteger numRegions); + + void convertSparseTileRegions(const MTL::Region* tileRegions, MTL::Region* pixelRegions, MTL::Size tileSize, NS::UInteger numRegions); + + NS::Array* counterSets() const; + + NS::UInteger currentAllocatedSize() const; + + [[deprecated("please use isDepth24Stencil8PixelFormatSupported instead")]] + bool depth24Stencil8PixelFormatSupported() const; + + FunctionHandle* functionHandle(const MTL::Function* function); + FunctionHandle* functionHandle(const MTL4::BinaryFunction* function); + + void getDefaultSamplePositions(MTL::SamplePosition* positions, NS::UInteger count); + + bool hasUnifiedMemory() const; + + [[deprecated("please use isHeadless instead")]] + bool headless() const; + + SizeAndAlign heapAccelerationStructureSizeAndAlign(NS::UInteger size); + SizeAndAlign heapAccelerationStructureSizeAndAlign(const MTL::AccelerationStructureDescriptor* descriptor); + + SizeAndAlign heapBufferSizeAndAlign(NS::UInteger length, MTL::ResourceOptions options); + + SizeAndAlign heapTextureSizeAndAlign(const MTL::TextureDescriptor* desc); + + bool isDepth24Stencil8PixelFormatSupported() const; + + bool isHeadless() const; + + bool isLowPower() const; + + bool isRemovable() const; + + DeviceLocation location() const; + NS::UInteger locationNumber() const; + + [[deprecated("please use isLowPower instead")]] + bool lowPower() const; + + NS::UInteger maxArgumentBufferSamplerCount() const; + + NS::UInteger maxBufferLength() const; + + NS::UInteger maxThreadgroupMemoryLength() const; + + Size maxThreadsPerThreadgroup() const; + + uint64_t maxTransferRate() const; + + NS::UInteger maximumConcurrentCompilationTaskCount() const; + + NS::UInteger minimumLinearTextureAlignmentForPixelFormat(MTL::PixelFormat format); + + NS::UInteger minimumTextureBufferAlignmentForPixelFormat(MTL::PixelFormat format); + + NS::String* name() const; + + AccelerationStructure* newAccelerationStructure(NS::UInteger size); + AccelerationStructure* newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor); + + MTL4::Archive* newArchive(const NS::URL* url, NS::Error** error); + + ArgumentEncoder* newArgumentEncoder(const NS::Array* arguments); + ArgumentEncoder* newArgumentEncoder(const MTL::BufferBinding* bufferBinding); + + MTL4::ArgumentTable* newArgumentTable(const MTL4::ArgumentTableDescriptor* descriptor, NS::Error** error); + + BinaryArchive* newBinaryArchive(const MTL::BinaryArchiveDescriptor* descriptor, NS::Error** error); + + Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options); + Buffer* newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options); + Buffer* newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options, void (^deallocator)(void*, NS::UInteger)); + Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options, MTL::SparsePageSize placementSparsePageSize); + + MTL4::CommandAllocator* newCommandAllocator(); + MTL4::CommandAllocator* newCommandAllocator(const MTL4::CommandAllocatorDescriptor* descriptor, NS::Error** error); + + MTL4::CommandBuffer* newCommandBuffer(); + + CommandQueue* newCommandQueue(); + CommandQueue* newCommandQueue(NS::UInteger maxCommandBufferCount); + CommandQueue* newCommandQueue(const MTL::CommandQueueDescriptor* descriptor); + + MTL4::Compiler* newCompiler(const MTL4::CompilerDescriptor* descriptor, NS::Error** error); + + ComputePipelineState* newComputePipelineState(const MTL::Function* computeFunction, NS::Error** error); + ComputePipelineState* newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error); + void newComputePipelineState(const MTL::Function* computeFunction, const MTL::NewComputePipelineStateCompletionHandler completionHandler); + void newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler); + ComputePipelineState* newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error); + void newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler); + void newComputePipelineState(const MTL::Function* pFunction, const MTL::NewComputePipelineStateCompletionHandlerFunction& completionHandler); + void newComputePipelineState(const MTL::Function* pFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler); + void newComputePipelineState(const MTL::ComputePipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler); + + MTL4::CounterHeap* newCounterHeap(const MTL4::CounterHeapDescriptor* descriptor, NS::Error** error); + + CounterSampleBuffer* newCounterSampleBuffer(const MTL::CounterSampleBufferDescriptor* descriptor, NS::Error** error); + + Library* newDefaultLibrary(); + Library* newDefaultLibrary(const NS::Bundle* bundle, NS::Error** error); + + DepthStencilState* newDepthStencilState(const MTL::DepthStencilDescriptor* descriptor); + + DynamicLibrary* newDynamicLibrary(const MTL::Library* library, NS::Error** error); + DynamicLibrary* newDynamicLibrary(const NS::URL* url, NS::Error** error); + + Event* newEvent(); + + Fence* newFence(); + + Heap* newHeap(const MTL::HeapDescriptor* descriptor); + + IOCommandQueue* newIOCommandQueue(const MTL::IOCommandQueueDescriptor* descriptor, NS::Error** error); + + IOFileHandle* newIOFileHandle(const NS::URL* url, NS::Error** error); + IOFileHandle* newIOFileHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error); + + IOFileHandle* newIOHandle(const NS::URL* url, NS::Error** error); + IOFileHandle* newIOHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error); + + IndirectCommandBuffer* newIndirectCommandBuffer(const MTL::IndirectCommandBufferDescriptor* descriptor, NS::UInteger maxCount, MTL::ResourceOptions options); + + Library* newLibrary(const NS::String* filepath, NS::Error** error); + Library* newLibrary(const NS::URL* url, NS::Error** error); + Library* newLibrary(const dispatch_data_t data, NS::Error** error); + Library* newLibrary(const NS::String* source, const MTL::CompileOptions* options, NS::Error** error); + void newLibrary(const NS::String* source, const MTL::CompileOptions* options, const MTL::NewLibraryCompletionHandler completionHandler); + Library* newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error); + void newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler); + void newLibrary(const NS::String* pSource, const MTL::CompileOptions* pOptions, const MTL::NewLibraryCompletionHandlerFunction& completionHandler); + void newLibrary(const MTL::StitchedLibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& completionHandler); + + LogState* newLogState(const MTL::LogStateDescriptor* descriptor, NS::Error** error); + + MTL4::CommandQueue* newMTL4CommandQueue(); + MTL4::CommandQueue* newMTL4CommandQueue(const MTL4::CommandQueueDescriptor* descriptor, NS::Error** error); + + MTL4::PipelineDataSetSerializer* newPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializerDescriptor* descriptor); + + RasterizationRateMap* newRasterizationRateMap(const MTL::RasterizationRateMapDescriptor* descriptor); + + RenderPipelineState* newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error); + RenderPipelineState* newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error); + void newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, const MTL::NewRenderPipelineStateCompletionHandler completionHandler); + void newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler); + RenderPipelineState* newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error); + void newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler); + RenderPipelineState* newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error); + void newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler); + void newRenderPipelineState(const MTL::RenderPipelineDescriptor* pDescriptor, const MTL::NewRenderPipelineStateCompletionHandlerFunction& completionHandler); + void newRenderPipelineState(const MTL::RenderPipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler); + void newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler); + + ResidencySet* newResidencySet(const MTL::ResidencySetDescriptor* desc, NS::Error** error); + + SamplerState* newSamplerState(const MTL::SamplerDescriptor* descriptor); + + SharedEvent* newSharedEvent(); + SharedEvent* newSharedEvent(const MTL::SharedEventHandle* sharedEventHandle); + + Texture* newSharedTexture(const MTL::TextureDescriptor* descriptor); + Texture* newSharedTexture(const MTL::SharedTextureHandle* sharedHandle); + + Tensor* newTensor(const MTL::TensorDescriptor* descriptor, NS::Error** error); + + Texture* newTexture(const MTL::TextureDescriptor* descriptor); + Texture* newTexture(const MTL::TextureDescriptor* descriptor, const IOSurfaceRef iosurface, NS::UInteger plane); + TextureViewPool* newTextureViewPool(const MTL::ResourceViewPoolDescriptor* descriptor, NS::Error** error); + + uint32_t peerCount() const; + + uint64_t peerGroupID() const; + + uint32_t peerIndex() const; + + [[deprecated("please use areProgrammableSamplePositionsSupported instead")]] + bool programmableSamplePositionsSupported() const; + + uint64_t queryTimestampFrequency(); + + [[deprecated("please use areRasterOrderGroupsSupported instead")]] + bool rasterOrderGroupsSupported() const; + + ReadWriteTextureTier readWriteTextureSupport() const; + + uint64_t recommendedMaxWorkingSetSize() const; + + uint64_t registryID() const; + + [[deprecated("please use isRemovable instead")]] + bool removable() const; + + void sampleTimestamps(MTL::Timestamp* cpuTimestamp, MTL::Timestamp* gpuTimestamp); + + void setShouldMaximizeConcurrentCompilation(bool shouldMaximizeConcurrentCompilation); + bool shouldMaximizeConcurrentCompilation() const; + + NS::UInteger sizeOfCounterHeapEntry(MTL4::CounterHeapType type); + + Size sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount); + Size sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount, MTL::SparsePageSize sparsePageSize); + NS::UInteger sparseTileSizeInBytes() const; + NS::UInteger sparseTileSizeInBytes(MTL::SparsePageSize sparsePageSize); + + bool supports32BitFloatFiltering() const; + + bool supports32BitMSAA() const; + + bool supportsBCTextureCompression() const; + + bool supportsCounterSampling(MTL::CounterSamplingPoint samplingPoint); + + bool supportsDynamicLibraries() const; + + bool supportsFamily(MTL::GPUFamily gpuFamily); + + bool supportsFeatureSet(MTL::FeatureSet featureSet); + + bool supportsFunctionPointers() const; + bool supportsFunctionPointersFromRender() const; + + bool supportsPrimitiveMotionBlur() const; + + bool supportsPullModelInterpolation() const; + + bool supportsQueryTextureLOD() const; + + bool supportsRasterizationRateMap(NS::UInteger layerCount); + + bool supportsRaytracing() const; + bool supportsRaytracingFromRender() const; + + bool supportsRenderDynamicLibraries() const; + + bool supportsShaderBarycentricCoordinates() const; + + bool supportsTextureSampleCount(NS::UInteger sampleCount); + + bool supportsVertexAmplificationCount(NS::UInteger count); + + SizeAndAlign tensorSizeAndAlign(const MTL::TensorDescriptor* descriptor); +}; + +} + +#if defined(MTL_PRIVATE_IMPLEMENTATION) +extern "C" MTL::Device* MTLCreateSystemDefaultDevice(); +extern "C" NS::Array* MTLCopyAllDevices(); +extern "C" NS::Array* MTLCopyAllDevicesWithObserver(NS::Object**, MTL::DeviceNotificationHandlerBlock); +extern "C" void MTLRemoveDeviceObserver(const NS::Object*); +_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceWasAddedNotification); +_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceRemovalRequestedNotification); +_MTL_PRIVATE_DEF_WEAK_CONST(MTL::DeviceNotificationName, DeviceWasRemovedNotification); +_MTL_PRIVATE_DEF_CONST(NS::ErrorUserInfoKey, CommandBufferEncoderInfoErrorKey); +_NS_EXPORT MTL::Device* MTL::CreateSystemDefaultDevice() +{ + return ::MTLCreateSystemDefaultDevice(); +} + +_NS_EXPORT NS::Array* MTL::CopyAllDevices() +{ +#if (__IPHONE_OS_VERSION_MIN_REQUIRED >= 180000) || (__MAC_OS_X_VERSION_MIN_REQUIRED >= 101100) + return ::MTLCopyAllDevices(); +#else + return nullptr; +#endif +} + +_NS_EXPORT NS::Array* MTL::CopyAllDevicesWithObserver(NS::Object** pOutObserver, MTL::DeviceNotificationHandlerBlock handler) +{ +#if TARGET_OS_OSX + return ::MTLCopyAllDevicesWithObserver(pOutObserver, handler); +#else + (void)pOutObserver; + (void)handler; + return nullptr; +#endif // TARGET_OS_OSX +} + +_NS_EXPORT NS::Array* MTL::CopyAllDevicesWithObserver(NS::Object** pOutObserver, const MTL::DeviceNotificationHandlerFunction& handler) +{ + __block DeviceNotificationHandlerFunction function = handler; + return CopyAllDevicesWithObserver(pOutObserver, ^(Device* pDevice, DeviceNotificationName pNotificationName) { function(pDevice, pNotificationName); }); +} + +_NS_EXPORT void MTL::RemoveDeviceObserver(const NS::Object* pObserver) +{ + (void)pObserver; +#if TARGET_OS_OSX + ::MTLRemoveDeviceObserver(pObserver); +#endif // TARGET_OS_OSX +} + +#endif // MTL_PRIVATE_IMPLEMENTATION + +_MTL_INLINE MTL::BindingAccess MTL::ArgumentDescriptor::access() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(access)); +} + +_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLArgumentDescriptor)); +} + +_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::argumentDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLArgumentDescriptor), _MTL_PRIVATE_SEL(argumentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::constantBlockAlignment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(constantBlockAlignment)); +} + +_MTL_INLINE MTL::DataType MTL::ArgumentDescriptor::dataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataType)); +} + +_MTL_INLINE NS::UInteger MTL::ArgumentDescriptor::index() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(index)); +} + +_MTL_INLINE MTL::ArgumentDescriptor* MTL::ArgumentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setAccess(MTL::BindingAccess access) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAccess_), access); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setArrayLength(NS::UInteger arrayLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArrayLength_), arrayLength); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setConstantBlockAlignment(NS::UInteger constantBlockAlignment) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantBlockAlignment_), constantBlockAlignment); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setDataType(MTL::DataType dataType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDataType_), dataType); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setIndex(NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndex_), index); +} + +_MTL_INLINE void MTL::ArgumentDescriptor::setTextureType(MTL::TextureType textureType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureType_), textureType); +} + +_MTL_INLINE MTL::TextureType MTL::ArgumentDescriptor::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE MTL::Architecture* MTL::Architecture::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLArchitecture)); +} + +_MTL_INLINE MTL::Architecture* MTL::Architecture::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::Architecture::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::AccelerationStructureSizes MTL::Device::accelerationStructureSizes(const MTL::AccelerationStructureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(accelerationStructureSizesWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::Architecture* MTL::Device::architecture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(architecture)); +} + +_MTL_INLINE bool MTL::Device::areBarycentricCoordsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areBarycentricCoordsSupported)); +} + +_MTL_INLINE bool MTL::Device::areProgrammableSamplePositionsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areProgrammableSamplePositionsSupported)); +} + +_MTL_INLINE bool MTL::Device::areRasterOrderGroupsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areRasterOrderGroupsSupported)); +} + +_MTL_INLINE MTL::ArgumentBuffersTier MTL::Device::argumentBuffersSupport() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(argumentBuffersSupport)); +} + +_MTL_INLINE bool MTL::Device::barycentricCoordsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areBarycentricCoordsSupported)); +} + +_MTL_INLINE void MTL::Device::convertSparsePixelRegions(const MTL::Region* pixelRegions, MTL::Region* tileRegions, MTL::Size tileSize, MTL::SparseTextureRegionAlignmentMode mode, NS::UInteger numRegions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(convertSparsePixelRegions_toTileRegions_withTileSize_alignmentMode_numRegions_), pixelRegions, tileRegions, tileSize, mode, numRegions); +} + +_MTL_INLINE void MTL::Device::convertSparseTileRegions(const MTL::Region* tileRegions, MTL::Region* pixelRegions, MTL::Size tileSize, NS::UInteger numRegions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(convertSparseTileRegions_toPixelRegions_withTileSize_numRegions_), tileRegions, pixelRegions, tileSize, numRegions); +} + +_MTL_INLINE NS::Array* MTL::Device::counterSets() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(counterSets)); +} + +_MTL_INLINE NS::UInteger MTL::Device::currentAllocatedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(currentAllocatedSize)); +} + +_MTL_INLINE bool MTL::Device::depth24Stencil8PixelFormatSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(isDepth24Stencil8PixelFormatSupported)); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::Device::functionHandle(const MTL::Function* function) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_), function); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::Device::functionHandle(const MTL4::BinaryFunction* function) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithBinaryFunction_), function); +} + +_MTL_INLINE void MTL::Device::getDefaultSamplePositions(MTL::SamplePosition* positions, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(getDefaultSamplePositions_count_), positions, count); +} + +_MTL_INLINE bool MTL::Device::hasUnifiedMemory() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hasUnifiedMemory)); +} + +_MTL_INLINE bool MTL::Device::headless() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isHeadless)); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapAccelerationStructureSizeAndAlign(NS::UInteger size) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heapAccelerationStructureSizeAndAlignWithSize_), size); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapAccelerationStructureSizeAndAlign(const MTL::AccelerationStructureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heapAccelerationStructureSizeAndAlignWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapBufferSizeAndAlign(NS::UInteger length, MTL::ResourceOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heapBufferSizeAndAlignWithLength_options_), length, options); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::Device::heapTextureSizeAndAlign(const MTL::TextureDescriptor* desc) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heapTextureSizeAndAlignWithDescriptor_), desc); +} + +_MTL_INLINE bool MTL::Device::isDepth24Stencil8PixelFormatSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(isDepth24Stencil8PixelFormatSupported)); +} + +_MTL_INLINE bool MTL::Device::isHeadless() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isHeadless)); +} + +_MTL_INLINE bool MTL::Device::isLowPower() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isLowPower)); +} + +_MTL_INLINE bool MTL::Device::isRemovable() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRemovable)); +} + +_MTL_INLINE MTL::DeviceLocation MTL::Device::location() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(location)); +} + +_MTL_INLINE NS::UInteger MTL::Device::locationNumber() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(locationNumber)); +} + +_MTL_INLINE bool MTL::Device::lowPower() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isLowPower)); +} + +_MTL_INLINE NS::UInteger MTL::Device::maxArgumentBufferSamplerCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxArgumentBufferSamplerCount)); +} + +_MTL_INLINE NS::UInteger MTL::Device::maxBufferLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxBufferLength)); +} + +_MTL_INLINE NS::UInteger MTL::Device::maxThreadgroupMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxThreadgroupMemoryLength)); +} + +_MTL_INLINE MTL::Size MTL::Device::maxThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxThreadsPerThreadgroup)); +} + +_MTL_INLINE uint64_t MTL::Device::maxTransferRate() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTransferRate)); +} + +_MTL_INLINE NS::UInteger MTL::Device::maximumConcurrentCompilationTaskCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maximumConcurrentCompilationTaskCount)); +} + +_MTL_INLINE NS::UInteger MTL::Device::minimumLinearTextureAlignmentForPixelFormat(MTL::PixelFormat format) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(minimumLinearTextureAlignmentForPixelFormat_), format); +} + +_MTL_INLINE NS::UInteger MTL::Device::minimumTextureBufferAlignmentForPixelFormat(MTL::PixelFormat format) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(minimumTextureBufferAlignmentForPixelFormat_), format); +} + +_MTL_INLINE NS::String* MTL::Device::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Device::newAccelerationStructure(NS::UInteger size) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_), size); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Device::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL4::Archive* MTL::Device::newArchive(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArchiveWithURL_error_), url, error); +} + +_MTL_INLINE MTL::ArgumentEncoder* MTL::Device::newArgumentEncoder(const NS::Array* arguments) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithArguments_), arguments); +} + +_MTL_INLINE MTL::ArgumentEncoder* MTL::Device::newArgumentEncoder(const MTL::BufferBinding* bufferBinding) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferBinding_), bufferBinding); +} + +_MTL_INLINE MTL4::ArgumentTable* MTL::Device::newArgumentTable(const MTL4::ArgumentTableDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentTableWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::BinaryArchive* MTL::Device::newBinaryArchive(const MTL::BinaryArchiveDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBinaryArchiveWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(NS::UInteger length, MTL::ResourceOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_), length, options); +} + +_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithBytes_length_options_), pointer, length, options); +} + +_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(const void* pointer, NS::UInteger length, MTL::ResourceOptions options, void (^deallocator)(void*, NS::UInteger)) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithBytesNoCopy_length_options_deallocator_), pointer, length, options, deallocator); +} + +_MTL_INLINE MTL::Buffer* MTL::Device::newBuffer(NS::UInteger length, MTL::ResourceOptions options, MTL::SparsePageSize placementSparsePageSize) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_placementSparsePageSize_), length, options, placementSparsePageSize); +} + +_MTL_INLINE MTL4::CommandAllocator* MTL::Device::newCommandAllocator() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandAllocator)); +} + +_MTL_INLINE MTL4::CommandAllocator* MTL::Device::newCommandAllocator(const MTL4::CommandAllocatorDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandAllocatorWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL4::CommandBuffer* MTL::Device::newCommandBuffer() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandBuffer)); +} + +_MTL_INLINE MTL::CommandQueue* MTL::Device::newCommandQueue() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandQueue)); +} + +_MTL_INLINE MTL::CommandQueue* MTL::Device::newCommandQueue(NS::UInteger maxCommandBufferCount) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandQueueWithMaxCommandBufferCount_), maxCommandBufferCount); +} + +_MTL_INLINE MTL::CommandQueue* MTL::Device::newCommandQueue(const MTL::CommandQueueDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCommandQueueWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL4::Compiler* MTL::Device::newCompiler(const MTL4::CompilerDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCompilerWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_error_), computeFunction, error); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_options_reflection_error_), computeFunction, options, reflection, error); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, const MTL::NewComputePipelineStateCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_completionHandler_), computeFunction, completionHandler); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* computeFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithFunction_options_completionHandler_), computeFunction, options, completionHandler); +} + +_MTL_INLINE MTL::ComputePipelineState* MTL::Device::newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedComputePipelineReflection* reflection, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_options_reflection_error_), descriptor, options, reflection, error); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::ComputePipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newComputePipelineStateWithDescriptor_options_completionHandler_), descriptor, options, completionHandler); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* pFunction, const MTL::NewComputePipelineStateCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewComputePipelineStateCompletionHandlerFunction blockCompletionHandler = completionHandler; + newComputePipelineState(pFunction, ^(MTL::ComputePipelineState* pPipelineState, NS::Error* pError) { blockCompletionHandler(pPipelineState, pError); }); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::Function* pFunction, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewComputePipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newComputePipelineState(pFunction, options, ^(MTL::ComputePipelineState* pPipelineState, MTL::ComputePipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); }); +} + +_MTL_INLINE void MTL::Device::newComputePipelineState(const MTL::ComputePipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewComputePipelineStateWithReflectionCompletionHandlerFunction& completionHandler) +{ + __block NewComputePipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newComputePipelineState(pDescriptor, options, ^(ComputePipelineState* pPipelineState, ComputePipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); }); +} + +_MTL_INLINE MTL4::CounterHeap* MTL::Device::newCounterHeap(const MTL4::CounterHeapDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCounterHeapWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::Device::newCounterSampleBuffer(const MTL::CounterSampleBufferDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newCounterSampleBufferWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::Library* MTL::Device::newDefaultLibrary() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDefaultLibrary)); +} + +_MTL_INLINE MTL::Library* MTL::Device::newDefaultLibrary(const NS::Bundle* bundle, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDefaultLibraryWithBundle_error_), bundle, error); +} + +_MTL_INLINE MTL::DepthStencilState* MTL::Device::newDepthStencilState(const MTL::DepthStencilDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDepthStencilStateWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::DynamicLibrary* MTL::Device::newDynamicLibrary(const MTL::Library* library, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibrary_error_), library, error); +} + +_MTL_INLINE MTL::DynamicLibrary* MTL::Device::newDynamicLibrary(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newDynamicLibraryWithURL_error_), url, error); +} + +_MTL_INLINE MTL::Event* MTL::Device::newEvent() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newEvent)); +} + +_MTL_INLINE MTL::Fence* MTL::Device::newFence() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newFence)); +} + +_MTL_INLINE MTL::Heap* MTL::Device::newHeap(const MTL::HeapDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newHeapWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::IOCommandQueue* MTL::Device::newIOCommandQueue(const MTL::IOCommandQueueDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIOCommandQueueWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOFileHandle(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIOFileHandleWithURL_error_), url, error); +} + +_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOFileHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIOFileHandleWithURL_compressionMethod_error_), url, compressionMethod, error); +} + +_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOHandle(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIOHandleWithURL_error_), url, error); +} + +_MTL_INLINE MTL::IOFileHandle* MTL::Device::newIOHandle(const NS::URL* url, MTL::IOCompressionMethod compressionMethod, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIOHandleWithURL_compressionMethod_error_), url, compressionMethod, error); +} + +_MTL_INLINE MTL::IndirectCommandBuffer* MTL::Device::newIndirectCommandBuffer(const MTL::IndirectCommandBufferDescriptor* descriptor, NS::UInteger maxCount, MTL::ResourceOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIndirectCommandBufferWithDescriptor_maxCommandCount_options_), descriptor, maxCount, options); +} + +_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::String* filepath, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithFile_error_), filepath, error); +} + +_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithURL_error_), url, error); +} + +_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const dispatch_data_t data, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithData_error_), data, error); +} + +_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const NS::String* source, const MTL::CompileOptions* options, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithSource_options_error_), source, options, error); +} + +_MTL_INLINE void MTL::Device::newLibrary(const NS::String* source, const MTL::CompileOptions* options, const MTL::NewLibraryCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithSource_options_completionHandler_), source, options, completionHandler); +} + +_MTL_INLINE MTL::Library* MTL::Device::newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithStitchedDescriptor_error_), descriptor, error); +} + +_MTL_INLINE void MTL::Device::newLibrary(const MTL::StitchedLibraryDescriptor* descriptor, const MTL::NewLibraryCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newLibraryWithStitchedDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE void MTL::Device::newLibrary(const NS::String* pSource, const MTL::CompileOptions* pOptions, const MTL::NewLibraryCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewLibraryCompletionHandlerFunction blockCompletionHandler = completionHandler; + newLibrary(pSource, pOptions, ^(MTL::Library* pLibrary, NS::Error* pError) { blockCompletionHandler(pLibrary, pError); }); +} + +_MTL_INLINE void MTL::Device::newLibrary(const MTL::StitchedLibraryDescriptor* pDescriptor, const MTL::NewLibraryCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewLibraryCompletionHandlerFunction blockCompletionHandler = completionHandler; + newLibrary(pDescriptor, ^(MTL::Library* pLibrary, NS::Error* pError) { blockCompletionHandler(pLibrary, pError); }); +} + +_MTL_INLINE MTL::LogState* MTL::Device::newLogState(const MTL::LogStateDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newLogStateWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL4::CommandQueue* MTL::Device::newMTL4CommandQueue() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newMTL4CommandQueue)); +} + +_MTL_INLINE MTL4::CommandQueue* MTL::Device::newMTL4CommandQueue(const MTL4::CommandQueueDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newMTL4CommandQueueWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL4::PipelineDataSetSerializer* MTL::Device::newPipelineDataSetSerializer(const MTL4::PipelineDataSetSerializerDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newPipelineDataSetSerializerWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::RasterizationRateMap* MTL::Device::newRasterizationRateMap(const MTL::RasterizationRateMapDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRasterizationRateMapWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_options_reflection_error_), descriptor, options, reflection, error); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, const MTL::NewRenderPipelineStateCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithDescriptor_options_completionHandler_), descriptor, options, completionHandler); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithTileDescriptor_options_reflection_error_), descriptor, options, reflection, error); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithTileDescriptor_options_completionHandler_), descriptor, options, completionHandler); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::Device::newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::AutoreleasedRenderPipelineReflection* reflection, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithMeshDescriptor_options_reflection_error_), descriptor, options, reflection, error); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::MeshRenderPipelineDescriptor* descriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandler completionHandler) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithMeshDescriptor_options_completionHandler_), descriptor, options, completionHandler); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* pDescriptor, const MTL::NewRenderPipelineStateCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewRenderPipelineStateCompletionHandlerFunction blockCompletionHandler = completionHandler; + newRenderPipelineState(pDescriptor, ^(MTL::RenderPipelineState* pPipelineState, NS::Error* pError) { blockCompletionHandler(pPipelineState, pError); }); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::RenderPipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newRenderPipelineState(pDescriptor, options, ^(MTL::RenderPipelineState* pPipelineState, MTL::RenderPipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); }); +} + +_MTL_INLINE void MTL::Device::newRenderPipelineState(const MTL::TileRenderPipelineDescriptor* pDescriptor, MTL::PipelineOption options, const MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction& completionHandler) +{ + __block MTL::NewRenderPipelineStateWithReflectionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newRenderPipelineState(pDescriptor, options, ^(MTL::RenderPipelineState* pPipelineState, MTL::RenderPipelineReflection* pReflection, NS::Error* pError) { blockCompletionHandler(pPipelineState, pReflection, pError); }); +} + +_MTL_INLINE MTL::ResidencySet* MTL::Device::newResidencySet(const MTL::ResidencySetDescriptor* desc, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newResidencySetWithDescriptor_error_), desc, error); +} + +_MTL_INLINE MTL::SamplerState* MTL::Device::newSamplerState(const MTL::SamplerDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSamplerStateWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::SharedEvent* MTL::Device::newSharedEvent() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedEvent)); +} + +_MTL_INLINE MTL::SharedEvent* MTL::Device::newSharedEvent(const MTL::SharedEventHandle* sharedEventHandle) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedEventWithHandle_), sharedEventHandle); +} + +_MTL_INLINE MTL::Texture* MTL::Device::newSharedTexture(const MTL::TextureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedTextureWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::Texture* MTL::Device::newSharedTexture(const MTL::SharedTextureHandle* sharedHandle) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedTextureWithHandle_), sharedHandle); +} + +_MTL_INLINE MTL::Tensor* MTL::Device::newTensor(const MTL::TensorDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTensorWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE MTL::Texture* MTL::Device::newTexture(const MTL::TextureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::Texture* MTL::Device::newTexture(const MTL::TextureDescriptor* descriptor, const IOSurfaceRef iosurface, NS::UInteger plane) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_iosurface_plane_), descriptor, iosurface, plane); +} + +_MTL_INLINE MTL::TextureViewPool* MTL::Device::newTextureViewPool(const MTL::ResourceViewPoolDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureViewPoolWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE uint32_t MTL::Device::peerCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(peerCount)); +} + +_MTL_INLINE uint64_t MTL::Device::peerGroupID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(peerGroupID)); +} + +_MTL_INLINE uint32_t MTL::Device::peerIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(peerIndex)); +} + +_MTL_INLINE bool MTL::Device::programmableSamplePositionsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areProgrammableSamplePositionsSupported)); +} + +_MTL_INLINE uint64_t MTL::Device::queryTimestampFrequency() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(queryTimestampFrequency)); +} + +_MTL_INLINE bool MTL::Device::rasterOrderGroupsSupported() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(areRasterOrderGroupsSupported)); +} + +_MTL_INLINE MTL::ReadWriteTextureTier MTL::Device::readWriteTextureSupport() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(readWriteTextureSupport)); +} + +_MTL_INLINE uint64_t MTL::Device::recommendedMaxWorkingSetSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(recommendedMaxWorkingSetSize)); +} + +_MTL_INLINE uint64_t MTL::Device::registryID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(registryID)); +} + +_MTL_INLINE bool MTL::Device::removable() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRemovable)); +} + +_MTL_INLINE void MTL::Device::sampleTimestamps(MTL::Timestamp* cpuTimestamp, MTL::Timestamp* gpuTimestamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleTimestamps_gpuTimestamp_), cpuTimestamp, gpuTimestamp); +} + +_MTL_INLINE void MTL::Device::setShouldMaximizeConcurrentCompilation(bool shouldMaximizeConcurrentCompilation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShouldMaximizeConcurrentCompilation_), shouldMaximizeConcurrentCompilation); +} + +_MTL_INLINE bool MTL::Device::shouldMaximizeConcurrentCompilation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shouldMaximizeConcurrentCompilation)); +} + +_MTL_INLINE NS::UInteger MTL::Device::sizeOfCounterHeapEntry(MTL4::CounterHeapType type) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sizeOfCounterHeapEntry_), type); +} + +_MTL_INLINE MTL::Size MTL::Device::sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_), textureType, pixelFormat, sampleCount); +} + +_MTL_INLINE MTL::Size MTL::Device::sparseTileSize(MTL::TextureType textureType, MTL::PixelFormat pixelFormat, NS::UInteger sampleCount, MTL::SparsePageSize sparsePageSize) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_sparsePageSize_), textureType, pixelFormat, sampleCount, sparsePageSize); +} + +_MTL_INLINE NS::UInteger MTL::Device::sparseTileSizeInBytes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseTileSizeInBytes)); +} + +_MTL_INLINE NS::UInteger MTL::Device::sparseTileSizeInBytes(MTL::SparsePageSize sparsePageSize) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseTileSizeInBytesForSparsePageSize_), sparsePageSize); +} + +_MTL_INLINE bool MTL::Device::supports32BitFloatFiltering() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supports32BitFloatFiltering)); +} + +_MTL_INLINE bool MTL::Device::supports32BitMSAA() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supports32BitMSAA)); +} + +_MTL_INLINE bool MTL::Device::supportsBCTextureCompression() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsBCTextureCompression)); +} + +_MTL_INLINE bool MTL::Device::supportsCounterSampling(MTL::CounterSamplingPoint samplingPoint) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsCounterSampling_), samplingPoint); +} + +_MTL_INLINE bool MTL::Device::supportsDynamicLibraries() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsDynamicLibraries)); +} + +_MTL_INLINE bool MTL::Device::supportsFamily(MTL::GPUFamily gpuFamily) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsFamily_), gpuFamily); +} + +_MTL_INLINE bool MTL::Device::supportsFeatureSet(MTL::FeatureSet featureSet) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsFeatureSet_), featureSet); +} + +_MTL_INLINE bool MTL::Device::supportsFunctionPointers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsFunctionPointers)); +} + +_MTL_INLINE bool MTL::Device::supportsFunctionPointersFromRender() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsFunctionPointersFromRender)); +} + +_MTL_INLINE bool MTL::Device::supportsPrimitiveMotionBlur() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsPrimitiveMotionBlur)); +} + +_MTL_INLINE bool MTL::Device::supportsPullModelInterpolation() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsPullModelInterpolation)); +} + +_MTL_INLINE bool MTL::Device::supportsQueryTextureLOD() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsQueryTextureLOD)); +} + +_MTL_INLINE bool MTL::Device::supportsRasterizationRateMap(NS::UInteger layerCount) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsRasterizationRateMapWithLayerCount_), layerCount); +} + +_MTL_INLINE bool MTL::Device::supportsRaytracing() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsRaytracing)); +} + +_MTL_INLINE bool MTL::Device::supportsRaytracingFromRender() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsRaytracingFromRender)); +} + +_MTL_INLINE bool MTL::Device::supportsRenderDynamicLibraries() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsRenderDynamicLibraries)); +} + +_MTL_INLINE bool MTL::Device::supportsShaderBarycentricCoordinates() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsShaderBarycentricCoordinates)); +} + +_MTL_INLINE bool MTL::Device::supportsTextureSampleCount(NS::UInteger sampleCount) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsTextureSampleCount_), sampleCount); +} + +_MTL_INLINE bool MTL::Device::supportsVertexAmplificationCount(NS::UInteger count) +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportsVertexAmplificationCount_), count); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::Device::tensorSizeAndAlign(const MTL::TensorDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tensorSizeAndAlignWithDescriptor_), descriptor); +} diff --git a/thirdparty/metal-cpp/Metal/MTLDrawable.hpp b/thirdparty/metal-cpp/Metal/MTLDrawable.hpp new file mode 100644 index 0000000000..fad4feda98 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDrawable.hpp @@ -0,0 +1,90 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDrawable.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +#include +#include + +namespace MTL +{ +class Drawable; + +using DrawablePresentedHandler = void (^)(MTL::Drawable*); +using DrawablePresentedHandlerFunction = std::function; + +class Drawable : public NS::Referencing +{ +public: + void addPresentedHandler(const MTL::DrawablePresentedHandler block); + void addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function); + + NS::UInteger drawableID() const; + + void present(); + void presentAfterMinimumDuration(CFTimeInterval duration); + + void presentAtTime(CFTimeInterval presentationTime); + + CFTimeInterval presentedTime() const; +}; + +} +_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandler block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addPresentedHandler_), block); +} + +_MTL_INLINE void MTL::Drawable::addPresentedHandler(const MTL::DrawablePresentedHandlerFunction& function) +{ + __block DrawablePresentedHandlerFunction blockFunction = function; + addPresentedHandler(^(Drawable* pDrawable) { blockFunction(pDrawable); }); +} + +_MTL_INLINE NS::UInteger MTL::Drawable::drawableID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(drawableID)); +} + +_MTL_INLINE void MTL::Drawable::present() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(present)); +} + +_MTL_INLINE void MTL::Drawable::presentAfterMinimumDuration(CFTimeInterval duration) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(presentAfterMinimumDuration_), duration); +} + +_MTL_INLINE void MTL::Drawable::presentAtTime(CFTimeInterval presentationTime) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(presentAtTime_), presentationTime); +} + +_MTL_INLINE CFTimeInterval MTL::Drawable::presentedTime() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(presentedTime)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLDynamicLibrary.hpp b/thirdparty/metal-cpp/Metal/MTLDynamicLibrary.hpp new file mode 100644 index 0000000000..0726acc1b8 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLDynamicLibrary.hpp @@ -0,0 +1,78 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLDynamicLibrary.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Device; +_MTL_ENUM(NS::UInteger, DynamicLibraryError) { + DynamicLibraryErrorNone = 0, + DynamicLibraryErrorInvalidFile = 1, + DynamicLibraryErrorCompilationFailure = 2, + DynamicLibraryErrorUnresolvedInstallName = 3, + DynamicLibraryErrorDependencyLoadFailure = 4, + DynamicLibraryErrorUnsupported = 5, +}; + +class DynamicLibrary : public NS::Referencing +{ +public: + Device* device() const; + + NS::String* installName() const; + + NS::String* label() const; + + bool serializeToURL(const NS::URL* url, NS::Error** error); + + void setLabel(const NS::String* label); +}; + +} +_MTL_INLINE MTL::Device* MTL::DynamicLibrary::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::DynamicLibrary::installName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(installName)); +} + +_MTL_INLINE NS::String* MTL::DynamicLibrary::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE bool MTL::DynamicLibrary::serializeToURL(const NS::URL* url, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(serializeToURL_error_), url, error); +} + +_MTL_INLINE void MTL::DynamicLibrary::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTLEvent.hpp b/thirdparty/metal-cpp/Metal/MTLEvent.hpp new file mode 100644 index 0000000000..d06b969342 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLEvent.hpp @@ -0,0 +1,170 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLEvent.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include +#include + +#include +#include + +namespace MTL +{ +class Device; +class SharedEvent; +class SharedEventHandle; +class SharedEventListener; + +using SharedEventNotificationBlock = void (^)(SharedEvent* pEvent, std::uint64_t value); +using SharedEventNotificationFunction = std::function; + +class Event : public NS::Referencing +{ +public: + Device* device() const; + + NS::String* label() const; + void setLabel(const NS::String* label); +}; +class SharedEventListener : public NS::Referencing +{ +public: + static SharedEventListener* alloc(); + + dispatch_queue_t dispatchQueue() const; + + SharedEventListener* init(); + SharedEventListener* init(const dispatch_queue_t dispatchQueue); + + static SharedEventListener* sharedListener(); +}; +class SharedEvent : public NS::Referencing +{ +public: + SharedEventHandle* newSharedEventHandle(); + + void notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block); + void notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationFunction& function); + + void setSignaledValue(uint64_t signaledValue); + uint64_t signaledValue() const; + bool waitUntilSignaledValue(uint64_t value, uint64_t milliseconds); +}; +class SharedEventHandle : public NS::SecureCoding +{ +public: + static SharedEventHandle* alloc(); + + SharedEventHandle* init(); + + NS::String* label() const; +}; + +} +_MTL_INLINE MTL::Device* MTL::Event::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::Event::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::Event::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLSharedEventListener)); +} + +_MTL_INLINE dispatch_queue_t MTL::SharedEventListener::dispatchQueue() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchQueue)); +} + +_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::init(const dispatch_queue_t dispatchQueue) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithDispatchQueue_), dispatchQueue); +} + +_MTL_INLINE MTL::SharedEventListener* MTL::SharedEventListener::sharedListener() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLSharedEventListener), _MTL_PRIVATE_SEL(sharedListener)); +} + +_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEvent::newSharedEventHandle() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedEventHandle)); +} + +_MTL_INLINE void MTL::SharedEvent::notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationBlock block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(notifyListener_atValue_block_), listener, value, block); +} + +_MTL_INLINE void MTL::SharedEvent::notifyListener(const MTL::SharedEventListener* listener, uint64_t value, const MTL::SharedEventNotificationFunction& function) +{ + __block MTL::SharedEventNotificationFunction callback = function; + notifyListener(listener, value, ^void(SharedEvent* pEvent, std::uint64_t innerValue) { callback(pEvent, innerValue); }); +} + +_MTL_INLINE void MTL::SharedEvent::setSignaledValue(uint64_t signaledValue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSignaledValue_), signaledValue); +} + +_MTL_INLINE uint64_t MTL::SharedEvent::signaledValue() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(signaledValue)); +} + +_MTL_INLINE bool MTL::SharedEvent::waitUntilSignaledValue(uint64_t value, uint64_t milliseconds) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(waitUntilSignaledValue_timeoutMS_), value, milliseconds); +} + +_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLSharedEventHandle)); +} + +_MTL_INLINE MTL::SharedEventHandle* MTL::SharedEventHandle::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::SharedEventHandle::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFence.hpp b/thirdparty/metal-cpp/Metal/MTLFence.hpp new file mode 100644 index 0000000000..f31df4ce8c --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFence.hpp @@ -0,0 +1,55 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFence.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Device; + +class Fence : public NS::Referencing +{ +public: + Device* device() const; + + NS::String* label() const; + void setLabel(const NS::String* label); +}; + +} +_MTL_INLINE MTL::Device* MTL::Fence::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::Fence::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::Fence::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFunctionConstantValues.hpp b/thirdparty/metal-cpp/Metal/MTLFunctionConstantValues.hpp new file mode 100644 index 0000000000..dce89d15f7 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFunctionConstantValues.hpp @@ -0,0 +1,76 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFunctionConstantValues.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDataType.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class FunctionConstantValues; + +class FunctionConstantValues : public NS::Copying +{ +public: + static FunctionConstantValues* alloc(); + + FunctionConstantValues* init(); + + void reset(); + + void setConstantValue(const void* value, MTL::DataType type, NS::UInteger index); + void setConstantValue(const void* value, MTL::DataType type, const NS::String* name); + void setConstantValues(const void* values, MTL::DataType type, NS::Range range); +}; + +} +_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionConstantValues)); +} + +_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionConstantValues::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::FunctionConstantValues::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantValue_type_atIndex_), value, type, index); +} + +_MTL_INLINE void MTL::FunctionConstantValues::setConstantValue(const void* value, MTL::DataType type, const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantValue_type_withName_), value, type, name); +} + +_MTL_INLINE void MTL::FunctionConstantValues::setConstantValues(const void* values, MTL::DataType type, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantValues_type_withRange_), values, type, range); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFunctionDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTLFunctionDescriptor.hpp new file mode 100644 index 0000000000..aa296b5ce7 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFunctionDescriptor.hpp @@ -0,0 +1,153 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFunctionDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class FunctionConstantValues; +class FunctionDescriptor; +class IntersectionFunctionDescriptor; + +_MTL_OPTIONS(NS::UInteger, FunctionOptions) { + FunctionOptionNone = 0, + FunctionOptionCompileToBinary = 1, + FunctionOptionStoreFunctionInMetalPipelinesScript = 1 << 1, + FunctionOptionStoreFunctionInMetalScript = 1 << 1, + FunctionOptionFailOnBinaryArchiveMiss = 1 << 2, + FunctionOptionPipelineIndependent = 1 << 3, +}; + +class FunctionDescriptor : public NS::Copying +{ +public: + static FunctionDescriptor* alloc(); + + NS::Array* binaryArchives() const; + + FunctionConstantValues* constantValues() const; + + static FunctionDescriptor* functionDescriptor(); + + FunctionDescriptor* init(); + + NS::String* name() const; + + FunctionOptions options() const; + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setConstantValues(const MTL::FunctionConstantValues* constantValues); + + void setName(const NS::String* name); + + void setOptions(MTL::FunctionOptions options); + + void setSpecializedName(const NS::String* specializedName); + NS::String* specializedName() const; +}; +class IntersectionFunctionDescriptor : public NS::Copying +{ +public: + static IntersectionFunctionDescriptor* alloc(); + + IntersectionFunctionDescriptor* init(); +}; + +} +_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::FunctionDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE MTL::FunctionConstantValues* MTL::FunctionDescriptor::constantValues() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(constantValues)); +} + +_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::functionDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLFunctionDescriptor), _MTL_PRIVATE_SEL(functionDescriptor)); +} + +_MTL_INLINE MTL::FunctionDescriptor* MTL::FunctionDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::FunctionDescriptor::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::FunctionOptions MTL::FunctionDescriptor::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE void MTL::FunctionDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::FunctionDescriptor::setConstantValues(const MTL::FunctionConstantValues* constantValues) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setConstantValues_), constantValues); +} + +_MTL_INLINE void MTL::FunctionDescriptor::setName(const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setName_), name); +} + +_MTL_INLINE void MTL::FunctionDescriptor::setOptions(MTL::FunctionOptions options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptions_), options); +} + +_MTL_INLINE void MTL::FunctionDescriptor::setSpecializedName(const NS::String* specializedName) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSpecializedName_), specializedName); +} + +_MTL_INLINE NS::String* MTL::FunctionDescriptor::specializedName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(specializedName)); +} + +_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLIntersectionFunctionDescriptor)); +} + +_MTL_INLINE MTL::IntersectionFunctionDescriptor* MTL::IntersectionFunctionDescriptor::init() +{ + return NS::Object::init(); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFunctionHandle.hpp b/thirdparty/metal-cpp/Metal/MTLFunctionHandle.hpp new file mode 100644 index 0000000000..7a3ff95d6c --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFunctionHandle.hpp @@ -0,0 +1,65 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFunctionHandle.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLLibrary.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Device; + +class FunctionHandle : public NS::Referencing +{ +public: + Device* device() const; + + FunctionType functionType() const; + + ResourceID gpuResourceID() const; + + NS::String* name() const; +}; + +} +_MTL_INLINE MTL::Device* MTL::FunctionHandle::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::FunctionType MTL::FunctionHandle::functionType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionType)); +} + +_MTL_INLINE MTL::ResourceID MTL::FunctionHandle::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::String* MTL::FunctionHandle::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFunctionLog.hpp b/thirdparty/metal-cpp/Metal/MTLFunctionLog.hpp new file mode 100644 index 0000000000..454e60585f --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFunctionLog.hpp @@ -0,0 +1,101 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFunctionLog.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Function; +class FunctionLogDebugLocation; +_MTL_ENUM(NS::UInteger, FunctionLogType) { + FunctionLogTypeValidation = 0, +}; + +class LogContainer : public NS::Referencing +{ +}; +class FunctionLogDebugLocation : public NS::Referencing +{ +public: + NS::URL* URL() const; + + NS::UInteger column() const; + + NS::String* functionName() const; + + NS::UInteger line() const; +}; +class FunctionLog : public NS::Referencing +{ +public: + FunctionLogDebugLocation* debugLocation() const; + + NS::String* encoderLabel() const; + + Function* function() const; + + FunctionLogType type() const; +}; + +} +_MTL_INLINE NS::URL* MTL::FunctionLogDebugLocation::URL() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(URL)); +} + +_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::column() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(column)); +} + +_MTL_INLINE NS::String* MTL::FunctionLogDebugLocation::functionName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionName)); +} + +_MTL_INLINE NS::UInteger MTL::FunctionLogDebugLocation::line() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(line)); +} + +_MTL_INLINE MTL::FunctionLogDebugLocation* MTL::FunctionLog::debugLocation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(debugLocation)); +} + +_MTL_INLINE NS::String* MTL::FunctionLog::encoderLabel() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(encoderLabel)); +} + +_MTL_INLINE MTL::Function* MTL::FunctionLog::function() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(function)); +} + +_MTL_INLINE MTL::FunctionLogType MTL::FunctionLog::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLFunctionStitching.hpp b/thirdparty/metal-cpp/Metal/MTLFunctionStitching.hpp new file mode 100644 index 0000000000..8dd5fd2902 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLFunctionStitching.hpp @@ -0,0 +1,319 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLFunctionStitching.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class FunctionStitchingAttributeAlwaysInline; +class FunctionStitchingFunctionNode; +class FunctionStitchingGraph; +class FunctionStitchingInputNode; +class StitchedLibraryDescriptor; + +_MTL_OPTIONS(NS::UInteger, StitchedLibraryOptions) { + StitchedLibraryOptionNone = 0, + StitchedLibraryOptionFailOnBinaryArchiveMiss = 1, + StitchedLibraryOptionStoreLibraryInMetalPipelinesScript = 1 << 1, +}; + +class FunctionStitchingAttribute : public NS::Referencing +{ +}; +class FunctionStitchingAttributeAlwaysInline : public NS::Referencing +{ +public: + static FunctionStitchingAttributeAlwaysInline* alloc(); + + FunctionStitchingAttributeAlwaysInline* init(); +}; +class FunctionStitchingNode : public NS::Copying +{ +}; +class FunctionStitchingInputNode : public NS::Referencing +{ +public: + static FunctionStitchingInputNode* alloc(); + + NS::UInteger argumentIndex() const; + + FunctionStitchingInputNode* init(); + FunctionStitchingInputNode* init(NS::UInteger argument); + + void setArgumentIndex(NS::UInteger argumentIndex); +}; +class FunctionStitchingFunctionNode : public NS::Referencing +{ +public: + static FunctionStitchingFunctionNode* alloc(); + + NS::Array* arguments() const; + + NS::Array* controlDependencies() const; + + FunctionStitchingFunctionNode* init(); + FunctionStitchingFunctionNode* init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies); + + NS::String* name() const; + + void setArguments(const NS::Array* arguments); + + void setControlDependencies(const NS::Array* controlDependencies); + + void setName(const NS::String* name); +}; +class FunctionStitchingGraph : public NS::Copying +{ +public: + static FunctionStitchingGraph* alloc(); + + NS::Array* attributes() const; + + NS::String* functionName() const; + + FunctionStitchingGraph* init(); + FunctionStitchingGraph* init(const NS::String* functionName, const NS::Array* nodes, const MTL::FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes); + + NS::Array* nodes() const; + + FunctionStitchingFunctionNode* outputNode() const; + + void setAttributes(const NS::Array* attributes); + + void setFunctionName(const NS::String* functionName); + + void setNodes(const NS::Array* nodes); + + void setOutputNode(const MTL::FunctionStitchingFunctionNode* outputNode); +}; +class StitchedLibraryDescriptor : public NS::Copying +{ +public: + static StitchedLibraryDescriptor* alloc(); + + NS::Array* binaryArchives() const; + + NS::Array* functionGraphs() const; + + NS::Array* functions() const; + + StitchedLibraryDescriptor* init(); + + StitchedLibraryOptions options() const; + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setFunctionGraphs(const NS::Array* functionGraphs); + + void setFunctions(const NS::Array* functions); + + void setOptions(MTL::StitchedLibraryOptions options); +}; + +} +_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionStitchingAttributeAlwaysInline)); +} + +_MTL_INLINE MTL::FunctionStitchingAttributeAlwaysInline* MTL::FunctionStitchingAttributeAlwaysInline::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionStitchingInputNode)); +} + +_MTL_INLINE NS::UInteger MTL::FunctionStitchingInputNode::argumentIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(argumentIndex)); +} + +_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::FunctionStitchingInputNode* MTL::FunctionStitchingInputNode::init(NS::UInteger argument) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithArgumentIndex_), argument); +} + +_MTL_INLINE void MTL::FunctionStitchingInputNode::setArgumentIndex(NS::UInteger argumentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArgumentIndex_), argumentIndex); +} + +_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionStitchingFunctionNode)); +} + +_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::arguments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arguments)); +} + +_MTL_INLINE NS::Array* MTL::FunctionStitchingFunctionNode::controlDependencies() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(controlDependencies)); +} + +_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingFunctionNode::init(const NS::String* name, const NS::Array* arguments, const NS::Array* controlDependencies) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithName_arguments_controlDependencies_), name, arguments, controlDependencies); +} + +_MTL_INLINE NS::String* MTL::FunctionStitchingFunctionNode::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setArguments(const NS::Array* arguments) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArguments_), arguments); +} + +_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setControlDependencies(const NS::Array* controlDependencies) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setControlDependencies_), controlDependencies); +} + +_MTL_INLINE void MTL::FunctionStitchingFunctionNode::setName(const NS::String* name) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setName_), name); +} + +_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionStitchingGraph)); +} + +_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::attributes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributes)); +} + +_MTL_INLINE NS::String* MTL::FunctionStitchingGraph::functionName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionName)); +} + +_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::FunctionStitchingGraph* MTL::FunctionStitchingGraph::init(const NS::String* functionName, const NS::Array* nodes, const MTL::FunctionStitchingFunctionNode* outputNode, const NS::Array* attributes) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithFunctionName_nodes_outputNode_attributes_), functionName, nodes, outputNode, attributes); +} + +_MTL_INLINE NS::Array* MTL::FunctionStitchingGraph::nodes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(nodes)); +} + +_MTL_INLINE MTL::FunctionStitchingFunctionNode* MTL::FunctionStitchingGraph::outputNode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(outputNode)); +} + +_MTL_INLINE void MTL::FunctionStitchingGraph::setAttributes(const NS::Array* attributes) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAttributes_), attributes); +} + +_MTL_INLINE void MTL::FunctionStitchingGraph::setFunctionName(const NS::String* functionName) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionName_), functionName); +} + +_MTL_INLINE void MTL::FunctionStitchingGraph::setNodes(const NS::Array* nodes) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setNodes_), nodes); +} + +_MTL_INLINE void MTL::FunctionStitchingGraph::setOutputNode(const MTL::FunctionStitchingFunctionNode* outputNode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOutputNode_), outputNode); +} + +_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLStitchedLibraryDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functionGraphs() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionGraphs)); +} + +_MTL_INLINE NS::Array* MTL::StitchedLibraryDescriptor::functions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functions)); +} + +_MTL_INLINE MTL::StitchedLibraryDescriptor* MTL::StitchedLibraryDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::StitchedLibraryOptions MTL::StitchedLibraryDescriptor::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE void MTL::StitchedLibraryDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctionGraphs(const NS::Array* functionGraphs) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionGraphs_), functionGraphs); +} + +_MTL_INLINE void MTL::StitchedLibraryDescriptor::setFunctions(const NS::Array* functions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctions_), functions); +} + +_MTL_INLINE void MTL::StitchedLibraryDescriptor::setOptions(MTL::StitchedLibraryOptions options) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptions_), options); +} diff --git a/thirdparty/metal-cpp/Metal/MTLGPUAddress.hpp b/thirdparty/metal-cpp/Metal/MTLGPUAddress.hpp new file mode 100644 index 0000000000..fb9d61d57b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLGPUAddress.hpp @@ -0,0 +1,36 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLGPUAddress.hpp +// +// Copyright 2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#ifdef __METAL_VERSION__ + +#include + +#else + +#include + +#endif // __METAL_VERSION__ + +namespace MTL +{ + using GPUAddress = uint64_t; +} diff --git a/thirdparty/metal-cpp/Metal/MTLHeaderBridge.hpp b/thirdparty/metal-cpp/Metal/MTLHeaderBridge.hpp new file mode 100644 index 0000000000..6a3a142234 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLHeaderBridge.hpp @@ -0,0 +1,3120 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLHeaderBridge.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once +#include "MTLPrivate.hpp" + +namespace MTL::Private::Class +{ + +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureBoundingBoxGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureCurveGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureMotionBoundingBoxGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureMotionCurveGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureMotionTriangleGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4AccelerationStructureTriangleGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4ArgumentTableDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4BinaryFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4CommandAllocatorDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4CommandBufferOptions); +_MTL_PRIVATE_DEF_CLS(MTL4CommandQueueDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4CommitOptions); +_MTL_PRIVATE_DEF_CLS(MTL4CompilerDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4CompilerTaskOptions); +_MTL_PRIVATE_DEF_CLS(MTL4ComputePipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4CounterHeapDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4FunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4IndirectInstanceAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4InstanceAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4LibraryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4LibraryFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4MachineLearningPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4MachineLearningPipelineReflection); +_MTL_PRIVATE_DEF_CLS(MTL4MeshRenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4PipelineDataSetSerializerDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4PipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4PipelineOptions); +_MTL_PRIVATE_DEF_CLS(MTL4PipelineStageDynamicLinkingDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4PrimitiveAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPipelineBinaryFunctionsDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPipelineColorAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPipelineColorAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4RenderPipelineDynamicLinkingDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4SpecializedFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4StaticLinkingDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4StitchedFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTL4TileRenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureCurveGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructurePassSampleBufferAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLAccelerationStructureTriangleGeometryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLArchitecture); +_MTL_PRIVATE_DEF_CLS(MTLArgument); +_MTL_PRIVATE_DEF_CLS(MTLArgumentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLArrayType); +_MTL_PRIVATE_DEF_CLS(MTLAttribute); +_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLAttributeDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLBinaryArchiveDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLBlitPassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLBlitPassSampleBufferAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLBufferLayoutDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLCaptureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLCaptureManager); +_MTL_PRIVATE_DEF_CLS(MTLCommandBufferDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLCommandQueueDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLCompileOptions); +_MTL_PRIVATE_DEF_CLS(MTLComputePassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLComputePassSampleBufferAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLComputePipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLComputePipelineReflection); +_MTL_PRIVATE_DEF_CLS(MTLCounterSampleBufferDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLDepthStencilDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLFunctionConstant); +_MTL_PRIVATE_DEF_CLS(MTLFunctionConstantValues); +_MTL_PRIVATE_DEF_CLS(MTLFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLFunctionReflection); +_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingAttributeAlwaysInline); +_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingFunctionNode); +_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingGraph); +_MTL_PRIVATE_DEF_CLS(MTLFunctionStitchingInputNode); +_MTL_PRIVATE_DEF_CLS(MTLHeapDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLIOCommandQueueDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLIndirectCommandBufferDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLIndirectInstanceAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLInstanceAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLIntersectionFunctionTableDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLLinkedFunctions); +_MTL_PRIVATE_DEF_CLS(MTLLogStateDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLLogicalToPhysicalColorAttachmentMap); +_MTL_PRIVATE_DEF_CLS(MTLMeshRenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLMotionKeyframeData); +_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLPipelineBufferDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLPointerType); +_MTL_PRIVATE_DEF_CLS(MTLPrimitiveAccelerationStructureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerArray); +_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateLayerDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateMapDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRasterizationRateSampleArray); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassColorAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassDepthAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLRenderPassStencilAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineColorAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineFunctionsDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLRenderPipelineReflection); +_MTL_PRIVATE_DEF_CLS(MTLResidencySetDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLResourceViewPoolDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLSamplerDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLSharedEventHandle); +_MTL_PRIVATE_DEF_CLS(MTLSharedEventListener); +_MTL_PRIVATE_DEF_CLS(MTLSharedTextureHandle); +_MTL_PRIVATE_DEF_CLS(MTLStageInputOutputDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLStencilDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLStitchedLibraryDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLStructMember); +_MTL_PRIVATE_DEF_CLS(MTLStructType); +_MTL_PRIVATE_DEF_CLS(MTLTensorDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLTensorExtents); +_MTL_PRIVATE_DEF_CLS(MTLTensorReferenceType); +_MTL_PRIVATE_DEF_CLS(MTLTextureDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLTextureReferenceType); +_MTL_PRIVATE_DEF_CLS(MTLTextureViewDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLTileRenderPipelineDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLType); +_MTL_PRIVATE_DEF_CLS(MTLVertexAttribute); +_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLVertexAttributeDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLVertexBufferLayoutDescriptorArray); +_MTL_PRIVATE_DEF_CLS(MTLVertexDescriptor); +_MTL_PRIVATE_DEF_CLS(MTLVisibleFunctionTableDescriptor); + +} + +namespace MTL::Private::Protocol +{ + +_MTL_PRIVATE_DEF_PRO(MTL4Archive); +_MTL_PRIVATE_DEF_PRO(MTL4ArgumentTable); +_MTL_PRIVATE_DEF_PRO(MTL4BinaryFunction); +_MTL_PRIVATE_DEF_PRO(MTL4CommandAllocator); +_MTL_PRIVATE_DEF_PRO(MTL4CommandBuffer); +_MTL_PRIVATE_DEF_PRO(MTL4CommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTL4CommandQueue); +_MTL_PRIVATE_DEF_PRO(MTL4CommitFeedback); +_MTL_PRIVATE_DEF_PRO(MTL4Compiler); +_MTL_PRIVATE_DEF_PRO(MTL4CompilerTask); +_MTL_PRIVATE_DEF_PRO(MTL4ComputeCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTL4CounterHeap); +_MTL_PRIVATE_DEF_PRO(MTL4MachineLearningCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTL4MachineLearningPipelineState); +_MTL_PRIVATE_DEF_PRO(MTL4PipelineDataSetSerializer); +_MTL_PRIVATE_DEF_PRO(MTL4RenderCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructure); +_MTL_PRIVATE_DEF_PRO(MTLAccelerationStructureCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLAllocation); +_MTL_PRIVATE_DEF_PRO(MTLArgumentEncoder); +_MTL_PRIVATE_DEF_PRO(MTLBinaryArchive); +_MTL_PRIVATE_DEF_PRO(MTLBinding); +_MTL_PRIVATE_DEF_PRO(MTLBlitCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLBuffer); +_MTL_PRIVATE_DEF_PRO(MTLBufferBinding); +_MTL_PRIVATE_DEF_PRO(MTLCommandBuffer); +_MTL_PRIVATE_DEF_PRO(MTLCommandBufferEncoderInfo); +_MTL_PRIVATE_DEF_PRO(MTLCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLCommandQueue); +_MTL_PRIVATE_DEF_PRO(MTLComputeCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLComputePipelineState); +_MTL_PRIVATE_DEF_PRO(MTLCounter); +_MTL_PRIVATE_DEF_PRO(MTLCounterSampleBuffer); +_MTL_PRIVATE_DEF_PRO(MTLCounterSet); +_MTL_PRIVATE_DEF_PRO(MTLDepthStencilState); +_MTL_PRIVATE_DEF_PRO(MTLDevice); +_MTL_PRIVATE_DEF_PRO(MTLDrawable); +_MTL_PRIVATE_DEF_PRO(MTLDynamicLibrary); +_MTL_PRIVATE_DEF_PRO(MTLEvent); +_MTL_PRIVATE_DEF_PRO(MTLFence); +_MTL_PRIVATE_DEF_PRO(MTLFunction); +_MTL_PRIVATE_DEF_PRO(MTLFunctionHandle); +_MTL_PRIVATE_DEF_PRO(MTLFunctionLog); +_MTL_PRIVATE_DEF_PRO(MTLFunctionLogDebugLocation); +_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingAttribute); +_MTL_PRIVATE_DEF_PRO(MTLFunctionStitchingNode); +_MTL_PRIVATE_DEF_PRO(MTLHeap); +_MTL_PRIVATE_DEF_PRO(MTLIOCommandBuffer); +_MTL_PRIVATE_DEF_PRO(MTLIOCommandQueue); +_MTL_PRIVATE_DEF_PRO(MTLIOFileHandle); +_MTL_PRIVATE_DEF_PRO(MTLIOScratchBuffer); +_MTL_PRIVATE_DEF_PRO(MTLIOScratchBufferAllocator); +_MTL_PRIVATE_DEF_PRO(MTLIndirectCommandBuffer); +_MTL_PRIVATE_DEF_PRO(MTLIndirectComputeCommand); +_MTL_PRIVATE_DEF_PRO(MTLIndirectRenderCommand); +_MTL_PRIVATE_DEF_PRO(MTLIntersectionFunctionTable); +_MTL_PRIVATE_DEF_PRO(MTLLibrary); +_MTL_PRIVATE_DEF_PRO(MTLLogContainer); +_MTL_PRIVATE_DEF_PRO(MTLLogState); +_MTL_PRIVATE_DEF_PRO(MTLObjectPayloadBinding); +_MTL_PRIVATE_DEF_PRO(MTLParallelRenderCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLRasterizationRateMap); +_MTL_PRIVATE_DEF_PRO(MTLRenderCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLRenderPipelineState); +_MTL_PRIVATE_DEF_PRO(MTLResidencySet); +_MTL_PRIVATE_DEF_PRO(MTLResource); +_MTL_PRIVATE_DEF_PRO(MTLResourceStateCommandEncoder); +_MTL_PRIVATE_DEF_PRO(MTLResourceViewPool); +_MTL_PRIVATE_DEF_PRO(MTLSamplerState); +_MTL_PRIVATE_DEF_PRO(MTLSharedEvent); +_MTL_PRIVATE_DEF_PRO(MTLTensor); +_MTL_PRIVATE_DEF_PRO(MTLTensorBinding); +_MTL_PRIVATE_DEF_PRO(MTLTexture); +_MTL_PRIVATE_DEF_PRO(MTLTextureBinding); +_MTL_PRIVATE_DEF_PRO(MTLTextureViewPool); +_MTL_PRIVATE_DEF_PRO(MTLThreadgroupBinding); +_MTL_PRIVATE_DEF_PRO(MTLVisibleFunctionTable); + +} + +namespace MTL::Private::Selector +{ + +_MTL_PRIVATE_DEF_SEL(GPUEndTime, + "GPUEndTime"); +_MTL_PRIVATE_DEF_SEL(GPUStartTime, + "GPUStartTime"); +_MTL_PRIVATE_DEF_SEL(URL, + "URL"); +_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoder, + "accelerationStructureCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(accelerationStructureCommandEncoderWithDescriptor_, + "accelerationStructureCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(accelerationStructurePassDescriptor, + "accelerationStructurePassDescriptor"); +_MTL_PRIVATE_DEF_SEL(accelerationStructureSizesWithDescriptor_, + "accelerationStructureSizesWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(access, + "access"); +_MTL_PRIVATE_DEF_SEL(addAllocation_, + "addAllocation:"); +_MTL_PRIVATE_DEF_SEL(addAllocations_count_, + "addAllocations:count:"); +_MTL_PRIVATE_DEF_SEL(addBarrier, + "addBarrier"); +_MTL_PRIVATE_DEF_SEL(addCompletedHandler_, + "addCompletedHandler:"); +_MTL_PRIVATE_DEF_SEL(addComputePipelineFunctionsWithDescriptor_error_, + "addComputePipelineFunctionsWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(addDebugMarker_range_, + "addDebugMarker:range:"); +_MTL_PRIVATE_DEF_SEL(addFeedbackHandler_, + "addFeedbackHandler:"); +_MTL_PRIVATE_DEF_SEL(addFunctionWithDescriptor_library_error_, + "addFunctionWithDescriptor:library:error:"); +_MTL_PRIVATE_DEF_SEL(addLibraryWithDescriptor_error_, + "addLibraryWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(addLogHandler_, + "addLogHandler:"); +_MTL_PRIVATE_DEF_SEL(addMeshRenderPipelineFunctionsWithDescriptor_error_, + "addMeshRenderPipelineFunctionsWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(addPresentedHandler_, + "addPresentedHandler:"); +_MTL_PRIVATE_DEF_SEL(addRenderPipelineFunctionsWithDescriptor_error_, + "addRenderPipelineFunctionsWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(addResidencySet_, + "addResidencySet:"); +_MTL_PRIVATE_DEF_SEL(addResidencySets_count_, + "addResidencySets:count:"); +_MTL_PRIVATE_DEF_SEL(addScheduledHandler_, + "addScheduledHandler:"); +_MTL_PRIVATE_DEF_SEL(addTileRenderPipelineFunctionsWithDescriptor_error_, + "addTileRenderPipelineFunctionsWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(alignment, + "alignment"); +_MTL_PRIVATE_DEF_SEL(allAllocations, + "allAllocations"); +_MTL_PRIVATE_DEF_SEL(allocatedSize, + "allocatedSize"); +_MTL_PRIVATE_DEF_SEL(allocationCount, + "allocationCount"); +_MTL_PRIVATE_DEF_SEL(allowDuplicateIntersectionFunctionInvocation, + "allowDuplicateIntersectionFunctionInvocation"); +_MTL_PRIVATE_DEF_SEL(allowGPUOptimizedContents, + "allowGPUOptimizedContents"); +_MTL_PRIVATE_DEF_SEL(allowReferencingUndefinedSymbols, + "allowReferencingUndefinedSymbols"); +_MTL_PRIVATE_DEF_SEL(alphaBlendOperation, + "alphaBlendOperation"); +_MTL_PRIVATE_DEF_SEL(alphaToCoverageState, + "alphaToCoverageState"); +_MTL_PRIVATE_DEF_SEL(alphaToOneState, + "alphaToOneState"); +_MTL_PRIVATE_DEF_SEL(architecture, + "architecture"); +_MTL_PRIVATE_DEF_SEL(areBarycentricCoordsSupported, + "areBarycentricCoordsSupported"); +_MTL_PRIVATE_DEF_SEL(areProgrammableSamplePositionsSupported, + "areProgrammableSamplePositionsSupported"); +_MTL_PRIVATE_DEF_SEL(areRasterOrderGroupsSupported, + "areRasterOrderGroupsSupported"); +_MTL_PRIVATE_DEF_SEL(argumentBuffersSupport, + "argumentBuffersSupport"); +_MTL_PRIVATE_DEF_SEL(argumentDescriptor, + "argumentDescriptor"); +_MTL_PRIVATE_DEF_SEL(argumentIndex, + "argumentIndex"); +_MTL_PRIVATE_DEF_SEL(argumentIndexStride, + "argumentIndexStride"); +_MTL_PRIVATE_DEF_SEL(arguments, + "arguments"); +_MTL_PRIVATE_DEF_SEL(arrayLength, + "arrayLength"); +_MTL_PRIVATE_DEF_SEL(arrayType, + "arrayType"); +_MTL_PRIVATE_DEF_SEL(attributeIndex, + "attributeIndex"); +_MTL_PRIVATE_DEF_SEL(attributeType, + "attributeType"); +_MTL_PRIVATE_DEF_SEL(attributes, + "attributes"); +_MTL_PRIVATE_DEF_SEL(backFaceStencil, + "backFaceStencil"); +_MTL_PRIVATE_DEF_SEL(barrierAfterEncoderStages_beforeEncoderStages_visibilityOptions_, + "barrierAfterEncoderStages:beforeEncoderStages:visibilityOptions:"); +_MTL_PRIVATE_DEF_SEL(barrierAfterQueueStages_beforeStages_, + "barrierAfterQueueStages:beforeStages:"); +_MTL_PRIVATE_DEF_SEL(barrierAfterQueueStages_beforeStages_visibilityOptions_, + "barrierAfterQueueStages:beforeStages:visibilityOptions:"); +_MTL_PRIVATE_DEF_SEL(barrierAfterStages_beforeQueueStages_visibilityOptions_, + "barrierAfterStages:beforeQueueStages:visibilityOptions:"); +_MTL_PRIVATE_DEF_SEL(baseResourceID, + "baseResourceID"); +_MTL_PRIVATE_DEF_SEL(beginCommandBufferWithAllocator_, + "beginCommandBufferWithAllocator:"); +_MTL_PRIVATE_DEF_SEL(beginCommandBufferWithAllocator_options_, + "beginCommandBufferWithAllocator:options:"); +_MTL_PRIVATE_DEF_SEL(binaryArchives, + "binaryArchives"); +_MTL_PRIVATE_DEF_SEL(binaryFunctions, + "binaryFunctions"); +_MTL_PRIVATE_DEF_SEL(binaryLinkedFunctions, + "binaryLinkedFunctions"); +_MTL_PRIVATE_DEF_SEL(bindings, + "bindings"); +_MTL_PRIVATE_DEF_SEL(blendingState, + "blendingState"); +_MTL_PRIVATE_DEF_SEL(blitCommandEncoder, + "blitCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(blitCommandEncoderWithDescriptor_, + "blitCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(blitPassDescriptor, + "blitPassDescriptor"); +_MTL_PRIVATE_DEF_SEL(borderColor, + "borderColor"); +_MTL_PRIVATE_DEF_SEL(boundingBoxBuffer, + "boundingBoxBuffer"); +_MTL_PRIVATE_DEF_SEL(boundingBoxBufferOffset, + "boundingBoxBufferOffset"); +_MTL_PRIVATE_DEF_SEL(boundingBoxBuffers, + "boundingBoxBuffers"); +_MTL_PRIVATE_DEF_SEL(boundingBoxCount, + "boundingBoxCount"); +_MTL_PRIVATE_DEF_SEL(boundingBoxStride, + "boundingBoxStride"); +_MTL_PRIVATE_DEF_SEL(buffer, + "buffer"); +_MTL_PRIVATE_DEF_SEL(bufferAlignment, + "bufferAlignment"); +_MTL_PRIVATE_DEF_SEL(bufferBytesPerRow, + "bufferBytesPerRow"); +_MTL_PRIVATE_DEF_SEL(bufferDataSize, + "bufferDataSize"); +_MTL_PRIVATE_DEF_SEL(bufferDataType, + "bufferDataType"); +_MTL_PRIVATE_DEF_SEL(bufferIndex, + "bufferIndex"); +_MTL_PRIVATE_DEF_SEL(bufferOffset, + "bufferOffset"); +_MTL_PRIVATE_DEF_SEL(bufferPointerType, + "bufferPointerType"); +_MTL_PRIVATE_DEF_SEL(bufferSize, + "bufferSize"); +_MTL_PRIVATE_DEF_SEL(bufferStructType, + "bufferStructType"); +_MTL_PRIVATE_DEF_SEL(buffers, + "buffers"); +_MTL_PRIVATE_DEF_SEL(buildAccelerationStructure_descriptor_scratchBuffer_, + "buildAccelerationStructure:descriptor:scratchBuffer:"); +_MTL_PRIVATE_DEF_SEL(buildAccelerationStructure_descriptor_scratchBuffer_scratchBufferOffset_, + "buildAccelerationStructure:descriptor:scratchBuffer:scratchBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(captureObject, + "captureObject"); +_MTL_PRIVATE_DEF_SEL(clearBarrier, + "clearBarrier"); +_MTL_PRIVATE_DEF_SEL(clearColor, + "clearColor"); +_MTL_PRIVATE_DEF_SEL(clearDepth, + "clearDepth"); +_MTL_PRIVATE_DEF_SEL(clearStencil, + "clearStencil"); +_MTL_PRIVATE_DEF_SEL(colorAttachmentMappingState, + "colorAttachmentMappingState"); +_MTL_PRIVATE_DEF_SEL(colorAttachments, + "colorAttachments"); +_MTL_PRIVATE_DEF_SEL(column, + "column"); +_MTL_PRIVATE_DEF_SEL(commandBuffer, + "commandBuffer"); +_MTL_PRIVATE_DEF_SEL(commandBufferWithDescriptor_, + "commandBufferWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(commandBufferWithUnretainedReferences, + "commandBufferWithUnretainedReferences"); +_MTL_PRIVATE_DEF_SEL(commandQueue, + "commandQueue"); +_MTL_PRIVATE_DEF_SEL(commandTypes, + "commandTypes"); +_MTL_PRIVATE_DEF_SEL(commit, + "commit"); +_MTL_PRIVATE_DEF_SEL(commit_count_, + "commit:count:"); +_MTL_PRIVATE_DEF_SEL(commit_count_options_, + "commit:count:options:"); +_MTL_PRIVATE_DEF_SEL(compareFunction, + "compareFunction"); +_MTL_PRIVATE_DEF_SEL(compileSymbolVisibility, + "compileSymbolVisibility"); +_MTL_PRIVATE_DEF_SEL(compiler, + "compiler"); +_MTL_PRIVATE_DEF_SEL(compressionType, + "compressionType"); +_MTL_PRIVATE_DEF_SEL(computeCommandEncoder, + "computeCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDescriptor_, + "computeCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(computeCommandEncoderWithDispatchType_, + "computeCommandEncoderWithDispatchType:"); +_MTL_PRIVATE_DEF_SEL(computeFunction, + "computeFunction"); +_MTL_PRIVATE_DEF_SEL(computeFunctionDescriptor, + "computeFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(computePassDescriptor, + "computePassDescriptor"); +_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_, + "concurrentDispatchThreadgroups:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(concurrentDispatchThreads_threadsPerThreadgroup_, + "concurrentDispatchThreads:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(configuration, + "configuration"); +_MTL_PRIVATE_DEF_SEL(constantBlockAlignment, + "constantBlockAlignment"); +_MTL_PRIVATE_DEF_SEL(constantDataAtIndex_, + "constantDataAtIndex:"); +_MTL_PRIVATE_DEF_SEL(constantValues, + "constantValues"); +_MTL_PRIVATE_DEF_SEL(containsAllocation_, + "containsAllocation:"); +_MTL_PRIVATE_DEF_SEL(contents, + "contents"); +_MTL_PRIVATE_DEF_SEL(controlDependencies, + "controlDependencies"); +_MTL_PRIVATE_DEF_SEL(controlPointBuffer, + "controlPointBuffer"); +_MTL_PRIVATE_DEF_SEL(controlPointBufferOffset, + "controlPointBufferOffset"); +_MTL_PRIVATE_DEF_SEL(controlPointBuffers, + "controlPointBuffers"); +_MTL_PRIVATE_DEF_SEL(controlPointCount, + "controlPointCount"); +_MTL_PRIVATE_DEF_SEL(controlPointFormat, + "controlPointFormat"); +_MTL_PRIVATE_DEF_SEL(controlPointStride, + "controlPointStride"); +_MTL_PRIVATE_DEF_SEL(convertSparsePixelRegions_toTileRegions_withTileSize_alignmentMode_numRegions_, + "convertSparsePixelRegions:toTileRegions:withTileSize:alignmentMode:numRegions:"); +_MTL_PRIVATE_DEF_SEL(convertSparseTileRegions_toPixelRegions_withTileSize_numRegions_, + "convertSparseTileRegions:toPixelRegions:withTileSize:numRegions:"); +_MTL_PRIVATE_DEF_SEL(copyAccelerationStructure_toAccelerationStructure_, + "copyAccelerationStructure:toAccelerationStructure:"); +_MTL_PRIVATE_DEF_SEL(copyAndCompactAccelerationStructure_toAccelerationStructure_, + "copyAndCompactAccelerationStructure:toAccelerationStructure:"); +_MTL_PRIVATE_DEF_SEL(copyBufferMappingsFromBuffer_toBuffer_operations_count_, + "copyBufferMappingsFromBuffer:toBuffer:operations:count:"); +_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, + "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); +_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_sourceBytesPerRow_sourceBytesPerImage_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_options_, + "copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:options:"); +_MTL_PRIVATE_DEF_SEL(copyFromBuffer_sourceOffset_toBuffer_destinationOffset_size_, + "copyFromBuffer:sourceOffset:toBuffer:destinationOffset:size:"); +_MTL_PRIVATE_DEF_SEL(copyFromTensor_sourceOrigin_sourceDimensions_toTensor_destinationOrigin_destinationDimensions_, + "copyFromTensor:sourceOrigin:sourceDimensions:toTensor:destinationOrigin:destinationDimensions:"); +_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_, + "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:"); +_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toBuffer_destinationOffset_destinationBytesPerRow_destinationBytesPerImage_options_, + "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:options:"); +_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, + "copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); +_MTL_PRIVATE_DEF_SEL(copyFromTexture_sourceSlice_sourceLevel_toTexture_destinationSlice_destinationLevel_sliceCount_levelCount_, + "copyFromTexture:sourceSlice:sourceLevel:toTexture:destinationSlice:destinationLevel:sliceCount:levelCount:"); +_MTL_PRIVATE_DEF_SEL(copyFromTexture_toTexture_, + "copyFromTexture:toTexture:"); +_MTL_PRIVATE_DEF_SEL(copyIndirectCommandBuffer_sourceRange_destination_destinationIndex_, + "copyIndirectCommandBuffer:sourceRange:destination:destinationIndex:"); +_MTL_PRIVATE_DEF_SEL(copyParameterDataToBuffer_offset_, + "copyParameterDataToBuffer:offset:"); +_MTL_PRIVATE_DEF_SEL(copyResourceViewsFromPool_sourceRange_destinationIndex_, + "copyResourceViewsFromPool:sourceRange:destinationIndex:"); +_MTL_PRIVATE_DEF_SEL(copyStatusToBuffer_offset_, + "copyStatusToBuffer:offset:"); +_MTL_PRIVATE_DEF_SEL(copyTextureMappingsFromTexture_toTexture_operations_count_, + "copyTextureMappingsFromTexture:toTexture:operations:count:"); +_MTL_PRIVATE_DEF_SEL(count, + "count"); +_MTL_PRIVATE_DEF_SEL(counterSet, + "counterSet"); +_MTL_PRIVATE_DEF_SEL(counterSets, + "counterSets"); +_MTL_PRIVATE_DEF_SEL(counters, + "counters"); +_MTL_PRIVATE_DEF_SEL(cpuCacheMode, + "cpuCacheMode"); +_MTL_PRIVATE_DEF_SEL(currentAllocatedSize, + "currentAllocatedSize"); +_MTL_PRIVATE_DEF_SEL(curveBasis, + "curveBasis"); +_MTL_PRIVATE_DEF_SEL(curveEndCaps, + "curveEndCaps"); +_MTL_PRIVATE_DEF_SEL(curveType, + "curveType"); +_MTL_PRIVATE_DEF_SEL(data, + "data"); +_MTL_PRIVATE_DEF_SEL(dataSize, + "dataSize"); +_MTL_PRIVATE_DEF_SEL(dataType, + "dataType"); +_MTL_PRIVATE_DEF_SEL(dealloc, + "dealloc"); +_MTL_PRIVATE_DEF_SEL(debugLocation, + "debugLocation"); +_MTL_PRIVATE_DEF_SEL(debugSignposts, + "debugSignposts"); +_MTL_PRIVATE_DEF_SEL(defaultCaptureScope, + "defaultCaptureScope"); +_MTL_PRIVATE_DEF_SEL(defaultRasterSampleCount, + "defaultRasterSampleCount"); +_MTL_PRIVATE_DEF_SEL(depth, + "depth"); +_MTL_PRIVATE_DEF_SEL(depthAttachment, + "depthAttachment"); +_MTL_PRIVATE_DEF_SEL(depthAttachmentPixelFormat, + "depthAttachmentPixelFormat"); +_MTL_PRIVATE_DEF_SEL(depthCompareFunction, + "depthCompareFunction"); +_MTL_PRIVATE_DEF_SEL(depthFailureOperation, + "depthFailureOperation"); +_MTL_PRIVATE_DEF_SEL(depthPlane, + "depthPlane"); +_MTL_PRIVATE_DEF_SEL(depthResolveFilter, + "depthResolveFilter"); +_MTL_PRIVATE_DEF_SEL(depthStencilPassOperation, + "depthStencilPassOperation"); +_MTL_PRIVATE_DEF_SEL(descriptor, + "descriptor"); +_MTL_PRIVATE_DEF_SEL(destination, + "destination"); +_MTL_PRIVATE_DEF_SEL(destinationAlphaBlendFactor, + "destinationAlphaBlendFactor"); +_MTL_PRIVATE_DEF_SEL(destinationRGBBlendFactor, + "destinationRGBBlendFactor"); +_MTL_PRIVATE_DEF_SEL(device, + "device"); +_MTL_PRIVATE_DEF_SEL(didModifyRange_, + "didModifyRange:"); +_MTL_PRIVATE_DEF_SEL(dimensions, + "dimensions"); +_MTL_PRIVATE_DEF_SEL(dispatchNetworkWithIntermediatesHeap_, + "dispatchNetworkWithIntermediatesHeap:"); +_MTL_PRIVATE_DEF_SEL(dispatchQueue, + "dispatchQueue"); +_MTL_PRIVATE_DEF_SEL(dispatchThreadgroups_threadsPerThreadgroup_, + "dispatchThreadgroups:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(dispatchThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerThreadgroup_, + "dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(dispatchThreadgroupsWithIndirectBuffer_threadsPerThreadgroup_, + "dispatchThreadgroupsWithIndirectBuffer:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(dispatchThreads_threadsPerThreadgroup_, + "dispatchThreads:threadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(dispatchThreadsPerTile_, + "dispatchThreadsPerTile:"); +_MTL_PRIVATE_DEF_SEL(dispatchThreadsWithIndirectBuffer_, + "dispatchThreadsWithIndirectBuffer:"); +_MTL_PRIVATE_DEF_SEL(dispatchType, + "dispatchType"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_, + "drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_, + "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_, + "drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferLength:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferLength:instanceCount:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferLength_instanceCount_baseVertex_baseInstance_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferLength:instanceCount:baseVertex:baseInstance:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_, + "drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferLength_indirectBuffer_, + "drawIndexedPrimitives:indexType:indexBuffer:indexBufferLength:indirectBuffer:"); +_MTL_PRIVATE_DEF_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_, + "drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, + "drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, + "drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(drawMeshThreadgroupsWithIndirectBuffer_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, + "drawMeshThreadgroupsWithIndirectBuffer:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_, + "drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_, + "drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_, + "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:"); +_MTL_PRIVATE_DEF_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_, + "drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:tessellationFactorBuffer:tessellationFactorBufferOffset:tessellationFactorBufferInstanceStride:"); +_MTL_PRIVATE_DEF_SEL(drawPrimitives_indirectBuffer_, + "drawPrimitives:indirectBuffer:"); +_MTL_PRIVATE_DEF_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_, + "drawPrimitives:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_, + "drawPrimitives:vertexStart:vertexCount:"); +_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_, + "drawPrimitives:vertexStart:vertexCount:instanceCount:"); +_MTL_PRIVATE_DEF_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_, + "drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:"); +_MTL_PRIVATE_DEF_SEL(drawableID, + "drawableID"); +_MTL_PRIVATE_DEF_SEL(elementArrayType, + "elementArrayType"); +_MTL_PRIVATE_DEF_SEL(elementIsArgumentBuffer, + "elementIsArgumentBuffer"); +_MTL_PRIVATE_DEF_SEL(elementPointerType, + "elementPointerType"); +_MTL_PRIVATE_DEF_SEL(elementStructType, + "elementStructType"); +_MTL_PRIVATE_DEF_SEL(elementTensorReferenceType, + "elementTensorReferenceType"); +_MTL_PRIVATE_DEF_SEL(elementTextureReferenceType, + "elementTextureReferenceType"); +_MTL_PRIVATE_DEF_SEL(elementType, + "elementType"); +_MTL_PRIVATE_DEF_SEL(enableLogging, + "enableLogging"); +_MTL_PRIVATE_DEF_SEL(encodeSignalEvent_value_, + "encodeSignalEvent:value:"); +_MTL_PRIVATE_DEF_SEL(encodeWaitForEvent_value_, + "encodeWaitForEvent:value:"); +_MTL_PRIVATE_DEF_SEL(encodedLength, + "encodedLength"); +_MTL_PRIVATE_DEF_SEL(encoderLabel, + "encoderLabel"); +_MTL_PRIVATE_DEF_SEL(endCommandBuffer, + "endCommandBuffer"); +_MTL_PRIVATE_DEF_SEL(endEncoding, + "endEncoding"); +_MTL_PRIVATE_DEF_SEL(endOfEncoderSampleIndex, + "endOfEncoderSampleIndex"); +_MTL_PRIVATE_DEF_SEL(endOfFragmentSampleIndex, + "endOfFragmentSampleIndex"); +_MTL_PRIVATE_DEF_SEL(endOfVertexSampleIndex, + "endOfVertexSampleIndex"); +_MTL_PRIVATE_DEF_SEL(endResidency, + "endResidency"); +_MTL_PRIVATE_DEF_SEL(enqueue, + "enqueue"); +_MTL_PRIVATE_DEF_SEL(enqueueBarrier, + "enqueueBarrier"); +_MTL_PRIVATE_DEF_SEL(error, + "error"); +_MTL_PRIVATE_DEF_SEL(errorOptions, + "errorOptions"); +_MTL_PRIVATE_DEF_SEL(errorState, + "errorState"); +_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_indirectBuffer_, + "executeCommandsInBuffer:indirectBuffer:"); +_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_, + "executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(executeCommandsInBuffer_withRange_, + "executeCommandsInBuffer:withRange:"); +_MTL_PRIVATE_DEF_SEL(extentAtDimensionIndex_, + "extentAtDimensionIndex:"); +_MTL_PRIVATE_DEF_SEL(fastMathEnabled, + "fastMathEnabled"); +_MTL_PRIVATE_DEF_SEL(feedbackQueue, + "feedbackQueue"); +_MTL_PRIVATE_DEF_SEL(fillBuffer_range_value_, + "fillBuffer:range:value:"); +_MTL_PRIVATE_DEF_SEL(firstMipmapInTail, + "firstMipmapInTail"); +_MTL_PRIVATE_DEF_SEL(format, + "format"); +_MTL_PRIVATE_DEF_SEL(fragmentAdditionalBinaryFunctions, + "fragmentAdditionalBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(fragmentArguments, + "fragmentArguments"); +_MTL_PRIVATE_DEF_SEL(fragmentBindings, + "fragmentBindings"); +_MTL_PRIVATE_DEF_SEL(fragmentBuffers, + "fragmentBuffers"); +_MTL_PRIVATE_DEF_SEL(fragmentFunction, + "fragmentFunction"); +_MTL_PRIVATE_DEF_SEL(fragmentFunctionDescriptor, + "fragmentFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(fragmentLinkedFunctions, + "fragmentLinkedFunctions"); +_MTL_PRIVATE_DEF_SEL(fragmentLinkingDescriptor, + "fragmentLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(fragmentPreloadedLibraries, + "fragmentPreloadedLibraries"); +_MTL_PRIVATE_DEF_SEL(fragmentStaticLinkingDescriptor, + "fragmentStaticLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(frontFaceStencil, + "frontFaceStencil"); +_MTL_PRIVATE_DEF_SEL(function, + "function"); +_MTL_PRIVATE_DEF_SEL(functionConstantsDictionary, + "functionConstantsDictionary"); +_MTL_PRIVATE_DEF_SEL(functionCount, + "functionCount"); +_MTL_PRIVATE_DEF_SEL(functionDescriptor, + "functionDescriptor"); +_MTL_PRIVATE_DEF_SEL(functionDescriptors, + "functionDescriptors"); +_MTL_PRIVATE_DEF_SEL(functionGraph, + "functionGraph"); +_MTL_PRIVATE_DEF_SEL(functionGraphs, + "functionGraphs"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithBinaryFunction_, + "functionHandleWithBinaryFunction:"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithBinaryFunction_stage_, + "functionHandleWithBinaryFunction:stage:"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_, + "functionHandleWithFunction:"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithFunction_stage_, + "functionHandleWithFunction:stage:"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithName_, + "functionHandleWithName:"); +_MTL_PRIVATE_DEF_SEL(functionHandleWithName_stage_, + "functionHandleWithName:stage:"); +_MTL_PRIVATE_DEF_SEL(functionName, + "functionName"); +_MTL_PRIVATE_DEF_SEL(functionNames, + "functionNames"); +_MTL_PRIVATE_DEF_SEL(functionType, + "functionType"); +_MTL_PRIVATE_DEF_SEL(functions, + "functions"); +_MTL_PRIVATE_DEF_SEL(generateMipmapsForTexture_, + "generateMipmapsForTexture:"); +_MTL_PRIVATE_DEF_SEL(geometryDescriptors, + "geometryDescriptors"); +_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_, + "getBytes:bytesPerRow:bytesPerImage:fromRegion:mipmapLevel:slice:"); +_MTL_PRIVATE_DEF_SEL(getBytes_bytesPerRow_fromRegion_mipmapLevel_, + "getBytes:bytesPerRow:fromRegion:mipmapLevel:"); +_MTL_PRIVATE_DEF_SEL(getBytes_strides_fromSliceOrigin_sliceDimensions_, + "getBytes:strides:fromSliceOrigin:sliceDimensions:"); +_MTL_PRIVATE_DEF_SEL(getDefaultSamplePositions_count_, + "getDefaultSamplePositions:count:"); +_MTL_PRIVATE_DEF_SEL(getPhysicalIndexForLogicalIndex_, + "getPhysicalIndexForLogicalIndex:"); +_MTL_PRIVATE_DEF_SEL(getSamplePositions_count_, + "getSamplePositions:count:"); +_MTL_PRIVATE_DEF_SEL(getTextureAccessCounters_region_mipLevel_slice_resetCounters_countersBuffer_countersBufferOffset_, + "getTextureAccessCounters:region:mipLevel:slice:resetCounters:countersBuffer:countersBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(gpuAddress, + "gpuAddress"); +_MTL_PRIVATE_DEF_SEL(gpuResourceID, + "gpuResourceID"); +_MTL_PRIVATE_DEF_SEL(groups, + "groups"); +_MTL_PRIVATE_DEF_SEL(hasUnifiedMemory, + "hasUnifiedMemory"); +_MTL_PRIVATE_DEF_SEL(hazardTrackingMode, + "hazardTrackingMode"); +_MTL_PRIVATE_DEF_SEL(heap, + "heap"); +_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithDescriptor_, + "heapAccelerationStructureSizeAndAlignWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(heapAccelerationStructureSizeAndAlignWithSize_, + "heapAccelerationStructureSizeAndAlignWithSize:"); +_MTL_PRIVATE_DEF_SEL(heapBufferSizeAndAlignWithLength_options_, + "heapBufferSizeAndAlignWithLength:options:"); +_MTL_PRIVATE_DEF_SEL(heapOffset, + "heapOffset"); +_MTL_PRIVATE_DEF_SEL(heapTextureSizeAndAlignWithDescriptor_, + "heapTextureSizeAndAlignWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(height, + "height"); +_MTL_PRIVATE_DEF_SEL(horizontal, + "horizontal"); +_MTL_PRIVATE_DEF_SEL(horizontalSampleStorage, + "horizontalSampleStorage"); +_MTL_PRIVATE_DEF_SEL(imageblockMemoryLengthForDimensions_, + "imageblockMemoryLengthForDimensions:"); +_MTL_PRIVATE_DEF_SEL(imageblockSampleLength, + "imageblockSampleLength"); +_MTL_PRIVATE_DEF_SEL(index, + "index"); +_MTL_PRIVATE_DEF_SEL(indexBuffer, + "indexBuffer"); +_MTL_PRIVATE_DEF_SEL(indexBufferIndex, + "indexBufferIndex"); +_MTL_PRIVATE_DEF_SEL(indexBufferOffset, + "indexBufferOffset"); +_MTL_PRIVATE_DEF_SEL(indexType, + "indexType"); +_MTL_PRIVATE_DEF_SEL(indirectComputeCommandAtIndex_, + "indirectComputeCommandAtIndex:"); +_MTL_PRIVATE_DEF_SEL(indirectRenderCommandAtIndex_, + "indirectRenderCommandAtIndex:"); +_MTL_PRIVATE_DEF_SEL(inheritBuffers, + "inheritBuffers"); +_MTL_PRIVATE_DEF_SEL(inheritCullMode, + "inheritCullMode"); +_MTL_PRIVATE_DEF_SEL(inheritDepthBias, + "inheritDepthBias"); +_MTL_PRIVATE_DEF_SEL(inheritDepthClipMode, + "inheritDepthClipMode"); +_MTL_PRIVATE_DEF_SEL(inheritDepthStencilState, + "inheritDepthStencilState"); +_MTL_PRIVATE_DEF_SEL(inheritFrontFacingWinding, + "inheritFrontFacingWinding"); +_MTL_PRIVATE_DEF_SEL(inheritPipelineState, + "inheritPipelineState"); +_MTL_PRIVATE_DEF_SEL(inheritTriangleFillMode, + "inheritTriangleFillMode"); +_MTL_PRIVATE_DEF_SEL(init, + "init"); +_MTL_PRIVATE_DEF_SEL(initWithArgumentIndex_, + "initWithArgumentIndex:"); +_MTL_PRIVATE_DEF_SEL(initWithDispatchQueue_, + "initWithDispatchQueue:"); +_MTL_PRIVATE_DEF_SEL(initWithFunctionName_nodes_outputNode_attributes_, + "initWithFunctionName:nodes:outputNode:attributes:"); +_MTL_PRIVATE_DEF_SEL(initWithName_arguments_controlDependencies_, + "initWithName:arguments:controlDependencies:"); +_MTL_PRIVATE_DEF_SEL(initWithRank_values_, + "initWithRank:values:"); +_MTL_PRIVATE_DEF_SEL(initWithSampleCount_, + "initWithSampleCount:"); +_MTL_PRIVATE_DEF_SEL(initWithSampleCount_horizontal_vertical_, + "initWithSampleCount:horizontal:vertical:"); +_MTL_PRIVATE_DEF_SEL(initialCapacity, + "initialCapacity"); +_MTL_PRIVATE_DEF_SEL(initializeBindings, + "initializeBindings"); +_MTL_PRIVATE_DEF_SEL(inputDimensionsAtBufferIndex_, + "inputDimensionsAtBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(inputPrimitiveTopology, + "inputPrimitiveTopology"); +_MTL_PRIVATE_DEF_SEL(insertDebugCaptureBoundary, + "insertDebugCaptureBoundary"); +_MTL_PRIVATE_DEF_SEL(insertDebugSignpost_, + "insertDebugSignpost:"); +_MTL_PRIVATE_DEF_SEL(insertLibraries, + "insertLibraries"); +_MTL_PRIVATE_DEF_SEL(installName, + "installName"); +_MTL_PRIVATE_DEF_SEL(instanceCount, + "instanceCount"); +_MTL_PRIVATE_DEF_SEL(instanceCountBuffer, + "instanceCountBuffer"); +_MTL_PRIVATE_DEF_SEL(instanceCountBufferOffset, + "instanceCountBufferOffset"); +_MTL_PRIVATE_DEF_SEL(instanceDescriptorBuffer, + "instanceDescriptorBuffer"); +_MTL_PRIVATE_DEF_SEL(instanceDescriptorBufferOffset, + "instanceDescriptorBufferOffset"); +_MTL_PRIVATE_DEF_SEL(instanceDescriptorStride, + "instanceDescriptorStride"); +_MTL_PRIVATE_DEF_SEL(instanceDescriptorType, + "instanceDescriptorType"); +_MTL_PRIVATE_DEF_SEL(instanceTransformationMatrixLayout, + "instanceTransformationMatrixLayout"); +_MTL_PRIVATE_DEF_SEL(instancedAccelerationStructures, + "instancedAccelerationStructures"); +_MTL_PRIVATE_DEF_SEL(intermediatesHeapSize, + "intermediatesHeapSize"); +_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableDescriptor, + "intersectionFunctionTableDescriptor"); +_MTL_PRIVATE_DEF_SEL(intersectionFunctionTableOffset, + "intersectionFunctionTableOffset"); +_MTL_PRIVATE_DEF_SEL(invalidateCounterRange_, + "invalidateCounterRange:"); +_MTL_PRIVATE_DEF_SEL(iosurface, + "iosurface"); +_MTL_PRIVATE_DEF_SEL(iosurfacePlane, + "iosurfacePlane"); +_MTL_PRIVATE_DEF_SEL(isActive, + "isActive"); +_MTL_PRIVATE_DEF_SEL(isAliasable, + "isAliasable"); +_MTL_PRIVATE_DEF_SEL(isAlphaToCoverageEnabled, + "isAlphaToCoverageEnabled"); +_MTL_PRIVATE_DEF_SEL(isAlphaToOneEnabled, + "isAlphaToOneEnabled"); +_MTL_PRIVATE_DEF_SEL(isArgument, + "isArgument"); +_MTL_PRIVATE_DEF_SEL(isBlendingEnabled, + "isBlendingEnabled"); +_MTL_PRIVATE_DEF_SEL(isCapturing, + "isCapturing"); +_MTL_PRIVATE_DEF_SEL(isDepth24Stencil8PixelFormatSupported, + "isDepth24Stencil8PixelFormatSupported"); +_MTL_PRIVATE_DEF_SEL(isDepthTexture, + "isDepthTexture"); +_MTL_PRIVATE_DEF_SEL(isDepthWriteEnabled, + "isDepthWriteEnabled"); +_MTL_PRIVATE_DEF_SEL(isFramebufferOnly, + "isFramebufferOnly"); +_MTL_PRIVATE_DEF_SEL(isHeadless, + "isHeadless"); +_MTL_PRIVATE_DEF_SEL(isLowPower, + "isLowPower"); +_MTL_PRIVATE_DEF_SEL(isPatchControlPointData, + "isPatchControlPointData"); +_MTL_PRIVATE_DEF_SEL(isPatchData, + "isPatchData"); +_MTL_PRIVATE_DEF_SEL(isRasterizationEnabled, + "isRasterizationEnabled"); +_MTL_PRIVATE_DEF_SEL(isRemovable, + "isRemovable"); +_MTL_PRIVATE_DEF_SEL(isShareable, + "isShareable"); +_MTL_PRIVATE_DEF_SEL(isSparse, + "isSparse"); +_MTL_PRIVATE_DEF_SEL(isTessellationFactorScaleEnabled, + "isTessellationFactorScaleEnabled"); +_MTL_PRIVATE_DEF_SEL(isUsed, + "isUsed"); +_MTL_PRIVATE_DEF_SEL(kernelEndTime, + "kernelEndTime"); +_MTL_PRIVATE_DEF_SEL(kernelStartTime, + "kernelStartTime"); +_MTL_PRIVATE_DEF_SEL(label, + "label"); +_MTL_PRIVATE_DEF_SEL(languageVersion, + "languageVersion"); +_MTL_PRIVATE_DEF_SEL(layerAtIndex_, + "layerAtIndex:"); +_MTL_PRIVATE_DEF_SEL(layerCount, + "layerCount"); +_MTL_PRIVATE_DEF_SEL(layers, + "layers"); +_MTL_PRIVATE_DEF_SEL(layouts, + "layouts"); +_MTL_PRIVATE_DEF_SEL(length, + "length"); +_MTL_PRIVATE_DEF_SEL(level, + "level"); +_MTL_PRIVATE_DEF_SEL(levelRange, + "levelRange"); +_MTL_PRIVATE_DEF_SEL(libraries, + "libraries"); +_MTL_PRIVATE_DEF_SEL(library, + "library"); +_MTL_PRIVATE_DEF_SEL(libraryType, + "libraryType"); +_MTL_PRIVATE_DEF_SEL(line, + "line"); +_MTL_PRIVATE_DEF_SEL(linkedFunctions, + "linkedFunctions"); +_MTL_PRIVATE_DEF_SEL(loadAction, + "loadAction"); +_MTL_PRIVATE_DEF_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_, + "loadBuffer:offset:size:sourceHandle:sourceHandleOffset:"); +_MTL_PRIVATE_DEF_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_, + "loadBytes:size:sourceHandle:sourceHandleOffset:"); +_MTL_PRIVATE_DEF_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_, + "loadTexture:slice:level:size:sourceBytesPerRow:sourceBytesPerImage:destinationOrigin:sourceHandle:sourceHandleOffset:"); +_MTL_PRIVATE_DEF_SEL(location, + "location"); +_MTL_PRIVATE_DEF_SEL(locationNumber, + "locationNumber"); +_MTL_PRIVATE_DEF_SEL(lodAverage, + "lodAverage"); +_MTL_PRIVATE_DEF_SEL(lodBias, + "lodBias"); +_MTL_PRIVATE_DEF_SEL(lodMaxClamp, + "lodMaxClamp"); +_MTL_PRIVATE_DEF_SEL(lodMinClamp, + "lodMinClamp"); +_MTL_PRIVATE_DEF_SEL(logState, + "logState"); +_MTL_PRIVATE_DEF_SEL(logs, + "logs"); +_MTL_PRIVATE_DEF_SEL(lookupArchives, + "lookupArchives"); +_MTL_PRIVATE_DEF_SEL(machineLearningCommandEncoder, + "machineLearningCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(machineLearningFunctionDescriptor, + "machineLearningFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(magFilter, + "magFilter"); +_MTL_PRIVATE_DEF_SEL(makeAliasable, + "makeAliasable"); +_MTL_PRIVATE_DEF_SEL(mapPhysicalToScreenCoordinates_forLayer_, + "mapPhysicalToScreenCoordinates:forLayer:"); +_MTL_PRIVATE_DEF_SEL(mapScreenToPhysicalCoordinates_forLayer_, + "mapScreenToPhysicalCoordinates:forLayer:"); +_MTL_PRIVATE_DEF_SEL(mathFloatingPointFunctions, + "mathFloatingPointFunctions"); +_MTL_PRIVATE_DEF_SEL(mathMode, + "mathMode"); +_MTL_PRIVATE_DEF_SEL(maxAnisotropy, + "maxAnisotropy"); +_MTL_PRIVATE_DEF_SEL(maxArgumentBufferSamplerCount, + "maxArgumentBufferSamplerCount"); +_MTL_PRIVATE_DEF_SEL(maxAvailableSizeWithAlignment_, + "maxAvailableSizeWithAlignment:"); +_MTL_PRIVATE_DEF_SEL(maxBufferBindCount, + "maxBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxBufferLength, + "maxBufferLength"); +_MTL_PRIVATE_DEF_SEL(maxCallStackDepth, + "maxCallStackDepth"); +_MTL_PRIVATE_DEF_SEL(maxCommandBufferCount, + "maxCommandBufferCount"); +_MTL_PRIVATE_DEF_SEL(maxCommandsInFlight, + "maxCommandsInFlight"); +_MTL_PRIVATE_DEF_SEL(maxCompatiblePlacementSparsePageSize, + "maxCompatiblePlacementSparsePageSize"); +_MTL_PRIVATE_DEF_SEL(maxFragmentBufferBindCount, + "maxFragmentBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxFragmentCallStackDepth, + "maxFragmentCallStackDepth"); +_MTL_PRIVATE_DEF_SEL(maxInstanceCount, + "maxInstanceCount"); +_MTL_PRIVATE_DEF_SEL(maxKernelBufferBindCount, + "maxKernelBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxKernelThreadgroupMemoryBindCount, + "maxKernelThreadgroupMemoryBindCount"); +_MTL_PRIVATE_DEF_SEL(maxMeshBufferBindCount, + "maxMeshBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxMotionTransformCount, + "maxMotionTransformCount"); +_MTL_PRIVATE_DEF_SEL(maxObjectBufferBindCount, + "maxObjectBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxObjectThreadgroupMemoryBindCount, + "maxObjectThreadgroupMemoryBindCount"); +_MTL_PRIVATE_DEF_SEL(maxSampleCount, + "maxSampleCount"); +_MTL_PRIVATE_DEF_SEL(maxSamplerStateBindCount, + "maxSamplerStateBindCount"); +_MTL_PRIVATE_DEF_SEL(maxTessellationFactor, + "maxTessellationFactor"); +_MTL_PRIVATE_DEF_SEL(maxTextureBindCount, + "maxTextureBindCount"); +_MTL_PRIVATE_DEF_SEL(maxThreadgroupMemoryLength, + "maxThreadgroupMemoryLength"); +_MTL_PRIVATE_DEF_SEL(maxThreadsPerThreadgroup, + "maxThreadsPerThreadgroup"); +_MTL_PRIVATE_DEF_SEL(maxTotalThreadgroupsPerMeshGrid, + "maxTotalThreadgroupsPerMeshGrid"); +_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerMeshThreadgroup, + "maxTotalThreadsPerMeshThreadgroup"); +_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerObjectThreadgroup, + "maxTotalThreadsPerObjectThreadgroup"); +_MTL_PRIVATE_DEF_SEL(maxTotalThreadsPerThreadgroup, + "maxTotalThreadsPerThreadgroup"); +_MTL_PRIVATE_DEF_SEL(maxTransferRate, + "maxTransferRate"); +_MTL_PRIVATE_DEF_SEL(maxVertexAmplificationCount, + "maxVertexAmplificationCount"); +_MTL_PRIVATE_DEF_SEL(maxVertexBufferBindCount, + "maxVertexBufferBindCount"); +_MTL_PRIVATE_DEF_SEL(maxVertexCallStackDepth, + "maxVertexCallStackDepth"); +_MTL_PRIVATE_DEF_SEL(maximumConcurrentCompilationTaskCount, + "maximumConcurrentCompilationTaskCount"); +_MTL_PRIVATE_DEF_SEL(memberByName_, + "memberByName:"); +_MTL_PRIVATE_DEF_SEL(members, + "members"); +_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_, + "memoryBarrierWithResources:count:"); +_MTL_PRIVATE_DEF_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_, + "memoryBarrierWithResources:count:afterStages:beforeStages:"); +_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_, + "memoryBarrierWithScope:"); +_MTL_PRIVATE_DEF_SEL(memoryBarrierWithScope_afterStages_beforeStages_, + "memoryBarrierWithScope:afterStages:beforeStages:"); +_MTL_PRIVATE_DEF_SEL(meshAdditionalBinaryFunctions, + "meshAdditionalBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(meshBindings, + "meshBindings"); +_MTL_PRIVATE_DEF_SEL(meshBuffers, + "meshBuffers"); +_MTL_PRIVATE_DEF_SEL(meshFunction, + "meshFunction"); +_MTL_PRIVATE_DEF_SEL(meshFunctionDescriptor, + "meshFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(meshLinkedFunctions, + "meshLinkedFunctions"); +_MTL_PRIVATE_DEF_SEL(meshLinkingDescriptor, + "meshLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(meshStaticLinkingDescriptor, + "meshStaticLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(meshThreadExecutionWidth, + "meshThreadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth, + "meshThreadgroupSizeIsMultipleOfThreadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(minFilter, + "minFilter"); +_MTL_PRIVATE_DEF_SEL(minimumLinearTextureAlignmentForPixelFormat_, + "minimumLinearTextureAlignmentForPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(minimumTextureBufferAlignmentForPixelFormat_, + "minimumTextureBufferAlignmentForPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(mipFilter, + "mipFilter"); +_MTL_PRIVATE_DEF_SEL(mipmapLevelCount, + "mipmapLevelCount"); +_MTL_PRIVATE_DEF_SEL(motionEndBorderMode, + "motionEndBorderMode"); +_MTL_PRIVATE_DEF_SEL(motionEndTime, + "motionEndTime"); +_MTL_PRIVATE_DEF_SEL(motionKeyframeCount, + "motionKeyframeCount"); +_MTL_PRIVATE_DEF_SEL(motionStartBorderMode, + "motionStartBorderMode"); +_MTL_PRIVATE_DEF_SEL(motionStartTime, + "motionStartTime"); +_MTL_PRIVATE_DEF_SEL(motionTransformBuffer, + "motionTransformBuffer"); +_MTL_PRIVATE_DEF_SEL(motionTransformBufferOffset, + "motionTransformBufferOffset"); +_MTL_PRIVATE_DEF_SEL(motionTransformCount, + "motionTransformCount"); +_MTL_PRIVATE_DEF_SEL(motionTransformCountBuffer, + "motionTransformCountBuffer"); +_MTL_PRIVATE_DEF_SEL(motionTransformCountBufferOffset, + "motionTransformCountBufferOffset"); +_MTL_PRIVATE_DEF_SEL(motionTransformStride, + "motionTransformStride"); +_MTL_PRIVATE_DEF_SEL(motionTransformType, + "motionTransformType"); +_MTL_PRIVATE_DEF_SEL(moveTextureMappingsFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_, + "moveTextureMappingsFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"); +_MTL_PRIVATE_DEF_SEL(mutability, + "mutability"); +_MTL_PRIVATE_DEF_SEL(name, + "name"); +_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_, + "newAccelerationStructureWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithDescriptor_offset_, + "newAccelerationStructureWithDescriptor:offset:"); +_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_, + "newAccelerationStructureWithSize:"); +_MTL_PRIVATE_DEF_SEL(newAccelerationStructureWithSize_offset_, + "newAccelerationStructureWithSize:offset:"); +_MTL_PRIVATE_DEF_SEL(newArchiveWithURL_error_, + "newArchiveWithURL:error:"); +_MTL_PRIVATE_DEF_SEL(newArgumentEncoderForBufferAtIndex_, + "newArgumentEncoderForBufferAtIndex:"); +_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithArguments_, + "newArgumentEncoderWithArguments:"); +_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferBinding_, + "newArgumentEncoderWithBufferBinding:"); +_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_, + "newArgumentEncoderWithBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(newArgumentEncoderWithBufferIndex_reflection_, + "newArgumentEncoderWithBufferIndex:reflection:"); +_MTL_PRIVATE_DEF_SEL(newArgumentTableWithDescriptor_error_, + "newArgumentTableWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newBinaryArchiveWithDescriptor_error_, + "newBinaryArchiveWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_completionHandler_, + "newBinaryFunctionWithDescriptor:compilerTaskOptions:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newBinaryFunctionWithDescriptor_compilerTaskOptions_error_, + "newBinaryFunctionWithDescriptor:compilerTaskOptions:error:"); +_MTL_PRIVATE_DEF_SEL(newBinaryFunctionWithDescriptor_error_, + "newBinaryFunctionWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newBufferWithBytes_length_options_, + "newBufferWithBytes:length:options:"); +_MTL_PRIVATE_DEF_SEL(newBufferWithBytesNoCopy_length_options_deallocator_, + "newBufferWithBytesNoCopy:length:options:deallocator:"); +_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_, + "newBufferWithLength:options:"); +_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_offset_, + "newBufferWithLength:options:offset:"); +_MTL_PRIVATE_DEF_SEL(newBufferWithLength_options_placementSparsePageSize_, + "newBufferWithLength:options:placementSparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithCommandQueue_, + "newCaptureScopeWithCommandQueue:"); +_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithDevice_, + "newCaptureScopeWithDevice:"); +_MTL_PRIVATE_DEF_SEL(newCaptureScopeWithMTL4CommandQueue_, + "newCaptureScopeWithMTL4CommandQueue:"); +_MTL_PRIVATE_DEF_SEL(newCommandAllocator, + "newCommandAllocator"); +_MTL_PRIVATE_DEF_SEL(newCommandAllocatorWithDescriptor_error_, + "newCommandAllocatorWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newCommandBuffer, + "newCommandBuffer"); +_MTL_PRIVATE_DEF_SEL(newCommandQueue, + "newCommandQueue"); +_MTL_PRIVATE_DEF_SEL(newCommandQueueWithDescriptor_, + "newCommandQueueWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newCommandQueueWithMaxCommandBufferCount_, + "newCommandQueueWithMaxCommandBufferCount:"); +_MTL_PRIVATE_DEF_SEL(newCompilerWithDescriptor_error_, + "newCompilerWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithAdditionalBinaryFunctions_error_, + "newComputePipelineStateWithAdditionalBinaryFunctions:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithBinaryFunctions_error_, + "newComputePipelineStateWithBinaryFunctions:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_completionHandler_, + "newComputePipelineStateWithDescriptor:compilerTaskOptions:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_compilerTaskOptions_error_, + "newComputePipelineStateWithDescriptor:compilerTaskOptions:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_, + "newComputePipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_, + "newComputePipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_dynamicLinkingDescriptor_error_, + "newComputePipelineStateWithDescriptor:dynamicLinkingDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_error_, + "newComputePipelineStateWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_completionHandler_, + "newComputePipelineStateWithDescriptor:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithDescriptor_options_reflection_error_, + "newComputePipelineStateWithDescriptor:options:reflection:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_completionHandler_, + "newComputePipelineStateWithFunction:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_error_, + "newComputePipelineStateWithFunction:error:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_completionHandler_, + "newComputePipelineStateWithFunction:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newComputePipelineStateWithFunction_options_reflection_error_, + "newComputePipelineStateWithFunction:options:reflection:error:"); +_MTL_PRIVATE_DEF_SEL(newCounterHeapWithDescriptor_error_, + "newCounterHeapWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newCounterSampleBufferWithDescriptor_error_, + "newCounterSampleBufferWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newDefaultLibrary, + "newDefaultLibrary"); +_MTL_PRIVATE_DEF_SEL(newDefaultLibraryWithBundle_error_, + "newDefaultLibraryWithBundle:error:"); +_MTL_PRIVATE_DEF_SEL(newDepthStencilStateWithDescriptor_, + "newDepthStencilStateWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newDynamicLibrary_completionHandler_, + "newDynamicLibrary:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newDynamicLibrary_error_, + "newDynamicLibrary:error:"); +_MTL_PRIVATE_DEF_SEL(newDynamicLibraryWithURL_completionHandler_, + "newDynamicLibraryWithURL:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newDynamicLibraryWithURL_error_, + "newDynamicLibraryWithURL:error:"); +_MTL_PRIVATE_DEF_SEL(newEvent, + "newEvent"); +_MTL_PRIVATE_DEF_SEL(newFence, + "newFence"); +_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_completionHandler_, + "newFunctionWithDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newFunctionWithDescriptor_error_, + "newFunctionWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newFunctionWithName_, + "newFunctionWithName:"); +_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_completionHandler_, + "newFunctionWithName:constantValues:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newFunctionWithName_constantValues_error_, + "newFunctionWithName:constantValues:error:"); +_MTL_PRIVATE_DEF_SEL(newHeapWithDescriptor_, + "newHeapWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newIOCommandQueueWithDescriptor_error_, + "newIOCommandQueueWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_compressionMethod_error_, + "newIOFileHandleWithURL:compressionMethod:error:"); +_MTL_PRIVATE_DEF_SEL(newIOFileHandleWithURL_error_, + "newIOFileHandleWithURL:error:"); +_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_compressionMethod_error_, + "newIOHandleWithURL:compressionMethod:error:"); +_MTL_PRIVATE_DEF_SEL(newIOHandleWithURL_error_, + "newIOHandleWithURL:error:"); +_MTL_PRIVATE_DEF_SEL(newIndirectCommandBufferWithDescriptor_maxCommandCount_options_, + "newIndirectCommandBufferWithDescriptor:maxCommandCount:options:"); +_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_, + "newIntersectionFunctionTableWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionTableWithDescriptor_stage_, + "newIntersectionFunctionTableWithDescriptor:stage:"); +_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_completionHandler_, + "newIntersectionFunctionWithDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newIntersectionFunctionWithDescriptor_error_, + "newIntersectionFunctionWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithData_error_, + "newLibraryWithData:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithDescriptor_completionHandler_, + "newLibraryWithDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithDescriptor_error_, + "newLibraryWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithFile_error_, + "newLibraryWithFile:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_completionHandler_, + "newLibraryWithSource:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithSource_options_error_, + "newLibraryWithSource:options:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_completionHandler_, + "newLibraryWithStitchedDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithStitchedDescriptor_error_, + "newLibraryWithStitchedDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newLibraryWithURL_error_, + "newLibraryWithURL:error:"); +_MTL_PRIVATE_DEF_SEL(newLogStateWithDescriptor_error_, + "newLogStateWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newMTL4CommandQueue, + "newMTL4CommandQueue"); +_MTL_PRIVATE_DEF_SEL(newMTL4CommandQueueWithDescriptor_error_, + "newMTL4CommandQueueWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newMachineLearningPipelineStateWithDescriptor_completionHandler_, + "newMachineLearningPipelineStateWithDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newMachineLearningPipelineStateWithDescriptor_error_, + "newMachineLearningPipelineStateWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newPipelineDataSetSerializerWithDescriptor_, + "newPipelineDataSetSerializerWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newRasterizationRateMapWithDescriptor_, + "newRasterizationRateMapWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newRemoteBufferViewForDevice_, + "newRemoteBufferViewForDevice:"); +_MTL_PRIVATE_DEF_SEL(newRemoteTextureViewForDevice_, + "newRemoteTextureViewForDevice:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineDescriptorForSpecialization, + "newRenderPipelineDescriptorForSpecialization"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_completionHandler_, + "newRenderPipelineStateBySpecializationWithDescriptor:pipeline:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateBySpecializationWithDescriptor_pipeline_error_, + "newRenderPipelineStateBySpecializationWithDescriptor:pipeline:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_, + "newRenderPipelineStateWithAdditionalBinaryFunctions:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithBinaryFunctions_error_, + "newRenderPipelineStateWithBinaryFunctions:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_completionHandler_, + "newRenderPipelineStateWithDescriptor:compilerTaskOptions:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_compilerTaskOptions_error_, + "newRenderPipelineStateWithDescriptor:compilerTaskOptions:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_completionHandler_, + "newRenderPipelineStateWithDescriptor:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_completionHandler_, + "newRenderPipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_compilerTaskOptions_error_, + "newRenderPipelineStateWithDescriptor:dynamicLinkingDescriptor:compilerTaskOptions:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_dynamicLinkingDescriptor_error_, + "newRenderPipelineStateWithDescriptor:dynamicLinkingDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_error_, + "newRenderPipelineStateWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_completionHandler_, + "newRenderPipelineStateWithDescriptor:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithDescriptor_options_reflection_error_, + "newRenderPipelineStateWithDescriptor:options:reflection:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_completionHandler_, + "newRenderPipelineStateWithMeshDescriptor:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithMeshDescriptor_options_reflection_error_, + "newRenderPipelineStateWithMeshDescriptor:options:reflection:error:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_completionHandler_, + "newRenderPipelineStateWithTileDescriptor:options:completionHandler:"); +_MTL_PRIVATE_DEF_SEL(newRenderPipelineStateWithTileDescriptor_options_reflection_error_, + "newRenderPipelineStateWithTileDescriptor:options:reflection:error:"); +_MTL_PRIVATE_DEF_SEL(newResidencySetWithDescriptor_error_, + "newResidencySetWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newSamplerStateWithDescriptor_, + "newSamplerStateWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newScratchBufferWithMinimumSize_, + "newScratchBufferWithMinimumSize:"); +_MTL_PRIVATE_DEF_SEL(newSharedEvent, + "newSharedEvent"); +_MTL_PRIVATE_DEF_SEL(newSharedEventHandle, + "newSharedEventHandle"); +_MTL_PRIVATE_DEF_SEL(newSharedEventWithHandle_, + "newSharedEventWithHandle:"); +_MTL_PRIVATE_DEF_SEL(newSharedTextureHandle, + "newSharedTextureHandle"); +_MTL_PRIVATE_DEF_SEL(newSharedTextureWithDescriptor_, + "newSharedTextureWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newSharedTextureWithHandle_, + "newSharedTextureWithHandle:"); +_MTL_PRIVATE_DEF_SEL(newTensorWithDescriptor_error_, + "newTensorWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newTensorWithDescriptor_offset_error_, + "newTensorWithDescriptor:offset:error:"); +_MTL_PRIVATE_DEF_SEL(newTextureViewPoolWithDescriptor_error_, + "newTextureViewPoolWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(newTextureViewWithDescriptor_, + "newTextureViewWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_, + "newTextureViewWithPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_, + "newTextureViewWithPixelFormat:textureType:levels:slices:"); +_MTL_PRIVATE_DEF_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_, + "newTextureViewWithPixelFormat:textureType:levels:slices:swizzle:"); +_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_, + "newTextureWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_iosurface_plane_, + "newTextureWithDescriptor:iosurface:plane:"); +_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_, + "newTextureWithDescriptor:offset:"); +_MTL_PRIVATE_DEF_SEL(newTextureWithDescriptor_offset_bytesPerRow_, + "newTextureWithDescriptor:offset:bytesPerRow:"); +_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_, + "newVisibleFunctionTableWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(newVisibleFunctionTableWithDescriptor_stage_, + "newVisibleFunctionTableWithDescriptor:stage:"); +_MTL_PRIVATE_DEF_SEL(nodes, + "nodes"); +_MTL_PRIVATE_DEF_SEL(normalizedCoordinates, + "normalizedCoordinates"); +_MTL_PRIVATE_DEF_SEL(notifyListener_atValue_block_, + "notifyListener:atValue:block:"); +_MTL_PRIVATE_DEF_SEL(objectAdditionalBinaryFunctions, + "objectAdditionalBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(objectAtIndexedSubscript_, + "objectAtIndexedSubscript:"); +_MTL_PRIVATE_DEF_SEL(objectBindings, + "objectBindings"); +_MTL_PRIVATE_DEF_SEL(objectBuffers, + "objectBuffers"); +_MTL_PRIVATE_DEF_SEL(objectFunction, + "objectFunction"); +_MTL_PRIVATE_DEF_SEL(objectFunctionDescriptor, + "objectFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(objectLinkedFunctions, + "objectLinkedFunctions"); +_MTL_PRIVATE_DEF_SEL(objectLinkingDescriptor, + "objectLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(objectPayloadAlignment, + "objectPayloadAlignment"); +_MTL_PRIVATE_DEF_SEL(objectPayloadDataSize, + "objectPayloadDataSize"); +_MTL_PRIVATE_DEF_SEL(objectStaticLinkingDescriptor, + "objectStaticLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(objectThreadExecutionWidth, + "objectThreadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth, + "objectThreadgroupSizeIsMultipleOfThreadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(offset, + "offset"); +_MTL_PRIVATE_DEF_SEL(opaque, + "opaque"); +_MTL_PRIVATE_DEF_SEL(optimizationLevel, + "optimizationLevel"); +_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_, + "optimizeContentsForCPUAccess:"); +_MTL_PRIVATE_DEF_SEL(optimizeContentsForCPUAccess_slice_level_, + "optimizeContentsForCPUAccess:slice:level:"); +_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_, + "optimizeContentsForGPUAccess:"); +_MTL_PRIVATE_DEF_SEL(optimizeContentsForGPUAccess_slice_level_, + "optimizeContentsForGPUAccess:slice:level:"); +_MTL_PRIVATE_DEF_SEL(optimizeIndirectCommandBuffer_withRange_, + "optimizeIndirectCommandBuffer:withRange:"); +_MTL_PRIVATE_DEF_SEL(options, + "options"); +_MTL_PRIVATE_DEF_SEL(outputNode, + "outputNode"); +_MTL_PRIVATE_DEF_SEL(outputURL, + "outputURL"); +_MTL_PRIVATE_DEF_SEL(parallelRenderCommandEncoderWithDescriptor_, + "parallelRenderCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(parameterBufferSizeAndAlign, + "parameterBufferSizeAndAlign"); +_MTL_PRIVATE_DEF_SEL(parentRelativeLevel, + "parentRelativeLevel"); +_MTL_PRIVATE_DEF_SEL(parentRelativeSlice, + "parentRelativeSlice"); +_MTL_PRIVATE_DEF_SEL(parentTexture, + "parentTexture"); +_MTL_PRIVATE_DEF_SEL(patchControlPointCount, + "patchControlPointCount"); +_MTL_PRIVATE_DEF_SEL(patchType, + "patchType"); +_MTL_PRIVATE_DEF_SEL(payloadMemoryLength, + "payloadMemoryLength"); +_MTL_PRIVATE_DEF_SEL(peerCount, + "peerCount"); +_MTL_PRIVATE_DEF_SEL(peerGroupID, + "peerGroupID"); +_MTL_PRIVATE_DEF_SEL(peerIndex, + "peerIndex"); +_MTL_PRIVATE_DEF_SEL(physicalGranularity, + "physicalGranularity"); +_MTL_PRIVATE_DEF_SEL(physicalSizeForLayer_, + "physicalSizeForLayer:"); +_MTL_PRIVATE_DEF_SEL(pipelineDataSetSerializer, + "pipelineDataSetSerializer"); +_MTL_PRIVATE_DEF_SEL(pixelFormat, + "pixelFormat"); +_MTL_PRIVATE_DEF_SEL(placementSparsePageSize, + "placementSparsePageSize"); +_MTL_PRIVATE_DEF_SEL(pointerType, + "pointerType"); +_MTL_PRIVATE_DEF_SEL(popDebugGroup, + "popDebugGroup"); +_MTL_PRIVATE_DEF_SEL(preloadedLibraries, + "preloadedLibraries"); +_MTL_PRIVATE_DEF_SEL(preprocessorMacros, + "preprocessorMacros"); +_MTL_PRIVATE_DEF_SEL(present, + "present"); +_MTL_PRIVATE_DEF_SEL(presentAfterMinimumDuration_, + "presentAfterMinimumDuration:"); +_MTL_PRIVATE_DEF_SEL(presentAtTime_, + "presentAtTime:"); +_MTL_PRIVATE_DEF_SEL(presentDrawable_, + "presentDrawable:"); +_MTL_PRIVATE_DEF_SEL(presentDrawable_afterMinimumDuration_, + "presentDrawable:afterMinimumDuration:"); +_MTL_PRIVATE_DEF_SEL(presentDrawable_atTime_, + "presentDrawable:atTime:"); +_MTL_PRIVATE_DEF_SEL(presentedTime, + "presentedTime"); +_MTL_PRIVATE_DEF_SEL(preserveInvariance, + "preserveInvariance"); +_MTL_PRIVATE_DEF_SEL(primitiveDataBuffer, + "primitiveDataBuffer"); +_MTL_PRIVATE_DEF_SEL(primitiveDataBufferOffset, + "primitiveDataBufferOffset"); +_MTL_PRIVATE_DEF_SEL(primitiveDataElementSize, + "primitiveDataElementSize"); +_MTL_PRIVATE_DEF_SEL(primitiveDataStride, + "primitiveDataStride"); +_MTL_PRIVATE_DEF_SEL(priority, + "priority"); +_MTL_PRIVATE_DEF_SEL(privateFunctionDescriptors, + "privateFunctionDescriptors"); +_MTL_PRIVATE_DEF_SEL(privateFunctions, + "privateFunctions"); +_MTL_PRIVATE_DEF_SEL(pushDebugGroup_, + "pushDebugGroup:"); +_MTL_PRIVATE_DEF_SEL(queryTimestampFrequency, + "queryTimestampFrequency"); +_MTL_PRIVATE_DEF_SEL(rAddressMode, + "rAddressMode"); +_MTL_PRIVATE_DEF_SEL(radiusBuffer, + "radiusBuffer"); +_MTL_PRIVATE_DEF_SEL(radiusBufferOffset, + "radiusBufferOffset"); +_MTL_PRIVATE_DEF_SEL(radiusBuffers, + "radiusBuffers"); +_MTL_PRIVATE_DEF_SEL(radiusFormat, + "radiusFormat"); +_MTL_PRIVATE_DEF_SEL(radiusStride, + "radiusStride"); +_MTL_PRIVATE_DEF_SEL(rank, + "rank"); +_MTL_PRIVATE_DEF_SEL(rasterSampleCount, + "rasterSampleCount"); +_MTL_PRIVATE_DEF_SEL(rasterizationRateMap, + "rasterizationRateMap"); +_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_, + "rasterizationRateMapDescriptorWithScreenSize:"); +_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layer_, + "rasterizationRateMapDescriptorWithScreenSize:layer:"); +_MTL_PRIVATE_DEF_SEL(rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_, + "rasterizationRateMapDescriptorWithScreenSize:layerCount:layers:"); +_MTL_PRIVATE_DEF_SEL(readMask, + "readMask"); +_MTL_PRIVATE_DEF_SEL(readWriteTextureSupport, + "readWriteTextureSupport"); +_MTL_PRIVATE_DEF_SEL(recommendedMaxWorkingSetSize, + "recommendedMaxWorkingSetSize"); +_MTL_PRIVATE_DEF_SEL(reductionMode, + "reductionMode"); +_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_, + "refitAccelerationStructure:descriptor:destination:scratchBuffer:"); +_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_options_, + "refitAccelerationStructure:descriptor:destination:scratchBuffer:options:"); +_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_, + "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(refitAccelerationStructure_descriptor_destination_scratchBuffer_scratchBufferOffset_options_, + "refitAccelerationStructure:descriptor:destination:scratchBuffer:scratchBufferOffset:options:"); +_MTL_PRIVATE_DEF_SEL(reflection, + "reflection"); +_MTL_PRIVATE_DEF_SEL(reflectionForFunctionWithName_, + "reflectionForFunctionWithName:"); +_MTL_PRIVATE_DEF_SEL(registryID, + "registryID"); +_MTL_PRIVATE_DEF_SEL(remoteStorageBuffer, + "remoteStorageBuffer"); +_MTL_PRIVATE_DEF_SEL(remoteStorageTexture, + "remoteStorageTexture"); +_MTL_PRIVATE_DEF_SEL(removeAllAllocations, + "removeAllAllocations"); +_MTL_PRIVATE_DEF_SEL(removeAllDebugMarkers, + "removeAllDebugMarkers"); +_MTL_PRIVATE_DEF_SEL(removeAllocation_, + "removeAllocation:"); +_MTL_PRIVATE_DEF_SEL(removeAllocations_count_, + "removeAllocations:count:"); +_MTL_PRIVATE_DEF_SEL(removeResidencySet_, + "removeResidencySet:"); +_MTL_PRIVATE_DEF_SEL(removeResidencySets_count_, + "removeResidencySets:count:"); +_MTL_PRIVATE_DEF_SEL(renderCommandEncoder, + "renderCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(renderCommandEncoderWithDescriptor_, + "renderCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(renderCommandEncoderWithDescriptor_options_, + "renderCommandEncoderWithDescriptor:options:"); +_MTL_PRIVATE_DEF_SEL(renderPassDescriptor, + "renderPassDescriptor"); +_MTL_PRIVATE_DEF_SEL(renderTargetArrayLength, + "renderTargetArrayLength"); +_MTL_PRIVATE_DEF_SEL(renderTargetHeight, + "renderTargetHeight"); +_MTL_PRIVATE_DEF_SEL(renderTargetWidth, + "renderTargetWidth"); +_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_, + "replaceRegion:mipmapLevel:slice:withBytes:bytesPerRow:bytesPerImage:"); +_MTL_PRIVATE_DEF_SEL(replaceRegion_mipmapLevel_withBytes_bytesPerRow_, + "replaceRegion:mipmapLevel:withBytes:bytesPerRow:"); +_MTL_PRIVATE_DEF_SEL(replaceSliceOrigin_sliceDimensions_withBytes_strides_, + "replaceSliceOrigin:sliceDimensions:withBytes:strides:"); +_MTL_PRIVATE_DEF_SEL(requestResidency, + "requestResidency"); +_MTL_PRIVATE_DEF_SEL(required, + "required"); +_MTL_PRIVATE_DEF_SEL(requiredThreadsPerMeshThreadgroup, + "requiredThreadsPerMeshThreadgroup"); +_MTL_PRIVATE_DEF_SEL(requiredThreadsPerObjectThreadgroup, + "requiredThreadsPerObjectThreadgroup"); +_MTL_PRIVATE_DEF_SEL(requiredThreadsPerThreadgroup, + "requiredThreadsPerThreadgroup"); +_MTL_PRIVATE_DEF_SEL(requiredThreadsPerTileThreadgroup, + "requiredThreadsPerTileThreadgroup"); +_MTL_PRIVATE_DEF_SEL(reset, + "reset"); +_MTL_PRIVATE_DEF_SEL(resetCommandsInBuffer_withRange_, + "resetCommandsInBuffer:withRange:"); +_MTL_PRIVATE_DEF_SEL(resetTextureAccessCounters_region_mipLevel_slice_, + "resetTextureAccessCounters:region:mipLevel:slice:"); +_MTL_PRIVATE_DEF_SEL(resetWithRange_, + "resetWithRange:"); +_MTL_PRIVATE_DEF_SEL(resolveCounterHeap_withRange_intoBuffer_waitFence_updateFence_, + "resolveCounterHeap:withRange:intoBuffer:waitFence:updateFence:"); +_MTL_PRIVATE_DEF_SEL(resolveCounterRange_, + "resolveCounterRange:"); +_MTL_PRIVATE_DEF_SEL(resolveCounters_inRange_destinationBuffer_destinationOffset_, + "resolveCounters:inRange:destinationBuffer:destinationOffset:"); +_MTL_PRIVATE_DEF_SEL(resolveDepthPlane, + "resolveDepthPlane"); +_MTL_PRIVATE_DEF_SEL(resolveLevel, + "resolveLevel"); +_MTL_PRIVATE_DEF_SEL(resolveSlice, + "resolveSlice"); +_MTL_PRIVATE_DEF_SEL(resolveTexture, + "resolveTexture"); +_MTL_PRIVATE_DEF_SEL(resourceOptions, + "resourceOptions"); +_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoder, + "resourceStateCommandEncoder"); +_MTL_PRIVATE_DEF_SEL(resourceStateCommandEncoderWithDescriptor_, + "resourceStateCommandEncoderWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(resourceStatePassDescriptor, + "resourceStatePassDescriptor"); +_MTL_PRIVATE_DEF_SEL(resourceViewCount, + "resourceViewCount"); +_MTL_PRIVATE_DEF_SEL(retainedReferences, + "retainedReferences"); +_MTL_PRIVATE_DEF_SEL(rgbBlendOperation, + "rgbBlendOperation"); +_MTL_PRIVATE_DEF_SEL(rootResource, + "rootResource"); +_MTL_PRIVATE_DEF_SEL(sAddressMode, + "sAddressMode"); +_MTL_PRIVATE_DEF_SEL(sampleBuffer, + "sampleBuffer"); +_MTL_PRIVATE_DEF_SEL(sampleBufferAttachments, + "sampleBufferAttachments"); +_MTL_PRIVATE_DEF_SEL(sampleCount, + "sampleCount"); +_MTL_PRIVATE_DEF_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_, + "sampleCountersInBuffer:atSampleIndex:withBarrier:"); +_MTL_PRIVATE_DEF_SEL(sampleTimestamps_gpuTimestamp_, + "sampleTimestamps:gpuTimestamp:"); +_MTL_PRIVATE_DEF_SEL(scratchBufferAllocator, + "scratchBufferAllocator"); +_MTL_PRIVATE_DEF_SEL(screenSize, + "screenSize"); +_MTL_PRIVATE_DEF_SEL(segmentControlPointCount, + "segmentControlPointCount"); +_MTL_PRIVATE_DEF_SEL(segmentCount, + "segmentCount"); +_MTL_PRIVATE_DEF_SEL(serializeAsArchiveAndFlushToURL_error_, + "serializeAsArchiveAndFlushToURL:error:"); +_MTL_PRIVATE_DEF_SEL(serializeAsPipelinesScriptWithError_, + "serializeAsPipelinesScriptWithError:"); +_MTL_PRIVATE_DEF_SEL(serializeToURL_error_, + "serializeToURL:error:"); +_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atBufferIndex_, + "setAccelerationStructure:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setAccelerationStructure_atIndex_, + "setAccelerationStructure:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setAccess_, + "setAccess:"); +_MTL_PRIVATE_DEF_SEL(setAddress_atIndex_, + "setAddress:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setAddress_attributeStride_atIndex_, + "setAddress:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setAllowDuplicateIntersectionFunctionInvocation_, + "setAllowDuplicateIntersectionFunctionInvocation:"); +_MTL_PRIVATE_DEF_SEL(setAllowGPUOptimizedContents_, + "setAllowGPUOptimizedContents:"); +_MTL_PRIVATE_DEF_SEL(setAllowReferencingUndefinedSymbols_, + "setAllowReferencingUndefinedSymbols:"); +_MTL_PRIVATE_DEF_SEL(setAlphaBlendOperation_, + "setAlphaBlendOperation:"); +_MTL_PRIVATE_DEF_SEL(setAlphaToCoverageEnabled_, + "setAlphaToCoverageEnabled:"); +_MTL_PRIVATE_DEF_SEL(setAlphaToCoverageState_, + "setAlphaToCoverageState:"); +_MTL_PRIVATE_DEF_SEL(setAlphaToOneEnabled_, + "setAlphaToOneEnabled:"); +_MTL_PRIVATE_DEF_SEL(setAlphaToOneState_, + "setAlphaToOneState:"); +_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_offset_, + "setArgumentBuffer:offset:"); +_MTL_PRIVATE_DEF_SEL(setArgumentBuffer_startOffset_arrayElement_, + "setArgumentBuffer:startOffset:arrayElement:"); +_MTL_PRIVATE_DEF_SEL(setArgumentIndex_, + "setArgumentIndex:"); +_MTL_PRIVATE_DEF_SEL(setArgumentTable_, + "setArgumentTable:"); +_MTL_PRIVATE_DEF_SEL(setArgumentTable_atStages_, + "setArgumentTable:atStages:"); +_MTL_PRIVATE_DEF_SEL(setArguments_, + "setArguments:"); +_MTL_PRIVATE_DEF_SEL(setArrayLength_, + "setArrayLength:"); +_MTL_PRIVATE_DEF_SEL(setAttributes_, + "setAttributes:"); +_MTL_PRIVATE_DEF_SEL(setBackFaceStencil_, + "setBackFaceStencil:"); +_MTL_PRIVATE_DEF_SEL(setBarrier, + "setBarrier"); +_MTL_PRIVATE_DEF_SEL(setBinaryArchives_, + "setBinaryArchives:"); +_MTL_PRIVATE_DEF_SEL(setBinaryFunctions_, + "setBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setBinaryLinkedFunctions_, + "setBinaryLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setBlendColorRed_green_blue_alpha_, + "setBlendColorRed:green:blue:alpha:"); +_MTL_PRIVATE_DEF_SEL(setBlendingEnabled_, + "setBlendingEnabled:"); +_MTL_PRIVATE_DEF_SEL(setBlendingState_, + "setBlendingState:"); +_MTL_PRIVATE_DEF_SEL(setBorderColor_, + "setBorderColor:"); +_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffer_, + "setBoundingBoxBuffer:"); +_MTL_PRIVATE_DEF_SEL(setBoundingBoxBufferOffset_, + "setBoundingBoxBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setBoundingBoxBuffers_, + "setBoundingBoxBuffers:"); +_MTL_PRIVATE_DEF_SEL(setBoundingBoxCount_, + "setBoundingBoxCount:"); +_MTL_PRIVATE_DEF_SEL(setBoundingBoxStride_, + "setBoundingBoxStride:"); +_MTL_PRIVATE_DEF_SEL(setBuffer_, + "setBuffer:"); +_MTL_PRIVATE_DEF_SEL(setBuffer_offset_atIndex_, + "setBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setBuffer_offset_attributeStride_atIndex_, + "setBuffer:offset:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setBufferIndex_, + "setBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setBufferOffset_atIndex_, + "setBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setBufferOffset_attributeStride_atIndex_, + "setBufferOffset:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setBufferSize_, + "setBufferSize:"); +_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_attributeStrides_withRange_, + "setBuffers:offsets:attributeStrides:withRange:"); +_MTL_PRIVATE_DEF_SEL(setBuffers_offsets_withRange_, + "setBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setBytes_length_atIndex_, + "setBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setBytes_length_attributeStride_atIndex_, + "setBytes:length:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setCaptureObject_, + "setCaptureObject:"); +_MTL_PRIVATE_DEF_SEL(setClearColor_, + "setClearColor:"); +_MTL_PRIVATE_DEF_SEL(setClearDepth_, + "setClearDepth:"); +_MTL_PRIVATE_DEF_SEL(setClearStencil_, + "setClearStencil:"); +_MTL_PRIVATE_DEF_SEL(setColorAttachmentMap_, + "setColorAttachmentMap:"); +_MTL_PRIVATE_DEF_SEL(setColorAttachmentMappingState_, + "setColorAttachmentMappingState:"); +_MTL_PRIVATE_DEF_SEL(setColorStoreAction_atIndex_, + "setColorStoreAction:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setColorStoreActionOptions_atIndex_, + "setColorStoreActionOptions:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setCommandTypes_, + "setCommandTypes:"); +_MTL_PRIVATE_DEF_SEL(setCompareFunction_, + "setCompareFunction:"); +_MTL_PRIVATE_DEF_SEL(setCompileSymbolVisibility_, + "setCompileSymbolVisibility:"); +_MTL_PRIVATE_DEF_SEL(setCompressionType_, + "setCompressionType:"); +_MTL_PRIVATE_DEF_SEL(setComputeFunction_, + "setComputeFunction:"); +_MTL_PRIVATE_DEF_SEL(setComputeFunctionDescriptor_, + "setComputeFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setComputePipelineState_, + "setComputePipelineState:"); +_MTL_PRIVATE_DEF_SEL(setComputePipelineState_atIndex_, + "setComputePipelineState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setComputePipelineStates_withRange_, + "setComputePipelineStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setConfiguration_, + "setConfiguration:"); +_MTL_PRIVATE_DEF_SEL(setConstantBlockAlignment_, + "setConstantBlockAlignment:"); +_MTL_PRIVATE_DEF_SEL(setConstantValue_type_atIndex_, + "setConstantValue:type:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setConstantValue_type_withName_, + "setConstantValue:type:withName:"); +_MTL_PRIVATE_DEF_SEL(setConstantValues_, + "setConstantValues:"); +_MTL_PRIVATE_DEF_SEL(setConstantValues_type_withRange_, + "setConstantValues:type:withRange:"); +_MTL_PRIVATE_DEF_SEL(setControlDependencies_, + "setControlDependencies:"); +_MTL_PRIVATE_DEF_SEL(setControlPointBuffer_, + "setControlPointBuffer:"); +_MTL_PRIVATE_DEF_SEL(setControlPointBufferOffset_, + "setControlPointBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setControlPointBuffers_, + "setControlPointBuffers:"); +_MTL_PRIVATE_DEF_SEL(setControlPointCount_, + "setControlPointCount:"); +_MTL_PRIVATE_DEF_SEL(setControlPointFormat_, + "setControlPointFormat:"); +_MTL_PRIVATE_DEF_SEL(setControlPointStride_, + "setControlPointStride:"); +_MTL_PRIVATE_DEF_SEL(setCount_, + "setCount:"); +_MTL_PRIVATE_DEF_SEL(setCounterSet_, + "setCounterSet:"); +_MTL_PRIVATE_DEF_SEL(setCpuCacheMode_, + "setCpuCacheMode:"); +_MTL_PRIVATE_DEF_SEL(setCullMode_, + "setCullMode:"); +_MTL_PRIVATE_DEF_SEL(setCurveBasis_, + "setCurveBasis:"); +_MTL_PRIVATE_DEF_SEL(setCurveEndCaps_, + "setCurveEndCaps:"); +_MTL_PRIVATE_DEF_SEL(setCurveType_, + "setCurveType:"); +_MTL_PRIVATE_DEF_SEL(setDataType_, + "setDataType:"); +_MTL_PRIVATE_DEF_SEL(setDefaultCaptureScope_, + "setDefaultCaptureScope:"); +_MTL_PRIVATE_DEF_SEL(setDefaultRasterSampleCount_, + "setDefaultRasterSampleCount:"); +_MTL_PRIVATE_DEF_SEL(setDepth_, + "setDepth:"); +_MTL_PRIVATE_DEF_SEL(setDepthAttachment_, + "setDepthAttachment:"); +_MTL_PRIVATE_DEF_SEL(setDepthAttachmentPixelFormat_, + "setDepthAttachmentPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(setDepthBias_slopeScale_clamp_, + "setDepthBias:slopeScale:clamp:"); +_MTL_PRIVATE_DEF_SEL(setDepthClipMode_, + "setDepthClipMode:"); +_MTL_PRIVATE_DEF_SEL(setDepthCompareFunction_, + "setDepthCompareFunction:"); +_MTL_PRIVATE_DEF_SEL(setDepthFailureOperation_, + "setDepthFailureOperation:"); +_MTL_PRIVATE_DEF_SEL(setDepthPlane_, + "setDepthPlane:"); +_MTL_PRIVATE_DEF_SEL(setDepthResolveFilter_, + "setDepthResolveFilter:"); +_MTL_PRIVATE_DEF_SEL(setDepthStencilPassOperation_, + "setDepthStencilPassOperation:"); +_MTL_PRIVATE_DEF_SEL(setDepthStencilState_, + "setDepthStencilState:"); +_MTL_PRIVATE_DEF_SEL(setDepthStencilState_atIndex_, + "setDepthStencilState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setDepthStencilStates_withRange_, + "setDepthStencilStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setDepthStoreAction_, + "setDepthStoreAction:"); +_MTL_PRIVATE_DEF_SEL(setDepthStoreActionOptions_, + "setDepthStoreActionOptions:"); +_MTL_PRIVATE_DEF_SEL(setDepthTestMinBound_maxBound_, + "setDepthTestMinBound:maxBound:"); +_MTL_PRIVATE_DEF_SEL(setDepthWriteEnabled_, + "setDepthWriteEnabled:"); +_MTL_PRIVATE_DEF_SEL(setDestination_, + "setDestination:"); +_MTL_PRIVATE_DEF_SEL(setDestinationAlphaBlendFactor_, + "setDestinationAlphaBlendFactor:"); +_MTL_PRIVATE_DEF_SEL(setDestinationRGBBlendFactor_, + "setDestinationRGBBlendFactor:"); +_MTL_PRIVATE_DEF_SEL(setDimensions_, + "setDimensions:"); +_MTL_PRIVATE_DEF_SEL(setDispatchType_, + "setDispatchType:"); +_MTL_PRIVATE_DEF_SEL(setEnableLogging_, + "setEnableLogging:"); +_MTL_PRIVATE_DEF_SEL(setEndOfEncoderSampleIndex_, + "setEndOfEncoderSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setEndOfFragmentSampleIndex_, + "setEndOfFragmentSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setEndOfVertexSampleIndex_, + "setEndOfVertexSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setErrorOptions_, + "setErrorOptions:"); +_MTL_PRIVATE_DEF_SEL(setFastMathEnabled_, + "setFastMathEnabled:"); +_MTL_PRIVATE_DEF_SEL(setFeedbackQueue_, + "setFeedbackQueue:"); +_MTL_PRIVATE_DEF_SEL(setFormat_, + "setFormat:"); +_MTL_PRIVATE_DEF_SEL(setFragmentAccelerationStructure_atBufferIndex_, + "setFragmentAccelerationStructure:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentAdditionalBinaryFunctions_, + "setFragmentAdditionalBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setFragmentBuffer_offset_atIndex_, + "setFragmentBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentBufferOffset_atIndex_, + "setFragmentBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentBuffers_offsets_withRange_, + "setFragmentBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setFragmentBytes_length_atIndex_, + "setFragmentBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentFunction_, + "setFragmentFunction:"); +_MTL_PRIVATE_DEF_SEL(setFragmentFunctionDescriptor_, + "setFragmentFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_, + "setFragmentIntersectionFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentIntersectionFunctionTables_withBufferRange_, + "setFragmentIntersectionFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setFragmentLinkedFunctions_, + "setFragmentLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setFragmentPreloadedLibraries_, + "setFragmentPreloadedLibraries:"); +_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_atIndex_, + "setFragmentSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setFragmentSamplerStates_withRange_, + "setFragmentSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setFragmentStaticLinkingDescriptor_, + "setFragmentStaticLinkingDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setFragmentTexture_atIndex_, + "setFragmentTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentTextures_withRange_, + "setFragmentTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTable_atBufferIndex_, + "setFragmentVisibleFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setFragmentVisibleFunctionTables_withBufferRange_, + "setFragmentVisibleFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setFrontFaceStencil_, + "setFrontFaceStencil:"); +_MTL_PRIVATE_DEF_SEL(setFrontFacingWinding_, + "setFrontFacingWinding:"); +_MTL_PRIVATE_DEF_SEL(setFunction_atIndex_, + "setFunction:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setFunctionCount_, + "setFunctionCount:"); +_MTL_PRIVATE_DEF_SEL(setFunctionDescriptor_, + "setFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setFunctionDescriptors_, + "setFunctionDescriptors:"); +_MTL_PRIVATE_DEF_SEL(setFunctionGraph_, + "setFunctionGraph:"); +_MTL_PRIVATE_DEF_SEL(setFunctionGraphs_, + "setFunctionGraphs:"); +_MTL_PRIVATE_DEF_SEL(setFunctionName_, + "setFunctionName:"); +_MTL_PRIVATE_DEF_SEL(setFunctions_, + "setFunctions:"); +_MTL_PRIVATE_DEF_SEL(setFunctions_withRange_, + "setFunctions:withRange:"); +_MTL_PRIVATE_DEF_SEL(setGeometryDescriptors_, + "setGeometryDescriptors:"); +_MTL_PRIVATE_DEF_SEL(setGroups_, + "setGroups:"); +_MTL_PRIVATE_DEF_SEL(setHazardTrackingMode_, + "setHazardTrackingMode:"); +_MTL_PRIVATE_DEF_SEL(setHeight_, + "setHeight:"); +_MTL_PRIVATE_DEF_SEL(setImageblockSampleLength_, + "setImageblockSampleLength:"); +_MTL_PRIVATE_DEF_SEL(setImageblockWidth_height_, + "setImageblockWidth:height:"); +_MTL_PRIVATE_DEF_SEL(setIndex_, + "setIndex:"); +_MTL_PRIVATE_DEF_SEL(setIndexBuffer_, + "setIndexBuffer:"); +_MTL_PRIVATE_DEF_SEL(setIndexBufferIndex_, + "setIndexBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setIndexBufferOffset_, + "setIndexBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setIndexType_, + "setIndexType:"); +_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffer_atIndex_, + "setIndirectCommandBuffer:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setIndirectCommandBuffers_withRange_, + "setIndirectCommandBuffers:withRange:"); +_MTL_PRIVATE_DEF_SEL(setInheritBuffers_, + "setInheritBuffers:"); +_MTL_PRIVATE_DEF_SEL(setInheritCullMode_, + "setInheritCullMode:"); +_MTL_PRIVATE_DEF_SEL(setInheritDepthBias_, + "setInheritDepthBias:"); +_MTL_PRIVATE_DEF_SEL(setInheritDepthClipMode_, + "setInheritDepthClipMode:"); +_MTL_PRIVATE_DEF_SEL(setInheritDepthStencilState_, + "setInheritDepthStencilState:"); +_MTL_PRIVATE_DEF_SEL(setInheritFrontFacingWinding_, + "setInheritFrontFacingWinding:"); +_MTL_PRIVATE_DEF_SEL(setInheritPipelineState_, + "setInheritPipelineState:"); +_MTL_PRIVATE_DEF_SEL(setInheritTriangleFillMode_, + "setInheritTriangleFillMode:"); +_MTL_PRIVATE_DEF_SEL(setInitialCapacity_, + "setInitialCapacity:"); +_MTL_PRIVATE_DEF_SEL(setInitializeBindings_, + "setInitializeBindings:"); +_MTL_PRIVATE_DEF_SEL(setInputDimensions_atBufferIndex_, + "setInputDimensions:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setInputDimensions_withRange_, + "setInputDimensions:withRange:"); +_MTL_PRIVATE_DEF_SEL(setInputPrimitiveTopology_, + "setInputPrimitiveTopology:"); +_MTL_PRIVATE_DEF_SEL(setInsertLibraries_, + "setInsertLibraries:"); +_MTL_PRIVATE_DEF_SEL(setInstallName_, + "setInstallName:"); +_MTL_PRIVATE_DEF_SEL(setInstanceCount_, + "setInstanceCount:"); +_MTL_PRIVATE_DEF_SEL(setInstanceCountBuffer_, + "setInstanceCountBuffer:"); +_MTL_PRIVATE_DEF_SEL(setInstanceCountBufferOffset_, + "setInstanceCountBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBuffer_, + "setInstanceDescriptorBuffer:"); +_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorBufferOffset_, + "setInstanceDescriptorBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorStride_, + "setInstanceDescriptorStride:"); +_MTL_PRIVATE_DEF_SEL(setInstanceDescriptorType_, + "setInstanceDescriptorType:"); +_MTL_PRIVATE_DEF_SEL(setInstanceTransformationMatrixLayout_, + "setInstanceTransformationMatrixLayout:"); +_MTL_PRIVATE_DEF_SEL(setInstancedAccelerationStructures_, + "setInstancedAccelerationStructures:"); +_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atBufferIndex_, + "setIntersectionFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTable_atIndex_, + "setIntersectionFunctionTable:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTableOffset_, + "setIntersectionFunctionTableOffset:"); +_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withBufferRange_, + "setIntersectionFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setIntersectionFunctionTables_withRange_, + "setIntersectionFunctionTables:withRange:"); +_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_atIndex_, + "setKernelBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setKernelBuffer_offset_attributeStride_atIndex_, + "setKernelBuffer:offset:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setLabel_, + "setLabel:"); +_MTL_PRIVATE_DEF_SEL(setLanguageVersion_, + "setLanguageVersion:"); +_MTL_PRIVATE_DEF_SEL(setLayer_atIndex_, + "setLayer:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setLevel_, + "setLevel:"); +_MTL_PRIVATE_DEF_SEL(setLevelRange_, + "setLevelRange:"); +_MTL_PRIVATE_DEF_SEL(setLibraries_, + "setLibraries:"); +_MTL_PRIVATE_DEF_SEL(setLibrary_, + "setLibrary:"); +_MTL_PRIVATE_DEF_SEL(setLibraryType_, + "setLibraryType:"); +_MTL_PRIVATE_DEF_SEL(setLinkedFunctions_, + "setLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setLoadAction_, + "setLoadAction:"); +_MTL_PRIVATE_DEF_SEL(setLodAverage_, + "setLodAverage:"); +_MTL_PRIVATE_DEF_SEL(setLodBias_, + "setLodBias:"); +_MTL_PRIVATE_DEF_SEL(setLodMaxClamp_, + "setLodMaxClamp:"); +_MTL_PRIVATE_DEF_SEL(setLodMinClamp_, + "setLodMinClamp:"); +_MTL_PRIVATE_DEF_SEL(setLogState_, + "setLogState:"); +_MTL_PRIVATE_DEF_SEL(setLookupArchives_, + "setLookupArchives:"); +_MTL_PRIVATE_DEF_SEL(setMachineLearningFunctionDescriptor_, + "setMachineLearningFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setMagFilter_, + "setMagFilter:"); +_MTL_PRIVATE_DEF_SEL(setMathFloatingPointFunctions_, + "setMathFloatingPointFunctions:"); +_MTL_PRIVATE_DEF_SEL(setMathMode_, + "setMathMode:"); +_MTL_PRIVATE_DEF_SEL(setMaxAnisotropy_, + "setMaxAnisotropy:"); +_MTL_PRIVATE_DEF_SEL(setMaxBufferBindCount_, + "setMaxBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxCallStackDepth_, + "setMaxCallStackDepth:"); +_MTL_PRIVATE_DEF_SEL(setMaxCommandBufferCount_, + "setMaxCommandBufferCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxCommandsInFlight_, + "setMaxCommandsInFlight:"); +_MTL_PRIVATE_DEF_SEL(setMaxCompatiblePlacementSparsePageSize_, + "setMaxCompatiblePlacementSparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(setMaxFragmentBufferBindCount_, + "setMaxFragmentBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxFragmentCallStackDepth_, + "setMaxFragmentCallStackDepth:"); +_MTL_PRIVATE_DEF_SEL(setMaxInstanceCount_, + "setMaxInstanceCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxKernelBufferBindCount_, + "setMaxKernelBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxKernelThreadgroupMemoryBindCount_, + "setMaxKernelThreadgroupMemoryBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxMeshBufferBindCount_, + "setMaxMeshBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxMotionTransformCount_, + "setMaxMotionTransformCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxObjectBufferBindCount_, + "setMaxObjectBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxObjectThreadgroupMemoryBindCount_, + "setMaxObjectThreadgroupMemoryBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxSamplerStateBindCount_, + "setMaxSamplerStateBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxTessellationFactor_, + "setMaxTessellationFactor:"); +_MTL_PRIVATE_DEF_SEL(setMaxTextureBindCount_, + "setMaxTextureBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadgroupsPerMeshGrid_, + "setMaxTotalThreadgroupsPerMeshGrid:"); +_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerMeshThreadgroup_, + "setMaxTotalThreadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerObjectThreadgroup_, + "setMaxTotalThreadsPerObjectThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setMaxTotalThreadsPerThreadgroup_, + "setMaxTotalThreadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setMaxVertexAmplificationCount_, + "setMaxVertexAmplificationCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxVertexBufferBindCount_, + "setMaxVertexBufferBindCount:"); +_MTL_PRIVATE_DEF_SEL(setMaxVertexCallStackDepth_, + "setMaxVertexCallStackDepth:"); +_MTL_PRIVATE_DEF_SEL(setMeshAdditionalBinaryFunctions_, + "setMeshAdditionalBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setMeshBuffer_offset_atIndex_, + "setMeshBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshBufferOffset_atIndex_, + "setMeshBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshBuffers_offsets_withRange_, + "setMeshBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setMeshBytes_length_atIndex_, + "setMeshBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshFunction_, + "setMeshFunction:"); +_MTL_PRIVATE_DEF_SEL(setMeshFunctionDescriptor_, + "setMeshFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setMeshLinkedFunctions_, + "setMeshLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_atIndex_, + "setMeshSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setMeshSamplerStates_withRange_, + "setMeshSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setMeshStaticLinkingDescriptor_, + "setMeshStaticLinkingDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setMeshTexture_atIndex_, + "setMeshTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setMeshTextures_withRange_, + "setMeshTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_, + "setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth:"); +_MTL_PRIVATE_DEF_SEL(setMinFilter_, + "setMinFilter:"); +_MTL_PRIVATE_DEF_SEL(setMipFilter_, + "setMipFilter:"); +_MTL_PRIVATE_DEF_SEL(setMipmapLevelCount_, + "setMipmapLevelCount:"); +_MTL_PRIVATE_DEF_SEL(setMotionEndBorderMode_, + "setMotionEndBorderMode:"); +_MTL_PRIVATE_DEF_SEL(setMotionEndTime_, + "setMotionEndTime:"); +_MTL_PRIVATE_DEF_SEL(setMotionKeyframeCount_, + "setMotionKeyframeCount:"); +_MTL_PRIVATE_DEF_SEL(setMotionStartBorderMode_, + "setMotionStartBorderMode:"); +_MTL_PRIVATE_DEF_SEL(setMotionStartTime_, + "setMotionStartTime:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformBuffer_, + "setMotionTransformBuffer:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformBufferOffset_, + "setMotionTransformBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformCount_, + "setMotionTransformCount:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBuffer_, + "setMotionTransformCountBuffer:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformCountBufferOffset_, + "setMotionTransformCountBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformStride_, + "setMotionTransformStride:"); +_MTL_PRIVATE_DEF_SEL(setMotionTransformType_, + "setMotionTransformType:"); +_MTL_PRIVATE_DEF_SEL(setMutability_, + "setMutability:"); +_MTL_PRIVATE_DEF_SEL(setName_, + "setName:"); +_MTL_PRIVATE_DEF_SEL(setNodes_, + "setNodes:"); +_MTL_PRIVATE_DEF_SEL(setNormalizedCoordinates_, + "setNormalizedCoordinates:"); +_MTL_PRIVATE_DEF_SEL(setObject_atIndexedSubscript_, + "setObject:atIndexedSubscript:"); +_MTL_PRIVATE_DEF_SEL(setObjectAdditionalBinaryFunctions_, + "setObjectAdditionalBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setObjectBuffer_offset_atIndex_, + "setObjectBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectBufferOffset_atIndex_, + "setObjectBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectBuffers_offsets_withRange_, + "setObjectBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setObjectBytes_length_atIndex_, + "setObjectBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectFunction_, + "setObjectFunction:"); +_MTL_PRIVATE_DEF_SEL(setObjectFunctionDescriptor_, + "setObjectFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setObjectLinkedFunctions_, + "setObjectLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_atIndex_, + "setObjectSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setObjectSamplerStates_withRange_, + "setObjectSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setObjectStaticLinkingDescriptor_, + "setObjectStaticLinkingDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setObjectTexture_atIndex_, + "setObjectTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectTextures_withRange_, + "setObjectTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupMemoryLength_atIndex_, + "setObjectThreadgroupMemoryLength:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_, + "setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth:"); +_MTL_PRIVATE_DEF_SEL(setOffset_, + "setOffset:"); +_MTL_PRIVATE_DEF_SEL(setOpaque_, + "setOpaque:"); +_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_, + "setOpaqueCurveIntersectionFunctionWithSignature:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_, + "setOpaqueCurveIntersectionFunctionWithSignature:withRange:"); +_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_, + "setOpaqueTriangleIntersectionFunctionWithSignature:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_, + "setOpaqueTriangleIntersectionFunctionWithSignature:withRange:"); +_MTL_PRIVATE_DEF_SEL(setOptimizationLevel_, + "setOptimizationLevel:"); +_MTL_PRIVATE_DEF_SEL(setOptions_, + "setOptions:"); +_MTL_PRIVATE_DEF_SEL(setOutputNode_, + "setOutputNode:"); +_MTL_PRIVATE_DEF_SEL(setOutputURL_, + "setOutputURL:"); +_MTL_PRIVATE_DEF_SEL(setOwnerWithIdentity_, + "setOwnerWithIdentity:"); +_MTL_PRIVATE_DEF_SEL(setPayloadMemoryLength_, + "setPayloadMemoryLength:"); +_MTL_PRIVATE_DEF_SEL(setPhysicalIndex_forLogicalIndex_, + "setPhysicalIndex:forLogicalIndex:"); +_MTL_PRIVATE_DEF_SEL(setPipelineDataSetSerializer_, + "setPipelineDataSetSerializer:"); +_MTL_PRIVATE_DEF_SEL(setPipelineState_, + "setPipelineState:"); +_MTL_PRIVATE_DEF_SEL(setPixelFormat_, + "setPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(setPlacementSparsePageSize_, + "setPlacementSparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(setPreloadedLibraries_, + "setPreloadedLibraries:"); +_MTL_PRIVATE_DEF_SEL(setPreprocessorMacros_, + "setPreprocessorMacros:"); +_MTL_PRIVATE_DEF_SEL(setPreserveInvariance_, + "setPreserveInvariance:"); +_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBuffer_, + "setPrimitiveDataBuffer:"); +_MTL_PRIVATE_DEF_SEL(setPrimitiveDataBufferOffset_, + "setPrimitiveDataBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setPrimitiveDataElementSize_, + "setPrimitiveDataElementSize:"); +_MTL_PRIVATE_DEF_SEL(setPrimitiveDataStride_, + "setPrimitiveDataStride:"); +_MTL_PRIVATE_DEF_SEL(setPriority_, + "setPriority:"); +_MTL_PRIVATE_DEF_SEL(setPrivateFunctionDescriptors_, + "setPrivateFunctionDescriptors:"); +_MTL_PRIVATE_DEF_SEL(setPrivateFunctions_, + "setPrivateFunctions:"); +_MTL_PRIVATE_DEF_SEL(setPurgeableState_, + "setPurgeableState:"); +_MTL_PRIVATE_DEF_SEL(setRAddressMode_, + "setRAddressMode:"); +_MTL_PRIVATE_DEF_SEL(setRadiusBuffer_, + "setRadiusBuffer:"); +_MTL_PRIVATE_DEF_SEL(setRadiusBufferOffset_, + "setRadiusBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setRadiusBuffers_, + "setRadiusBuffers:"); +_MTL_PRIVATE_DEF_SEL(setRadiusFormat_, + "setRadiusFormat:"); +_MTL_PRIVATE_DEF_SEL(setRadiusStride_, + "setRadiusStride:"); +_MTL_PRIVATE_DEF_SEL(setRasterSampleCount_, + "setRasterSampleCount:"); +_MTL_PRIVATE_DEF_SEL(setRasterizationEnabled_, + "setRasterizationEnabled:"); +_MTL_PRIVATE_DEF_SEL(setRasterizationRateMap_, + "setRasterizationRateMap:"); +_MTL_PRIVATE_DEF_SEL(setReadMask_, + "setReadMask:"); +_MTL_PRIVATE_DEF_SEL(setReductionMode_, + "setReductionMode:"); +_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_, + "setRenderPipelineState:"); +_MTL_PRIVATE_DEF_SEL(setRenderPipelineState_atIndex_, + "setRenderPipelineState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setRenderPipelineStates_withRange_, + "setRenderPipelineStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setRenderTargetArrayLength_, + "setRenderTargetArrayLength:"); +_MTL_PRIVATE_DEF_SEL(setRenderTargetHeight_, + "setRenderTargetHeight:"); +_MTL_PRIVATE_DEF_SEL(setRenderTargetWidth_, + "setRenderTargetWidth:"); +_MTL_PRIVATE_DEF_SEL(setRequiredThreadsPerMeshThreadgroup_, + "setRequiredThreadsPerMeshThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setRequiredThreadsPerObjectThreadgroup_, + "setRequiredThreadsPerObjectThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setRequiredThreadsPerThreadgroup_, + "setRequiredThreadsPerThreadgroup:"); +_MTL_PRIVATE_DEF_SEL(setResolveDepthPlane_, + "setResolveDepthPlane:"); +_MTL_PRIVATE_DEF_SEL(setResolveLevel_, + "setResolveLevel:"); +_MTL_PRIVATE_DEF_SEL(setResolveSlice_, + "setResolveSlice:"); +_MTL_PRIVATE_DEF_SEL(setResolveTexture_, + "setResolveTexture:"); +_MTL_PRIVATE_DEF_SEL(setResource_atBufferIndex_, + "setResource:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setResourceOptions_, + "setResourceOptions:"); +_MTL_PRIVATE_DEF_SEL(setResourceViewCount_, + "setResourceViewCount:"); +_MTL_PRIVATE_DEF_SEL(setRetainedReferences_, + "setRetainedReferences:"); +_MTL_PRIVATE_DEF_SEL(setRgbBlendOperation_, + "setRgbBlendOperation:"); +_MTL_PRIVATE_DEF_SEL(setSAddressMode_, + "setSAddressMode:"); +_MTL_PRIVATE_DEF_SEL(setSampleBuffer_, + "setSampleBuffer:"); +_MTL_PRIVATE_DEF_SEL(setSampleCount_, + "setSampleCount:"); +_MTL_PRIVATE_DEF_SEL(setSamplePositions_count_, + "setSamplePositions:count:"); +_MTL_PRIVATE_DEF_SEL(setSamplerState_atIndex_, + "setSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setSamplerStates_withRange_, + "setSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setScissorRect_, + "setScissorRect:"); +_MTL_PRIVATE_DEF_SEL(setScissorRects_count_, + "setScissorRects:count:"); +_MTL_PRIVATE_DEF_SEL(setScratchBufferAllocator_, + "setScratchBufferAllocator:"); +_MTL_PRIVATE_DEF_SEL(setScreenSize_, + "setScreenSize:"); +_MTL_PRIVATE_DEF_SEL(setSegmentControlPointCount_, + "setSegmentControlPointCount:"); +_MTL_PRIVATE_DEF_SEL(setSegmentCount_, + "setSegmentCount:"); +_MTL_PRIVATE_DEF_SEL(setShaderReflection_, + "setShaderReflection:"); +_MTL_PRIVATE_DEF_SEL(setShaderValidation_, + "setShaderValidation:"); +_MTL_PRIVATE_DEF_SEL(setShouldMaximizeConcurrentCompilation_, + "setShouldMaximizeConcurrentCompilation:"); +_MTL_PRIVATE_DEF_SEL(setSignaledValue_, + "setSignaledValue:"); +_MTL_PRIVATE_DEF_SEL(setSize_, + "setSize:"); +_MTL_PRIVATE_DEF_SEL(setSlice_, + "setSlice:"); +_MTL_PRIVATE_DEF_SEL(setSliceRange_, + "setSliceRange:"); +_MTL_PRIVATE_DEF_SEL(setSource_, + "setSource:"); +_MTL_PRIVATE_DEF_SEL(setSourceAlphaBlendFactor_, + "setSourceAlphaBlendFactor:"); +_MTL_PRIVATE_DEF_SEL(setSourceRGBBlendFactor_, + "setSourceRGBBlendFactor:"); +_MTL_PRIVATE_DEF_SEL(setSparsePageSize_, + "setSparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(setSpecializedName_, + "setSpecializedName:"); +_MTL_PRIVATE_DEF_SEL(setStageInRegion_, + "setStageInRegion:"); +_MTL_PRIVATE_DEF_SEL(setStageInRegionWithIndirectBuffer_indirectBufferOffset_, + "setStageInRegionWithIndirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setStageInputDescriptor_, + "setStageInputDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setStartOfEncoderSampleIndex_, + "setStartOfEncoderSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setStartOfFragmentSampleIndex_, + "setStartOfFragmentSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setStartOfVertexSampleIndex_, + "setStartOfVertexSampleIndex:"); +_MTL_PRIVATE_DEF_SEL(setStaticLinkingDescriptor_, + "setStaticLinkingDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setStencilAttachment_, + "setStencilAttachment:"); +_MTL_PRIVATE_DEF_SEL(setStencilAttachmentPixelFormat_, + "setStencilAttachmentPixelFormat:"); +_MTL_PRIVATE_DEF_SEL(setStencilCompareFunction_, + "setStencilCompareFunction:"); +_MTL_PRIVATE_DEF_SEL(setStencilFailureOperation_, + "setStencilFailureOperation:"); +_MTL_PRIVATE_DEF_SEL(setStencilFrontReferenceValue_backReferenceValue_, + "setStencilFrontReferenceValue:backReferenceValue:"); +_MTL_PRIVATE_DEF_SEL(setStencilReferenceValue_, + "setStencilReferenceValue:"); +_MTL_PRIVATE_DEF_SEL(setStencilResolveFilter_, + "setStencilResolveFilter:"); +_MTL_PRIVATE_DEF_SEL(setStencilStoreAction_, + "setStencilStoreAction:"); +_MTL_PRIVATE_DEF_SEL(setStencilStoreActionOptions_, + "setStencilStoreActionOptions:"); +_MTL_PRIVATE_DEF_SEL(setStepFunction_, + "setStepFunction:"); +_MTL_PRIVATE_DEF_SEL(setStepRate_, + "setStepRate:"); +_MTL_PRIVATE_DEF_SEL(setStorageMode_, + "setStorageMode:"); +_MTL_PRIVATE_DEF_SEL(setStoreAction_, + "setStoreAction:"); +_MTL_PRIVATE_DEF_SEL(setStoreActionOptions_, + "setStoreActionOptions:"); +_MTL_PRIVATE_DEF_SEL(setStride_, + "setStride:"); +_MTL_PRIVATE_DEF_SEL(setStrides_, + "setStrides:"); +_MTL_PRIVATE_DEF_SEL(setSupportAddingBinaryFunctions_, + "setSupportAddingBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setSupportAddingFragmentBinaryFunctions_, + "setSupportAddingFragmentBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setSupportAddingVertexBinaryFunctions_, + "setSupportAddingVertexBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setSupportArgumentBuffers_, + "setSupportArgumentBuffers:"); +_MTL_PRIVATE_DEF_SEL(setSupportAttributeStrides_, + "setSupportAttributeStrides:"); +_MTL_PRIVATE_DEF_SEL(setSupportBinaryLinking_, + "setSupportBinaryLinking:"); +_MTL_PRIVATE_DEF_SEL(setSupportColorAttachmentMapping_, + "setSupportColorAttachmentMapping:"); +_MTL_PRIVATE_DEF_SEL(setSupportDynamicAttributeStride_, + "setSupportDynamicAttributeStride:"); +_MTL_PRIVATE_DEF_SEL(setSupportFragmentBinaryLinking_, + "setSupportFragmentBinaryLinking:"); +_MTL_PRIVATE_DEF_SEL(setSupportIndirectCommandBuffers_, + "setSupportIndirectCommandBuffers:"); +_MTL_PRIVATE_DEF_SEL(setSupportMeshBinaryLinking_, + "setSupportMeshBinaryLinking:"); +_MTL_PRIVATE_DEF_SEL(setSupportObjectBinaryLinking_, + "setSupportObjectBinaryLinking:"); +_MTL_PRIVATE_DEF_SEL(setSupportRayTracing_, + "setSupportRayTracing:"); +_MTL_PRIVATE_DEF_SEL(setSupportVertexBinaryLinking_, + "setSupportVertexBinaryLinking:"); +_MTL_PRIVATE_DEF_SEL(setSwizzle_, + "setSwizzle:"); +_MTL_PRIVATE_DEF_SEL(setTAddressMode_, + "setTAddressMode:"); +_MTL_PRIVATE_DEF_SEL(setTessellationControlPointIndexType_, + "setTessellationControlPointIndexType:"); +_MTL_PRIVATE_DEF_SEL(setTessellationFactorBuffer_offset_instanceStride_, + "setTessellationFactorBuffer:offset:instanceStride:"); +_MTL_PRIVATE_DEF_SEL(setTessellationFactorFormat_, + "setTessellationFactorFormat:"); +_MTL_PRIVATE_DEF_SEL(setTessellationFactorScale_, + "setTessellationFactorScale:"); +_MTL_PRIVATE_DEF_SEL(setTessellationFactorScaleEnabled_, + "setTessellationFactorScaleEnabled:"); +_MTL_PRIVATE_DEF_SEL(setTessellationFactorStepFunction_, + "setTessellationFactorStepFunction:"); +_MTL_PRIVATE_DEF_SEL(setTessellationOutputWindingOrder_, + "setTessellationOutputWindingOrder:"); +_MTL_PRIVATE_DEF_SEL(setTessellationPartitionMode_, + "setTessellationPartitionMode:"); +_MTL_PRIVATE_DEF_SEL(setTexture_, + "setTexture:"); +_MTL_PRIVATE_DEF_SEL(setTexture_atIndex_, + "setTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTextureType_, + "setTextureType:"); +_MTL_PRIVATE_DEF_SEL(setTextureView_atIndex_, + "setTextureView:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTextureView_descriptor_atIndex_, + "setTextureView:descriptor:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTextureViewFromBuffer_descriptor_offset_bytesPerRow_atIndex_, + "setTextureViewFromBuffer:descriptor:offset:bytesPerRow:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTextures_withRange_, + "setTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setThreadGroupSizeIsMultipleOfThreadExecutionWidth_, + "setThreadGroupSizeIsMultipleOfThreadExecutionWidth:"); +_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_, + "setThreadgroupMemoryLength:"); +_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_atIndex_, + "setThreadgroupMemoryLength:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setThreadgroupMemoryLength_offset_atIndex_, + "setThreadgroupMemoryLength:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setThreadgroupSizeMatchesTileSize_, + "setThreadgroupSizeMatchesTileSize:"); +_MTL_PRIVATE_DEF_SEL(setTileAccelerationStructure_atBufferIndex_, + "setTileAccelerationStructure:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileAdditionalBinaryFunctions_, + "setTileAdditionalBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setTileBuffer_offset_atIndex_, + "setTileBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileBufferOffset_atIndex_, + "setTileBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileBuffers_offsets_withRange_, + "setTileBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setTileBytes_length_atIndex_, + "setTileBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileFunction_, + "setTileFunction:"); +_MTL_PRIVATE_DEF_SEL(setTileFunctionDescriptor_, + "setTileFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setTileHeight_, + "setTileHeight:"); +_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTable_atBufferIndex_, + "setTileIntersectionFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileIntersectionFunctionTables_withBufferRange_, + "setTileIntersectionFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setTileSamplerState_atIndex_, + "setTileSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setTileSamplerStates_withRange_, + "setTileSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setTileTexture_atIndex_, + "setTileTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileTextures_withRange_, + "setTileTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTable_atBufferIndex_, + "setTileVisibleFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setTileVisibleFunctionTables_withBufferRange_, + "setTileVisibleFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setTileWidth_, + "setTileWidth:"); +_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBuffer_, + "setTransformationMatrixBuffer:"); +_MTL_PRIVATE_DEF_SEL(setTransformationMatrixBufferOffset_, + "setTransformationMatrixBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setTransformationMatrixLayout_, + "setTransformationMatrixLayout:"); +_MTL_PRIVATE_DEF_SEL(setTriangleCount_, + "setTriangleCount:"); +_MTL_PRIVATE_DEF_SEL(setTriangleFillMode_, + "setTriangleFillMode:"); +_MTL_PRIVATE_DEF_SEL(setType_, + "setType:"); +_MTL_PRIVATE_DEF_SEL(setUrl_, + "setUrl:"); +_MTL_PRIVATE_DEF_SEL(setUsage_, + "setUsage:"); +_MTL_PRIVATE_DEF_SEL(setVertexAccelerationStructure_atBufferIndex_, + "setVertexAccelerationStructure:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexAdditionalBinaryFunctions_, + "setVertexAdditionalBinaryFunctions:"); +_MTL_PRIVATE_DEF_SEL(setVertexAmplificationCount_viewMappings_, + "setVertexAmplificationCount:viewMappings:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffer_, + "setVertexBuffer:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_atIndex_, + "setVertexBuffer:offset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffer_offset_attributeStride_atIndex_, + "setVertexBuffer:offset:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_, + "setVertexBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_atIndex_, + "setVertexBufferOffset:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexBufferOffset_attributeStride_atIndex_, + "setVertexBufferOffset:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffers_, + "setVertexBuffers:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_attributeStrides_withRange_, + "setVertexBuffers:offsets:attributeStrides:withRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexBuffers_offsets_withRange_, + "setVertexBuffers:offsets:withRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_atIndex_, + "setVertexBytes:length:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexBytes_length_attributeStride_atIndex_, + "setVertexBytes:length:attributeStride:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexDescriptor_, + "setVertexDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setVertexFormat_, + "setVertexFormat:"); +_MTL_PRIVATE_DEF_SEL(setVertexFunction_, + "setVertexFunction:"); +_MTL_PRIVATE_DEF_SEL(setVertexFunctionDescriptor_, + "setVertexFunctionDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTable_atBufferIndex_, + "setVertexIntersectionFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexIntersectionFunctionTables_withBufferRange_, + "setVertexIntersectionFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexLinkedFunctions_, + "setVertexLinkedFunctions:"); +_MTL_PRIVATE_DEF_SEL(setVertexPreloadedLibraries_, + "setVertexPreloadedLibraries:"); +_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_atIndex_, + "setVertexSamplerState:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_, + "setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_, + "setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexSamplerStates_withRange_, + "setVertexSamplerStates:withRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexStaticLinkingDescriptor_, + "setVertexStaticLinkingDescriptor:"); +_MTL_PRIVATE_DEF_SEL(setVertexStride_, + "setVertexStride:"); +_MTL_PRIVATE_DEF_SEL(setVertexTexture_atIndex_, + "setVertexTexture:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexTextures_withRange_, + "setVertexTextures:withRange:"); +_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTable_atBufferIndex_, + "setVertexVisibleFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setVertexVisibleFunctionTables_withBufferRange_, + "setVertexVisibleFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setViewport_, + "setViewport:"); +_MTL_PRIVATE_DEF_SEL(setViewports_count_, + "setViewports:count:"); +_MTL_PRIVATE_DEF_SEL(setVisibilityResultBuffer_, + "setVisibilityResultBuffer:"); +_MTL_PRIVATE_DEF_SEL(setVisibilityResultMode_offset_, + "setVisibilityResultMode:offset:"); +_MTL_PRIVATE_DEF_SEL(setVisibilityResultType_, + "setVisibilityResultType:"); +_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atBufferIndex_, + "setVisibleFunctionTable:atBufferIndex:"); +_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTable_atIndex_, + "setVisibleFunctionTable:atIndex:"); +_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withBufferRange_, + "setVisibleFunctionTables:withBufferRange:"); +_MTL_PRIVATE_DEF_SEL(setVisibleFunctionTables_withRange_, + "setVisibleFunctionTables:withRange:"); +_MTL_PRIVATE_DEF_SEL(setWidth_, + "setWidth:"); +_MTL_PRIVATE_DEF_SEL(setWriteMask_, + "setWriteMask:"); +_MTL_PRIVATE_DEF_SEL(shaderReflection, + "shaderReflection"); +_MTL_PRIVATE_DEF_SEL(shaderValidation, + "shaderValidation"); +_MTL_PRIVATE_DEF_SEL(sharedCaptureManager, + "sharedCaptureManager"); +_MTL_PRIVATE_DEF_SEL(sharedListener, + "sharedListener"); +_MTL_PRIVATE_DEF_SEL(shouldMaximizeConcurrentCompilation, + "shouldMaximizeConcurrentCompilation"); +_MTL_PRIVATE_DEF_SEL(signalDrawable_, + "signalDrawable:"); +_MTL_PRIVATE_DEF_SEL(signalEvent_value_, + "signalEvent:value:"); +_MTL_PRIVATE_DEF_SEL(signaledValue, + "signaledValue"); +_MTL_PRIVATE_DEF_SEL(size, + "size"); +_MTL_PRIVATE_DEF_SEL(sizeOfCounterHeapEntry_, + "sizeOfCounterHeapEntry:"); +_MTL_PRIVATE_DEF_SEL(slice, + "slice"); +_MTL_PRIVATE_DEF_SEL(sliceRange, + "sliceRange"); +_MTL_PRIVATE_DEF_SEL(source, + "source"); +_MTL_PRIVATE_DEF_SEL(sourceAlphaBlendFactor, + "sourceAlphaBlendFactor"); +_MTL_PRIVATE_DEF_SEL(sourceRGBBlendFactor, + "sourceRGBBlendFactor"); +_MTL_PRIVATE_DEF_SEL(sparseBufferTier, + "sparseBufferTier"); +_MTL_PRIVATE_DEF_SEL(sparsePageSize, + "sparsePageSize"); +_MTL_PRIVATE_DEF_SEL(sparseTextureTier, + "sparseTextureTier"); +_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytes, + "sparseTileSizeInBytes"); +_MTL_PRIVATE_DEF_SEL(sparseTileSizeInBytesForSparsePageSize_, + "sparseTileSizeInBytesForSparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_, + "sparseTileSizeWithTextureType:pixelFormat:sampleCount:"); +_MTL_PRIVATE_DEF_SEL(sparseTileSizeWithTextureType_pixelFormat_sampleCount_sparsePageSize_, + "sparseTileSizeWithTextureType:pixelFormat:sampleCount:sparsePageSize:"); +_MTL_PRIVATE_DEF_SEL(specializedName, + "specializedName"); +_MTL_PRIVATE_DEF_SEL(stageInputAttributes, + "stageInputAttributes"); +_MTL_PRIVATE_DEF_SEL(stageInputDescriptor, + "stageInputDescriptor"); +_MTL_PRIVATE_DEF_SEL(stageInputOutputDescriptor, + "stageInputOutputDescriptor"); +_MTL_PRIVATE_DEF_SEL(stages, + "stages"); +_MTL_PRIVATE_DEF_SEL(startCaptureWithCommandQueue_, + "startCaptureWithCommandQueue:"); +_MTL_PRIVATE_DEF_SEL(startCaptureWithDescriptor_error_, + "startCaptureWithDescriptor:error:"); +_MTL_PRIVATE_DEF_SEL(startCaptureWithDevice_, + "startCaptureWithDevice:"); +_MTL_PRIVATE_DEF_SEL(startCaptureWithScope_, + "startCaptureWithScope:"); +_MTL_PRIVATE_DEF_SEL(startOfEncoderSampleIndex, + "startOfEncoderSampleIndex"); +_MTL_PRIVATE_DEF_SEL(startOfFragmentSampleIndex, + "startOfFragmentSampleIndex"); +_MTL_PRIVATE_DEF_SEL(startOfVertexSampleIndex, + "startOfVertexSampleIndex"); +_MTL_PRIVATE_DEF_SEL(staticLinkingDescriptor, + "staticLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(staticThreadgroupMemoryLength, + "staticThreadgroupMemoryLength"); +_MTL_PRIVATE_DEF_SEL(status, + "status"); +_MTL_PRIVATE_DEF_SEL(stencilAttachment, + "stencilAttachment"); +_MTL_PRIVATE_DEF_SEL(stencilAttachmentPixelFormat, + "stencilAttachmentPixelFormat"); +_MTL_PRIVATE_DEF_SEL(stencilCompareFunction, + "stencilCompareFunction"); +_MTL_PRIVATE_DEF_SEL(stencilFailureOperation, + "stencilFailureOperation"); +_MTL_PRIVATE_DEF_SEL(stencilResolveFilter, + "stencilResolveFilter"); +_MTL_PRIVATE_DEF_SEL(stepFunction, + "stepFunction"); +_MTL_PRIVATE_DEF_SEL(stepRate, + "stepRate"); +_MTL_PRIVATE_DEF_SEL(stopCapture, + "stopCapture"); +_MTL_PRIVATE_DEF_SEL(storageMode, + "storageMode"); +_MTL_PRIVATE_DEF_SEL(storeAction, + "storeAction"); +_MTL_PRIVATE_DEF_SEL(storeActionOptions, + "storeActionOptions"); +_MTL_PRIVATE_DEF_SEL(stride, + "stride"); +_MTL_PRIVATE_DEF_SEL(strides, + "strides"); +_MTL_PRIVATE_DEF_SEL(structType, + "structType"); +_MTL_PRIVATE_DEF_SEL(supportAddingBinaryFunctions, + "supportAddingBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(supportAddingFragmentBinaryFunctions, + "supportAddingFragmentBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(supportAddingVertexBinaryFunctions, + "supportAddingVertexBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(supportArgumentBuffers, + "supportArgumentBuffers"); +_MTL_PRIVATE_DEF_SEL(supportAttributeStrides, + "supportAttributeStrides"); +_MTL_PRIVATE_DEF_SEL(supportBinaryLinking, + "supportBinaryLinking"); +_MTL_PRIVATE_DEF_SEL(supportColorAttachmentMapping, + "supportColorAttachmentMapping"); +_MTL_PRIVATE_DEF_SEL(supportDynamicAttributeStride, + "supportDynamicAttributeStride"); +_MTL_PRIVATE_DEF_SEL(supportFragmentBinaryLinking, + "supportFragmentBinaryLinking"); +_MTL_PRIVATE_DEF_SEL(supportIndirectCommandBuffers, + "supportIndirectCommandBuffers"); +_MTL_PRIVATE_DEF_SEL(supportMeshBinaryLinking, + "supportMeshBinaryLinking"); +_MTL_PRIVATE_DEF_SEL(supportObjectBinaryLinking, + "supportObjectBinaryLinking"); +_MTL_PRIVATE_DEF_SEL(supportRayTracing, + "supportRayTracing"); +_MTL_PRIVATE_DEF_SEL(supportVertexBinaryLinking, + "supportVertexBinaryLinking"); +_MTL_PRIVATE_DEF_SEL(supports32BitFloatFiltering, + "supports32BitFloatFiltering"); +_MTL_PRIVATE_DEF_SEL(supports32BitMSAA, + "supports32BitMSAA"); +_MTL_PRIVATE_DEF_SEL(supportsBCTextureCompression, + "supportsBCTextureCompression"); +_MTL_PRIVATE_DEF_SEL(supportsCounterSampling_, + "supportsCounterSampling:"); +_MTL_PRIVATE_DEF_SEL(supportsDestination_, + "supportsDestination:"); +_MTL_PRIVATE_DEF_SEL(supportsDynamicLibraries, + "supportsDynamicLibraries"); +_MTL_PRIVATE_DEF_SEL(supportsFamily_, + "supportsFamily:"); +_MTL_PRIVATE_DEF_SEL(supportsFeatureSet_, + "supportsFeatureSet:"); +_MTL_PRIVATE_DEF_SEL(supportsFunctionPointers, + "supportsFunctionPointers"); +_MTL_PRIVATE_DEF_SEL(supportsFunctionPointersFromRender, + "supportsFunctionPointersFromRender"); +_MTL_PRIVATE_DEF_SEL(supportsPrimitiveMotionBlur, + "supportsPrimitiveMotionBlur"); +_MTL_PRIVATE_DEF_SEL(supportsPullModelInterpolation, + "supportsPullModelInterpolation"); +_MTL_PRIVATE_DEF_SEL(supportsQueryTextureLOD, + "supportsQueryTextureLOD"); +_MTL_PRIVATE_DEF_SEL(supportsRasterizationRateMapWithLayerCount_, + "supportsRasterizationRateMapWithLayerCount:"); +_MTL_PRIVATE_DEF_SEL(supportsRaytracing, + "supportsRaytracing"); +_MTL_PRIVATE_DEF_SEL(supportsRaytracingFromRender, + "supportsRaytracingFromRender"); +_MTL_PRIVATE_DEF_SEL(supportsRenderDynamicLibraries, + "supportsRenderDynamicLibraries"); +_MTL_PRIVATE_DEF_SEL(supportsShaderBarycentricCoordinates, + "supportsShaderBarycentricCoordinates"); +_MTL_PRIVATE_DEF_SEL(supportsTextureSampleCount_, + "supportsTextureSampleCount:"); +_MTL_PRIVATE_DEF_SEL(supportsVertexAmplificationCount_, + "supportsVertexAmplificationCount:"); +_MTL_PRIVATE_DEF_SEL(swizzle, + "swizzle"); +_MTL_PRIVATE_DEF_SEL(synchronizeResource_, + "synchronizeResource:"); +_MTL_PRIVATE_DEF_SEL(synchronizeTexture_slice_level_, + "synchronizeTexture:slice:level:"); +_MTL_PRIVATE_DEF_SEL(tAddressMode, + "tAddressMode"); +_MTL_PRIVATE_DEF_SEL(tailSizeInBytes, + "tailSizeInBytes"); +_MTL_PRIVATE_DEF_SEL(tensorDataType, + "tensorDataType"); +_MTL_PRIVATE_DEF_SEL(tensorReferenceType, + "tensorReferenceType"); +_MTL_PRIVATE_DEF_SEL(tensorSizeAndAlignWithDescriptor_, + "tensorSizeAndAlignWithDescriptor:"); +_MTL_PRIVATE_DEF_SEL(tessellationControlPointIndexType, + "tessellationControlPointIndexType"); +_MTL_PRIVATE_DEF_SEL(tessellationFactorFormat, + "tessellationFactorFormat"); +_MTL_PRIVATE_DEF_SEL(tessellationFactorStepFunction, + "tessellationFactorStepFunction"); +_MTL_PRIVATE_DEF_SEL(tessellationOutputWindingOrder, + "tessellationOutputWindingOrder"); +_MTL_PRIVATE_DEF_SEL(tessellationPartitionMode, + "tessellationPartitionMode"); +_MTL_PRIVATE_DEF_SEL(texture, + "texture"); +_MTL_PRIVATE_DEF_SEL(texture2DDescriptorWithPixelFormat_width_height_mipmapped_, + "texture2DDescriptorWithPixelFormat:width:height:mipmapped:"); +_MTL_PRIVATE_DEF_SEL(textureBarrier, + "textureBarrier"); +_MTL_PRIVATE_DEF_SEL(textureBufferDescriptorWithPixelFormat_width_resourceOptions_usage_, + "textureBufferDescriptorWithPixelFormat:width:resourceOptions:usage:"); +_MTL_PRIVATE_DEF_SEL(textureCubeDescriptorWithPixelFormat_size_mipmapped_, + "textureCubeDescriptorWithPixelFormat:size:mipmapped:"); +_MTL_PRIVATE_DEF_SEL(textureDataType, + "textureDataType"); +_MTL_PRIVATE_DEF_SEL(textureReferenceType, + "textureReferenceType"); +_MTL_PRIVATE_DEF_SEL(textureType, + "textureType"); +_MTL_PRIVATE_DEF_SEL(threadExecutionWidth, + "threadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(threadGroupSizeIsMultipleOfThreadExecutionWidth, + "threadGroupSizeIsMultipleOfThreadExecutionWidth"); +_MTL_PRIVATE_DEF_SEL(threadgroupMemoryAlignment, + "threadgroupMemoryAlignment"); +_MTL_PRIVATE_DEF_SEL(threadgroupMemoryDataSize, + "threadgroupMemoryDataSize"); +_MTL_PRIVATE_DEF_SEL(threadgroupMemoryLength, + "threadgroupMemoryLength"); +_MTL_PRIVATE_DEF_SEL(threadgroupSizeMatchesTileSize, + "threadgroupSizeMatchesTileSize"); +_MTL_PRIVATE_DEF_SEL(tileAdditionalBinaryFunctions, + "tileAdditionalBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(tileArguments, + "tileArguments"); +_MTL_PRIVATE_DEF_SEL(tileBindings, + "tileBindings"); +_MTL_PRIVATE_DEF_SEL(tileBuffers, + "tileBuffers"); +_MTL_PRIVATE_DEF_SEL(tileFunction, + "tileFunction"); +_MTL_PRIVATE_DEF_SEL(tileFunctionDescriptor, + "tileFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(tileHeight, + "tileHeight"); +_MTL_PRIVATE_DEF_SEL(tileLinkingDescriptor, + "tileLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(tileWidth, + "tileWidth"); +_MTL_PRIVATE_DEF_SEL(transformationMatrixBuffer, + "transformationMatrixBuffer"); +_MTL_PRIVATE_DEF_SEL(transformationMatrixBufferOffset, + "transformationMatrixBufferOffset"); +_MTL_PRIVATE_DEF_SEL(transformationMatrixLayout, + "transformationMatrixLayout"); +_MTL_PRIVATE_DEF_SEL(triangleCount, + "triangleCount"); +_MTL_PRIVATE_DEF_SEL(tryCancel, + "tryCancel"); +_MTL_PRIVATE_DEF_SEL(type, + "type"); +_MTL_PRIVATE_DEF_SEL(updateBufferMappings_heap_operations_count_, + "updateBufferMappings:heap:operations:count:"); +_MTL_PRIVATE_DEF_SEL(updateFence_, + "updateFence:"); +_MTL_PRIVATE_DEF_SEL(updateFence_afterEncoderStages_, + "updateFence:afterEncoderStages:"); +_MTL_PRIVATE_DEF_SEL(updateFence_afterStages_, + "updateFence:afterStages:"); +_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_, + "updateTextureMapping:mode:indirectBuffer:indirectBufferOffset:"); +_MTL_PRIVATE_DEF_SEL(updateTextureMapping_mode_region_mipLevel_slice_, + "updateTextureMapping:mode:region:mipLevel:slice:"); +_MTL_PRIVATE_DEF_SEL(updateTextureMappings_heap_operations_count_, + "updateTextureMappings:heap:operations:count:"); +_MTL_PRIVATE_DEF_SEL(updateTextureMappings_mode_regions_mipLevels_slices_numRegions_, + "updateTextureMappings:mode:regions:mipLevels:slices:numRegions:"); +_MTL_PRIVATE_DEF_SEL(url, + "url"); +_MTL_PRIVATE_DEF_SEL(usage, + "usage"); +_MTL_PRIVATE_DEF_SEL(useHeap_, + "useHeap:"); +_MTL_PRIVATE_DEF_SEL(useHeap_stages_, + "useHeap:stages:"); +_MTL_PRIVATE_DEF_SEL(useHeaps_count_, + "useHeaps:count:"); +_MTL_PRIVATE_DEF_SEL(useHeaps_count_stages_, + "useHeaps:count:stages:"); +_MTL_PRIVATE_DEF_SEL(useResidencySet_, + "useResidencySet:"); +_MTL_PRIVATE_DEF_SEL(useResidencySets_count_, + "useResidencySets:count:"); +_MTL_PRIVATE_DEF_SEL(useResource_usage_, + "useResource:usage:"); +_MTL_PRIVATE_DEF_SEL(useResource_usage_stages_, + "useResource:usage:stages:"); +_MTL_PRIVATE_DEF_SEL(useResources_count_usage_, + "useResources:count:usage:"); +_MTL_PRIVATE_DEF_SEL(useResources_count_usage_stages_, + "useResources:count:usage:stages:"); +_MTL_PRIVATE_DEF_SEL(usedSize, + "usedSize"); +_MTL_PRIVATE_DEF_SEL(vertexAdditionalBinaryFunctions, + "vertexAdditionalBinaryFunctions"); +_MTL_PRIVATE_DEF_SEL(vertexArguments, + "vertexArguments"); +_MTL_PRIVATE_DEF_SEL(vertexAttributes, + "vertexAttributes"); +_MTL_PRIVATE_DEF_SEL(vertexBindings, + "vertexBindings"); +_MTL_PRIVATE_DEF_SEL(vertexBuffer, + "vertexBuffer"); +_MTL_PRIVATE_DEF_SEL(vertexBufferOffset, + "vertexBufferOffset"); +_MTL_PRIVATE_DEF_SEL(vertexBuffers, + "vertexBuffers"); +_MTL_PRIVATE_DEF_SEL(vertexDescriptor, + "vertexDescriptor"); +_MTL_PRIVATE_DEF_SEL(vertexFormat, + "vertexFormat"); +_MTL_PRIVATE_DEF_SEL(vertexFunction, + "vertexFunction"); +_MTL_PRIVATE_DEF_SEL(vertexFunctionDescriptor, + "vertexFunctionDescriptor"); +_MTL_PRIVATE_DEF_SEL(vertexLinkedFunctions, + "vertexLinkedFunctions"); +_MTL_PRIVATE_DEF_SEL(vertexLinkingDescriptor, + "vertexLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(vertexPreloadedLibraries, + "vertexPreloadedLibraries"); +_MTL_PRIVATE_DEF_SEL(vertexStaticLinkingDescriptor, + "vertexStaticLinkingDescriptor"); +_MTL_PRIVATE_DEF_SEL(vertexStride, + "vertexStride"); +_MTL_PRIVATE_DEF_SEL(vertical, + "vertical"); +_MTL_PRIVATE_DEF_SEL(verticalSampleStorage, + "verticalSampleStorage"); +_MTL_PRIVATE_DEF_SEL(visibilityResultBuffer, + "visibilityResultBuffer"); +_MTL_PRIVATE_DEF_SEL(visibilityResultType, + "visibilityResultType"); +_MTL_PRIVATE_DEF_SEL(visibleFunctionTableDescriptor, + "visibleFunctionTableDescriptor"); +_MTL_PRIVATE_DEF_SEL(waitForDrawable_, + "waitForDrawable:"); +_MTL_PRIVATE_DEF_SEL(waitForEvent_value_, + "waitForEvent:value:"); +_MTL_PRIVATE_DEF_SEL(waitForFence_, + "waitForFence:"); +_MTL_PRIVATE_DEF_SEL(waitForFence_beforeEncoderStages_, + "waitForFence:beforeEncoderStages:"); +_MTL_PRIVATE_DEF_SEL(waitForFence_beforeStages_, + "waitForFence:beforeStages:"); +_MTL_PRIVATE_DEF_SEL(waitUntilCompleted, + "waitUntilCompleted"); +_MTL_PRIVATE_DEF_SEL(waitUntilScheduled, + "waitUntilScheduled"); +_MTL_PRIVATE_DEF_SEL(waitUntilSignaledValue_timeoutMS_, + "waitUntilSignaledValue:timeoutMS:"); +_MTL_PRIVATE_DEF_SEL(width, + "width"); +_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_, + "writeCompactedAccelerationStructureSize:toBuffer:"); +_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_, + "writeCompactedAccelerationStructureSize:toBuffer:offset:"); +_MTL_PRIVATE_DEF_SEL(writeCompactedAccelerationStructureSize_toBuffer_offset_sizeDataType_, + "writeCompactedAccelerationStructureSize:toBuffer:offset:sizeDataType:"); +_MTL_PRIVATE_DEF_SEL(writeMask, + "writeMask"); +_MTL_PRIVATE_DEF_SEL(writeTimestampIntoHeap_atIndex_, + "writeTimestampIntoHeap:atIndex:"); +_MTL_PRIVATE_DEF_SEL(writeTimestampWithGranularity_afterStage_intoHeap_atIndex_, + "writeTimestampWithGranularity:afterStage:intoHeap:atIndex:"); +_MTL_PRIVATE_DEF_SEL(writeTimestampWithGranularity_intoHeap_atIndex_, + "writeTimestampWithGranularity:intoHeap:atIndex:"); + +} diff --git a/thirdparty/metal-cpp/Metal/MTLHeap.hpp b/thirdparty/metal-cpp/Metal/MTLHeap.hpp new file mode 100644 index 0000000000..251b284a89 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLHeap.hpp @@ -0,0 +1,318 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLHeap.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAllocation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" + +namespace MTL +{ +class AccelerationStructure; +class AccelerationStructureDescriptor; +class Buffer; +class Device; +class HeapDescriptor; +class Texture; +class TextureDescriptor; +_MTL_ENUM(NS::Integer, HeapType) { + HeapTypeAutomatic = 0, + HeapTypePlacement = 1, + HeapTypeSparse = 2, +}; + +class HeapDescriptor : public NS::Copying +{ +public: + static HeapDescriptor* alloc(); + + CPUCacheMode cpuCacheMode() const; + + HazardTrackingMode hazardTrackingMode() const; + + HeapDescriptor* init(); + + SparsePageSize maxCompatiblePlacementSparsePageSize() const; + + ResourceOptions resourceOptions() const; + + void setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode); + + void setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode); + + void setMaxCompatiblePlacementSparsePageSize(MTL::SparsePageSize maxCompatiblePlacementSparsePageSize); + + void setResourceOptions(MTL::ResourceOptions resourceOptions); + + void setSize(NS::UInteger size); + + void setSparsePageSize(MTL::SparsePageSize sparsePageSize); + + void setStorageMode(MTL::StorageMode storageMode); + + void setType(MTL::HeapType type); + + NS::UInteger size() const; + SparsePageSize sparsePageSize() const; + + StorageMode storageMode() const; + + HeapType type() const; +}; +class Heap : public NS::Referencing +{ +public: + CPUCacheMode cpuCacheMode() const; + + NS::UInteger currentAllocatedSize() const; + + Device* device() const; + + HazardTrackingMode hazardTrackingMode() const; + + NS::String* label() const; + + NS::UInteger maxAvailableSize(NS::UInteger alignment); + + AccelerationStructure* newAccelerationStructure(NS::UInteger size); + AccelerationStructure* newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor); + AccelerationStructure* newAccelerationStructure(NS::UInteger size, NS::UInteger offset); + AccelerationStructure* newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor, NS::UInteger offset); + + Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options); + Buffer* newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset); + + Texture* newTexture(const MTL::TextureDescriptor* descriptor); + Texture* newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset); + + ResourceOptions resourceOptions() const; + + void setLabel(const NS::String* label); + + PurgeableState setPurgeableState(MTL::PurgeableState state); + + NS::UInteger size() const; + + StorageMode storageMode() const; + + HeapType type() const; + + NS::UInteger usedSize() const; +}; + +} +_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLHeapDescriptor)); +} + +_MTL_INLINE MTL::CPUCacheMode MTL::HeapDescriptor::cpuCacheMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(cpuCacheMode)); +} + +_MTL_INLINE MTL::HazardTrackingMode MTL::HeapDescriptor::hazardTrackingMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hazardTrackingMode)); +} + +_MTL_INLINE MTL::HeapDescriptor* MTL::HeapDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::SparsePageSize MTL::HeapDescriptor::maxCompatiblePlacementSparsePageSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCompatiblePlacementSparsePageSize)); +} + +_MTL_INLINE MTL::ResourceOptions MTL::HeapDescriptor::resourceOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceOptions)); +} + +_MTL_INLINE void MTL::HeapDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode); +} + +_MTL_INLINE void MTL::HeapDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode); +} + +_MTL_INLINE void MTL::HeapDescriptor::setMaxCompatiblePlacementSparsePageSize(MTL::SparsePageSize maxCompatiblePlacementSparsePageSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCompatiblePlacementSparsePageSize_), maxCompatiblePlacementSparsePageSize); +} + +_MTL_INLINE void MTL::HeapDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions); +} + +_MTL_INLINE void MTL::HeapDescriptor::setSize(NS::UInteger size) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSize_), size); +} + +_MTL_INLINE void MTL::HeapDescriptor::setSparsePageSize(MTL::SparsePageSize sparsePageSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSparsePageSize_), sparsePageSize); +} + +_MTL_INLINE void MTL::HeapDescriptor::setStorageMode(MTL::StorageMode storageMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode); +} + +_MTL_INLINE void MTL::HeapDescriptor::setType(MTL::HeapType type) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setType_), type); +} + +_MTL_INLINE NS::UInteger MTL::HeapDescriptor::size() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(size)); +} + +_MTL_INLINE MTL::SparsePageSize MTL::HeapDescriptor::sparsePageSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparsePageSize)); +} + +_MTL_INLINE MTL::StorageMode MTL::HeapDescriptor::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} + +_MTL_INLINE MTL::HeapType MTL::HeapDescriptor::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE MTL::CPUCacheMode MTL::Heap::cpuCacheMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(cpuCacheMode)); +} + +_MTL_INLINE NS::UInteger MTL::Heap::currentAllocatedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(currentAllocatedSize)); +} + +_MTL_INLINE MTL::Device* MTL::Heap::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::HazardTrackingMode MTL::Heap::hazardTrackingMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hazardTrackingMode)); +} + +_MTL_INLINE NS::String* MTL::Heap::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::Heap::maxAvailableSize(NS::UInteger alignment) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxAvailableSizeWithAlignment_), alignment); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_), size); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(NS::UInteger size, NS::UInteger offset) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithSize_offset_), size, offset); +} + +_MTL_INLINE MTL::AccelerationStructure* MTL::Heap::newAccelerationStructure(const MTL::AccelerationStructureDescriptor* descriptor, NS::UInteger offset) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newAccelerationStructureWithDescriptor_offset_), descriptor, offset); +} + +_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_), length, options); +} + +_MTL_INLINE MTL::Buffer* MTL::Heap::newBuffer(NS::UInteger length, MTL::ResourceOptions options, NS::UInteger offset) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newBufferWithLength_options_offset_), length, options, offset); +} + +_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::Texture* MTL::Heap::newTexture(const MTL::TextureDescriptor* descriptor, NS::UInteger offset) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureWithDescriptor_offset_), descriptor, offset); +} + +_MTL_INLINE MTL::ResourceOptions MTL::Heap::resourceOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceOptions)); +} + +_MTL_INLINE void MTL::Heap::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::PurgeableState MTL::Heap::setPurgeableState(MTL::PurgeableState state) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setPurgeableState_), state); +} + +_MTL_INLINE NS::UInteger MTL::Heap::size() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(size)); +} + +_MTL_INLINE MTL::StorageMode MTL::Heap::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} + +_MTL_INLINE MTL::HeapType MTL::Heap::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE NS::UInteger MTL::Heap::usedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usedSize)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLIOCommandBuffer.hpp b/thirdparty/metal-cpp/Metal/MTLIOCommandBuffer.hpp new file mode 100644 index 0000000000..9402318d7c --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIOCommandBuffer.hpp @@ -0,0 +1,182 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIOCommandBuffer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class Buffer; +class IOCommandBuffer; +class IOFileHandle; +class SharedEvent; +class Texture; +_MTL_ENUM(NS::Integer, IOStatus) { + IOStatusPending = 0, + IOStatusCancelled = 1, + IOStatusError = 2, + IOStatusComplete = 3, +}; + +using IOCommandBufferHandler = void (^)(MTL::IOCommandBuffer*); +using IOCommandBufferHandlerFunction = std::function; + +class IOCommandBuffer : public NS::Referencing +{ +public: + void addBarrier(); + + void addCompletedHandler(const MTL::IOCommandBufferHandler block); + void addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function); + + void commit(); + + void copyStatusToBuffer(const MTL::Buffer* buffer, NS::UInteger offset); + + void enqueue(); + + NS::Error* error() const; + + NS::String* label() const; + + void loadBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset); + + void loadBytes(const void* pointer, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset); + + void loadTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset); + + void popDebugGroup(); + + void pushDebugGroup(const NS::String* string); + + void setLabel(const NS::String* label); + + void signalEvent(const MTL::SharedEvent* event, uint64_t value); + + IOStatus status() const; + + void tryCancel(); + + void wait(const MTL::SharedEvent* event, uint64_t value); + void waitUntilCompleted(); +}; + +} +_MTL_INLINE void MTL::IOCommandBuffer::addBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addBarrier)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandler block) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addCompletedHandler_), block); +} + +_MTL_INLINE void MTL::IOCommandBuffer::addCompletedHandler(const MTL::IOCommandBufferHandlerFunction& function) +{ + __block MTL::IOCommandBufferHandlerFunction blockFunction = function; + addCompletedHandler(^(MTL::IOCommandBuffer* pCommandBuffer) { blockFunction(pCommandBuffer); }); +} + +_MTL_INLINE void MTL::IOCommandBuffer::commit() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(commit)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::copyStatusToBuffer(const MTL::Buffer* buffer, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyStatusToBuffer_offset_), buffer, offset); +} + +_MTL_INLINE void MTL::IOCommandBuffer::enqueue() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(enqueue)); +} + +_MTL_INLINE NS::Error* MTL::IOCommandBuffer::error() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(error)); +} + +_MTL_INLINE NS::String* MTL::IOCommandBuffer::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::loadBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(loadBuffer_offset_size_sourceHandle_sourceHandleOffset_), buffer, offset, size, sourceHandle, sourceHandleOffset); +} + +_MTL_INLINE void MTL::IOCommandBuffer::loadBytes(const void* pointer, NS::UInteger size, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(loadBytes_size_sourceHandle_sourceHandleOffset_), pointer, size, sourceHandle, sourceHandleOffset); +} + +_MTL_INLINE void MTL::IOCommandBuffer::loadTexture(const MTL::Texture* texture, NS::UInteger slice, NS::UInteger level, MTL::Size size, NS::UInteger sourceBytesPerRow, NS::UInteger sourceBytesPerImage, MTL::Origin destinationOrigin, const MTL::IOFileHandle* sourceHandle, NS::UInteger sourceHandleOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(loadTexture_slice_level_size_sourceBytesPerRow_sourceBytesPerImage_destinationOrigin_sourceHandle_sourceHandleOffset_), texture, slice, level, size, sourceBytesPerRow, sourceBytesPerImage, destinationOrigin, sourceHandle, sourceHandleOffset); +} + +_MTL_INLINE void MTL::IOCommandBuffer::popDebugGroup() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(popDebugGroup)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::pushDebugGroup(const NS::String* string) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(pushDebugGroup_), string); +} + +_MTL_INLINE void MTL::IOCommandBuffer::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::IOCommandBuffer::signalEvent(const MTL::SharedEvent* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(signalEvent_value_), event, value); +} + +_MTL_INLINE MTL::IOStatus MTL::IOCommandBuffer::status() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(status)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::tryCancel() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(tryCancel)); +} + +_MTL_INLINE void MTL::IOCommandBuffer::wait(const MTL::SharedEvent* event, uint64_t value) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForEvent_value_), event, value); +} + +_MTL_INLINE void MTL::IOCommandBuffer::waitUntilCompleted() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitUntilCompleted)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLIOCommandQueue.hpp b/thirdparty/metal-cpp/Metal/MTLIOCommandQueue.hpp new file mode 100644 index 0000000000..ac956c8f11 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIOCommandQueue.hpp @@ -0,0 +1,211 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIOCommandQueue.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class Buffer; +class IOCommandBuffer; +class IOCommandQueueDescriptor; +class IOScratchBuffer; +class IOScratchBufferAllocator; +_MTL_ENUM(NS::Integer, IOPriority) { + IOPriorityHigh = 0, + IOPriorityNormal = 1, + IOPriorityLow = 2, +}; + +_MTL_ENUM(NS::Integer, IOCommandQueueType) { + IOCommandQueueTypeConcurrent = 0, + IOCommandQueueTypeSerial = 1, +}; + +_MTL_ENUM(NS::Integer, IOError) { + IOErrorURLInvalid = 1, + IOErrorInternal = 2, +}; + +_MTL_CONST(NS::ErrorDomain, IOErrorDomain); +class IOCommandQueue : public NS::Referencing +{ +public: + IOCommandBuffer* commandBuffer(); + IOCommandBuffer* commandBufferWithUnretainedReferences(); + + void enqueueBarrier(); + + NS::String* label() const; + void setLabel(const NS::String* label); +}; +class IOScratchBuffer : public NS::Referencing +{ +public: + Buffer* buffer() const; +}; +class IOScratchBufferAllocator : public NS::Referencing +{ +public: + IOScratchBuffer* newScratchBuffer(NS::UInteger minimumSize); +}; +class IOCommandQueueDescriptor : public NS::Copying +{ +public: + static IOCommandQueueDescriptor* alloc(); + + IOCommandQueueDescriptor* init(); + + NS::UInteger maxCommandBufferCount() const; + + NS::UInteger maxCommandsInFlight() const; + + IOPriority priority() const; + + IOScratchBufferAllocator* scratchBufferAllocator() const; + + void setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount); + + void setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight); + + void setPriority(MTL::IOPriority priority); + + void setScratchBufferAllocator(const MTL::IOScratchBufferAllocator* scratchBufferAllocator); + + void setType(MTL::IOCommandQueueType type); + IOCommandQueueType type() const; +}; +class IOFileHandle : public NS::Referencing +{ +public: + NS::String* label() const; + void setLabel(const NS::String* label); +}; + +} +_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, IOErrorDomain); +_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBuffer() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBuffer)); +} + +_MTL_INLINE MTL::IOCommandBuffer* MTL::IOCommandQueue::commandBufferWithUnretainedReferences() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandBufferWithUnretainedReferences)); +} + +_MTL_INLINE void MTL::IOCommandQueue::enqueueBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(enqueueBarrier)); +} + +_MTL_INLINE NS::String* MTL::IOCommandQueue::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::IOCommandQueue::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::Buffer* MTL::IOScratchBuffer::buffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(buffer)); +} + +_MTL_INLINE MTL::IOScratchBuffer* MTL::IOScratchBufferAllocator::newScratchBuffer(NS::UInteger minimumSize) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newScratchBufferWithMinimumSize_), minimumSize); +} + +_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLIOCommandQueueDescriptor)); +} + +_MTL_INLINE MTL::IOCommandQueueDescriptor* MTL::IOCommandQueueDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandBufferCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCommandBufferCount)); +} + +_MTL_INLINE NS::UInteger MTL::IOCommandQueueDescriptor::maxCommandsInFlight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCommandsInFlight)); +} + +_MTL_INLINE MTL::IOPriority MTL::IOCommandQueueDescriptor::priority() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(priority)); +} + +_MTL_INLINE MTL::IOScratchBufferAllocator* MTL::IOCommandQueueDescriptor::scratchBufferAllocator() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(scratchBufferAllocator)); +} + +_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandBufferCount(NS::UInteger maxCommandBufferCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCommandBufferCount_), maxCommandBufferCount); +} + +_MTL_INLINE void MTL::IOCommandQueueDescriptor::setMaxCommandsInFlight(NS::UInteger maxCommandsInFlight) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCommandsInFlight_), maxCommandsInFlight); +} + +_MTL_INLINE void MTL::IOCommandQueueDescriptor::setPriority(MTL::IOPriority priority) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPriority_), priority); +} + +_MTL_INLINE void MTL::IOCommandQueueDescriptor::setScratchBufferAllocator(const MTL::IOScratchBufferAllocator* scratchBufferAllocator) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScratchBufferAllocator_), scratchBufferAllocator); +} + +_MTL_INLINE void MTL::IOCommandQueueDescriptor::setType(MTL::IOCommandQueueType type) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setType_), type); +} + +_MTL_INLINE MTL::IOCommandQueueType MTL::IOCommandQueueDescriptor::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE NS::String* MTL::IOFileHandle::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::IOFileHandle::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} diff --git a/thirdparty/metal-cpp/Metal/MTLIOCompressor.hpp b/thirdparty/metal-cpp/Metal/MTLIOCompressor.hpp new file mode 100644 index 0000000000..920fa611cb --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIOCompressor.hpp @@ -0,0 +1,94 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIOCompressor.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLDevice.hpp" + +#include "../Foundation/Foundation.hpp" + +namespace MTL +{ +using IOCompressionContext=void*; + +_MTL_ENUM(NS::Integer, IOCompressionStatus) { + IOCompressionStatusComplete = 0, + IOCompressionStatusError = 1, +}; + +size_t IOCompressionContextDefaultChunkSize(); + +IOCompressionContext IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize); + +void IOCompressionContextAppendData(IOCompressionContext context, const void* data, size_t size); + +IOCompressionStatus IOFlushAndDestroyCompressionContext(IOCompressionContext context); + +} + +#if defined(MTL_PRIVATE_IMPLEMENTATION) + +namespace MTL::Private { + +MTL_DEF_FUNC(MTLIOCompressionContextDefaultChunkSize, size_t (*)(void)); + +MTL_DEF_FUNC( MTLIOCreateCompressionContext, void* (*)(const char*, MTL::IOCompressionMethod, size_t) ); + +MTL_DEF_FUNC( MTLIOCompressionContextAppendData, void (*)(void*, const void*, size_t) ); + +MTL_DEF_FUNC( MTLIOFlushAndDestroyCompressionContext, MTL::IOCompressionStatus (*)(void*) ); + +} + +_NS_EXPORT size_t MTL::IOCompressionContextDefaultChunkSize() +{ + return MTL::Private::MTLIOCompressionContextDefaultChunkSize(); +} + +_NS_EXPORT void* MTL::IOCreateCompressionContext(const char* path, IOCompressionMethod type, size_t chunkSize) +{ + if ( MTL::Private::MTLIOCreateCompressionContext ) + { + return MTL::Private::MTLIOCreateCompressionContext( path, type, chunkSize ); + } + return nullptr; +} + +_NS_EXPORT void MTL::IOCompressionContextAppendData(void* context, const void* data, size_t size) +{ + if ( MTL::Private::MTLIOCompressionContextAppendData ) + { + MTL::Private::MTLIOCompressionContextAppendData( context, data, size ); + } +} + +_NS_EXPORT MTL::IOCompressionStatus MTL::IOFlushAndDestroyCompressionContext(void* context) +{ + if ( MTL::Private::MTLIOFlushAndDestroyCompressionContext ) + { + return MTL::Private::MTLIOFlushAndDestroyCompressionContext( context ); + } + return MTL::IOCompressionStatusError; +} + +#endif diff --git a/thirdparty/metal-cpp/Metal/MTLIndirectCommandBuffer.hpp b/thirdparty/metal-cpp/Metal/MTLIndirectCommandBuffer.hpp new file mode 100644 index 0000000000..6944d56217 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIndirectCommandBuffer.hpp @@ -0,0 +1,376 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIndirectCommandBuffer.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class IndirectCommandBufferDescriptor; +class IndirectComputeCommand; +class IndirectRenderCommand; + +_MTL_OPTIONS(NS::UInteger, IndirectCommandType) { + IndirectCommandTypeDraw = 1, + IndirectCommandTypeDrawIndexed = 1 << 1, + IndirectCommandTypeDrawPatches = 1 << 2, + IndirectCommandTypeDrawIndexedPatches = 1 << 3, + IndirectCommandTypeConcurrentDispatch = 1 << 5, + IndirectCommandTypeConcurrentDispatchThreads = 1 << 6, + IndirectCommandTypeDrawMeshThreadgroups = 1 << 7, + IndirectCommandTypeDrawMeshThreads = 1 << 8, +}; + +struct IndirectCommandBufferExecutionRange +{ + uint32_t location; + uint32_t length; +} _MTL_PACKED; + +class IndirectCommandBufferDescriptor : public NS::Copying +{ +public: + static IndirectCommandBufferDescriptor* alloc(); + + IndirectCommandType commandTypes() const; + + bool inheritBuffers() const; + + bool inheritCullMode() const; + + bool inheritDepthBias() const; + + bool inheritDepthClipMode() const; + + bool inheritDepthStencilState() const; + + bool inheritFrontFacingWinding() const; + + bool inheritPipelineState() const; + + bool inheritTriangleFillMode() const; + + IndirectCommandBufferDescriptor* init(); + + NS::UInteger maxFragmentBufferBindCount() const; + + NS::UInteger maxKernelBufferBindCount() const; + + NS::UInteger maxKernelThreadgroupMemoryBindCount() const; + + NS::UInteger maxMeshBufferBindCount() const; + + NS::UInteger maxObjectBufferBindCount() const; + + NS::UInteger maxObjectThreadgroupMemoryBindCount() const; + + NS::UInteger maxVertexBufferBindCount() const; + + void setCommandTypes(MTL::IndirectCommandType commandTypes); + + void setInheritBuffers(bool inheritBuffers); + + void setInheritCullMode(bool inheritCullMode); + + void setInheritDepthBias(bool inheritDepthBias); + + void setInheritDepthClipMode(bool inheritDepthClipMode); + + void setInheritDepthStencilState(bool inheritDepthStencilState); + + void setInheritFrontFacingWinding(bool inheritFrontFacingWinding); + + void setInheritPipelineState(bool inheritPipelineState); + + void setInheritTriangleFillMode(bool inheritTriangleFillMode); + + void setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount); + + void setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount); + + void setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount); + + void setMaxMeshBufferBindCount(NS::UInteger maxMeshBufferBindCount); + + void setMaxObjectBufferBindCount(NS::UInteger maxObjectBufferBindCount); + + void setMaxObjectThreadgroupMemoryBindCount(NS::UInteger maxObjectThreadgroupMemoryBindCount); + + void setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount); + + void setSupportColorAttachmentMapping(bool supportColorAttachmentMapping); + + void setSupportDynamicAttributeStride(bool supportDynamicAttributeStride); + + void setSupportRayTracing(bool supportRayTracing); + + bool supportColorAttachmentMapping() const; + + bool supportDynamicAttributeStride() const; + + bool supportRayTracing() const; +}; +class IndirectCommandBuffer : public NS::Referencing +{ +public: + ResourceID gpuResourceID() const; + + IndirectComputeCommand* indirectComputeCommand(NS::UInteger commandIndex); + + IndirectRenderCommand* indirectRenderCommand(NS::UInteger commandIndex); + + void reset(NS::Range range); + + NS::UInteger size() const; +}; + +} + +_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLIndirectCommandBufferDescriptor)); +} + +_MTL_INLINE MTL::IndirectCommandType MTL::IndirectCommandBufferDescriptor::commandTypes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(commandTypes)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritBuffers)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritCullMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritCullMode)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthBias() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritDepthBias)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthClipMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritDepthClipMode)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritDepthStencilState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritDepthStencilState)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritFrontFacingWinding() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritFrontFacingWinding)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritPipelineState() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritPipelineState)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::inheritTriangleFillMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inheritTriangleFillMode)); +} + +_MTL_INLINE MTL::IndirectCommandBufferDescriptor* MTL::IndirectCommandBufferDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxFragmentBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxFragmentBufferBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxKernelBufferBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxKernelThreadgroupMemoryBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxKernelThreadgroupMemoryBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxMeshBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxMeshBufferBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxObjectBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxObjectBufferBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxObjectThreadgroupMemoryBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxObjectThreadgroupMemoryBindCount)); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBufferDescriptor::maxVertexBufferBindCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexBufferBindCount)); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setCommandTypes(MTL::IndirectCommandType commandTypes) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCommandTypes_), commandTypes); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritBuffers(bool inheritBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritBuffers_), inheritBuffers); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritCullMode(bool inheritCullMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritCullMode_), inheritCullMode); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthBias(bool inheritDepthBias) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritDepthBias_), inheritDepthBias); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthClipMode(bool inheritDepthClipMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritDepthClipMode_), inheritDepthClipMode); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritDepthStencilState(bool inheritDepthStencilState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritDepthStencilState_), inheritDepthStencilState); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritFrontFacingWinding(bool inheritFrontFacingWinding) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritFrontFacingWinding_), inheritFrontFacingWinding); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritPipelineState(bool inheritPipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritPipelineState_), inheritPipelineState); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setInheritTriangleFillMode(bool inheritTriangleFillMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInheritTriangleFillMode_), inheritTriangleFillMode); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxFragmentBufferBindCount(NS::UInteger maxFragmentBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxFragmentBufferBindCount_), maxFragmentBufferBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelBufferBindCount(NS::UInteger maxKernelBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxKernelBufferBindCount_), maxKernelBufferBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxKernelThreadgroupMemoryBindCount(NS::UInteger maxKernelThreadgroupMemoryBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxKernelThreadgroupMemoryBindCount_), maxKernelThreadgroupMemoryBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxMeshBufferBindCount(NS::UInteger maxMeshBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxMeshBufferBindCount_), maxMeshBufferBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxObjectBufferBindCount(NS::UInteger maxObjectBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxObjectBufferBindCount_), maxObjectBufferBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxObjectThreadgroupMemoryBindCount(NS::UInteger maxObjectThreadgroupMemoryBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxObjectThreadgroupMemoryBindCount_), maxObjectThreadgroupMemoryBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setMaxVertexBufferBindCount(NS::UInteger maxVertexBufferBindCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexBufferBindCount_), maxVertexBufferBindCount); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportColorAttachmentMapping(bool supportColorAttachmentMapping) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportColorAttachmentMapping_), supportColorAttachmentMapping); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportDynamicAttributeStride(bool supportDynamicAttributeStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportDynamicAttributeStride_), supportDynamicAttributeStride); +} + +_MTL_INLINE void MTL::IndirectCommandBufferDescriptor::setSupportRayTracing(bool supportRayTracing) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportRayTracing_), supportRayTracing); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportColorAttachmentMapping() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportColorAttachmentMapping)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportDynamicAttributeStride() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportDynamicAttributeStride)); +} + +_MTL_INLINE bool MTL::IndirectCommandBufferDescriptor::supportRayTracing() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportRayTracing)); +} + +_MTL_INLINE MTL::ResourceID MTL::IndirectCommandBuffer::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE MTL::IndirectComputeCommand* MTL::IndirectCommandBuffer::indirectComputeCommand(NS::UInteger commandIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indirectComputeCommandAtIndex_), commandIndex); +} + +_MTL_INLINE MTL::IndirectRenderCommand* MTL::IndirectCommandBuffer::indirectRenderCommand(NS::UInteger commandIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indirectRenderCommandAtIndex_), commandIndex); +} + +_MTL_INLINE void MTL::IndirectCommandBuffer::reset(NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(resetWithRange_), range); +} + +_MTL_INLINE NS::UInteger MTL::IndirectCommandBuffer::size() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(size)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLIndirectCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLIndirectCommandEncoder.hpp new file mode 100644 index 0000000000..9e1a94004b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIndirectCommandEncoder.hpp @@ -0,0 +1,272 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIndirectCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLArgument.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderCommandEncoder.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Buffer; +class ComputePipelineState; +class RenderPipelineState; + +class IndirectRenderCommand : public NS::Referencing +{ +public: + void clearBarrier(); + + void drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride); + + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance); + + void drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride); + + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance); + + void reset(); + + void setBarrier(); + + void setCullMode(MTL::CullMode cullMode); + + void setDepthBias(float depthBias, float slopeScale, float clamp); + + void setDepthClipMode(MTL::DepthClipMode depthClipMode); + + void setDepthStencilState(const MTL::DepthStencilState* depthStencilState); + + void setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + + void setFrontFacingWinding(MTL::Winding frontFacingWindning); + + void setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + + void setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + + void setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); + + void setRenderPipelineState(const MTL::RenderPipelineState* pipelineState); + + void setTriangleFillMode(MTL::TriangleFillMode fillMode); + + void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index); +}; +class IndirectComputeCommand : public NS::Referencing +{ +public: + void clearBarrier(); + + void concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup); + + void concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup); + + void reset(); + + void setBarrier(); + + void setComputePipelineState(const MTL::ComputePipelineState* pipelineState); + + void setImageblockWidth(NS::UInteger width, NS::UInteger height); + + void setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index); + + void setStageInRegion(MTL::Region region); + + void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); +}; + +} +_MTL_INLINE void MTL::IndirectRenderCommand::clearBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(clearBarrier)); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance, const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_tessellationFactorBuffer_tessellationFactorBufferOffset_tessellationFactorBufferInstanceStride_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance, buffer, offset, instanceStride); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBarrier)); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setCullMode(MTL::CullMode cullMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setDepthBias(float depthBias, float slopeScale, float clamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setDepthClipMode(MTL::DepthClipMode depthClipMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setDepthStencilState(const MTL::DepthStencilState* depthStencilState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setFrontFacingWinding(MTL::Winding frontFacingWindning) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWindning); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setTriangleFillMode(MTL::TriangleFillMode fillMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IndirectRenderCommand::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::clearBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(clearBarrier)); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(concurrentDispatchThreadgroups_threadsPerThreadgroup_), threadgroupsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::concurrentDispatchThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(concurrentDispatchThreads_threadsPerThreadgroup_), threadsPerGrid, threadsPerThreadgroup); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBarrier)); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setComputePipelineState(const MTL::ComputePipelineState* pipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setComputePipelineState_), pipelineState); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setImageblockWidth(NS::UInteger width, NS::UInteger height) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setImageblockWidth_height_), width, height); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setKernelBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setKernelBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setStageInRegion(MTL::Region region) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStageInRegion_), region); +} + +_MTL_INLINE void MTL::IndirectComputeCommand::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_atIndex_), length, index); +} diff --git a/thirdparty/metal-cpp/Metal/MTLIntersectionFunctionTable.hpp b/thirdparty/metal-cpp/Metal/MTLIntersectionFunctionTable.hpp new file mode 100644 index 0000000000..436653b2ef --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLIntersectionFunctionTable.hpp @@ -0,0 +1,173 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLIntersectionFunctionTable.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class Buffer; +class FunctionHandle; +class IntersectionFunctionTableDescriptor; +class VisibleFunctionTable; + +_MTL_OPTIONS(NS::UInteger, IntersectionFunctionSignature) { + IntersectionFunctionSignatureNone = 0, + IntersectionFunctionSignatureInstancing = 1, + IntersectionFunctionSignatureTriangleData = 1 << 1, + IntersectionFunctionSignatureWorldSpaceData = 1 << 2, + IntersectionFunctionSignatureInstanceMotion = 1 << 3, + IntersectionFunctionSignaturePrimitiveMotion = 1 << 4, + IntersectionFunctionSignatureExtendedLimits = 1 << 5, + IntersectionFunctionSignatureMaxLevels = 1 << 6, + IntersectionFunctionSignatureCurveData = 1 << 7, + IntersectionFunctionSignatureIntersectionFunctionBuffer = 1 << 8, + IntersectionFunctionSignatureUserData = 1 << 9, +}; + +struct IntersectionFunctionBufferArguments +{ + uint64_t intersectionFunctionBuffer; + uint64_t intersectionFunctionBufferSize; + uint64_t intersectionFunctionStride; +} _MTL_PACKED; + +class IntersectionFunctionTableDescriptor : public NS::Copying +{ +public: + static IntersectionFunctionTableDescriptor* alloc(); + + NS::UInteger functionCount() const; + + IntersectionFunctionTableDescriptor* init(); + + static IntersectionFunctionTableDescriptor* intersectionFunctionTableDescriptor(); + + void setFunctionCount(NS::UInteger functionCount); +}; +class IntersectionFunctionTable : public NS::Referencing +{ +public: + ResourceID gpuResourceID() const; + + void setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range); + + void setFunction(const MTL::FunctionHandle* function, NS::UInteger index); + void setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range); + + void setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index); + void setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range); + + void setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index); + void setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range); + + void setVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex); + void setVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range bufferRange); +}; + +} + +_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::IntersectionFunctionTableDescriptor::functionCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionCount)); +} + +_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::IntersectionFunctionTableDescriptor* MTL::IntersectionFunctionTableDescriptor::intersectionFunctionTableDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLIntersectionFunctionTableDescriptor), _MTL_PRIVATE_SEL(intersectionFunctionTableDescriptor)); +} + +_MTL_INLINE void MTL::IntersectionFunctionTableDescriptor::setFunctionCount(NS::UInteger functionCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionCount_), functionCount); +} + +_MTL_INLINE MTL::ResourceID MTL::IntersectionFunctionTable::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setFunction(const MTL::FunctionHandle* function, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunction_atIndex_), function, index); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctions_withRange_), functions, range); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_atIndex_), signature, index); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueCurveIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaqueCurveIntersectionFunctionWithSignature_withRange_), signature, range); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_atIndex_), signature, index); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setOpaqueTriangleIntersectionFunction(MTL::IntersectionFunctionSignature signature, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOpaqueTriangleIntersectionFunctionWithSignature_withRange_), signature, range); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex); +} + +_MTL_INLINE void MTL::IntersectionFunctionTable::setVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range bufferRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibleFunctionTables_withBufferRange_), functionTables, bufferRange); +} diff --git a/thirdparty/metal-cpp/Metal/MTLLibrary.hpp b/thirdparty/metal-cpp/Metal/MTLLibrary.hpp new file mode 100644 index 0000000000..44aa3a7a07 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLLibrary.hpp @@ -0,0 +1,786 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLLibrary.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDataType.hpp" +#include "MTLDefines.hpp" +#include "MTLFunctionDescriptor.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Argument; +class ArgumentEncoder; +class Attribute; +class CompileOptions; +class Device; +class Function; +class FunctionConstant; +class FunctionConstantValues; +class FunctionDescriptor; +class FunctionReflection; +class IntersectionFunctionDescriptor; +class VertexAttribute; +_MTL_ENUM(NS::UInteger, PatchType) { + PatchTypeNone = 0, + PatchTypeTriangle = 1, + PatchTypeQuad = 2, +}; + +_MTL_ENUM(NS::UInteger, FunctionType) { + FunctionTypeVertex = 1, + FunctionTypeFragment = 2, + FunctionTypeKernel = 3, + FunctionTypeVisible = 5, + FunctionTypeIntersection = 6, + FunctionTypeMesh = 7, + FunctionTypeObject = 8, +}; + +_MTL_ENUM(NS::UInteger, LanguageVersion) { + LanguageVersion1_0 = 65536, + LanguageVersion1_1 = 65537, + LanguageVersion1_2 = 65538, + LanguageVersion2_0 = 131072, + LanguageVersion2_1 = 131073, + LanguageVersion2_2 = 131074, + LanguageVersion2_3 = 131075, + LanguageVersion2_4 = 131076, + LanguageVersion3_0 = 196608, + LanguageVersion3_1 = 196609, + LanguageVersion3_2 = 196610, + LanguageVersion4_0 = 262144, +}; + +_MTL_ENUM(NS::Integer, LibraryType) { + LibraryTypeExecutable = 0, + LibraryTypeDynamic = 1, +}; + +_MTL_ENUM(NS::Integer, LibraryOptimizationLevel) { + LibraryOptimizationLevelDefault = 0, + LibraryOptimizationLevelSize = 1, +}; + +_MTL_ENUM(NS::Integer, CompileSymbolVisibility) { + CompileSymbolVisibilityDefault = 0, + CompileSymbolVisibilityHidden = 1, +}; + +_MTL_ENUM(NS::Integer, MathMode) { + MathModeSafe = 0, + MathModeRelaxed = 1, + MathModeFast = 2, +}; + +_MTL_ENUM(NS::Integer, MathFloatingPointFunctions) { + MathFloatingPointFunctionsFast = 0, + MathFloatingPointFunctionsPrecise = 1, +}; + +_MTL_ENUM(NS::UInteger, LibraryError) { + LibraryErrorUnsupported = 1, + LibraryErrorInternal = 2, + LibraryErrorCompileFailure = 3, + LibraryErrorCompileWarning = 4, + LibraryErrorFunctionNotFound = 5, + LibraryErrorFileNotFound = 6, +}; + +using AutoreleasedArgument = MTL::Argument*; +using FunctionCompletionHandlerFunction = std::function; + +class VertexAttribute : public NS::Referencing +{ +public: + [[deprecated("please use isActive instead")]] + bool active() const; + + static VertexAttribute* alloc(); + + NS::UInteger attributeIndex() const; + + DataType attributeType() const; + + VertexAttribute* init(); + + bool isActive() const; + + bool isPatchControlPointData() const; + + bool isPatchData() const; + + NS::String* name() const; + + [[deprecated("please use isPatchControlPointData instead")]] + bool patchControlPointData() const; + + [[deprecated("please use isPatchData instead")]] + bool patchData() const; +}; +class Attribute : public NS::Referencing +{ +public: + [[deprecated("please use isActive instead")]] + bool active() const; + + static Attribute* alloc(); + + NS::UInteger attributeIndex() const; + + DataType attributeType() const; + + Attribute* init(); + + bool isActive() const; + + bool isPatchControlPointData() const; + + bool isPatchData() const; + + NS::String* name() const; + + [[deprecated("please use isPatchControlPointData instead")]] + bool patchControlPointData() const; + + [[deprecated("please use isPatchData instead")]] + bool patchData() const; +}; +class FunctionConstant : public NS::Referencing +{ +public: + static FunctionConstant* alloc(); + + NS::UInteger index() const; + + FunctionConstant* init(); + + NS::String* name() const; + + bool required() const; + + DataType type() const; +}; +class Function : public NS::Referencing +{ +public: + Device* device() const; + + NS::Dictionary* functionConstantsDictionary() const; + + FunctionType functionType() const; + + NS::String* label() const; + + NS::String* name() const; + + ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex); + ArgumentEncoder* newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection); + + FunctionOptions options() const; + + NS::Integer patchControlPointCount() const; + + PatchType patchType() const; + + void setLabel(const NS::String* label); + + NS::Array* stageInputAttributes() const; + + NS::Array* vertexAttributes() const; +}; +class CompileOptions : public NS::Copying +{ +public: + static CompileOptions* alloc(); + + bool allowReferencingUndefinedSymbols() const; + + CompileSymbolVisibility compileSymbolVisibility() const; + + bool enableLogging() const; + + bool fastMathEnabled() const; + + CompileOptions* init(); + + NS::String* installName() const; + + LanguageVersion languageVersion() const; + + NS::Array* libraries() const; + + LibraryType libraryType() const; + + MathFloatingPointFunctions mathFloatingPointFunctions() const; + + MathMode mathMode() const; + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + LibraryOptimizationLevel optimizationLevel() const; + + NS::Dictionary* preprocessorMacros() const; + + bool preserveInvariance() const; + + Size requiredThreadsPerThreadgroup() const; + + void setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols); + + void setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility); + + void setEnableLogging(bool enableLogging); + + void setFastMathEnabled(bool fastMathEnabled); + + void setInstallName(const NS::String* installName); + + void setLanguageVersion(MTL::LanguageVersion languageVersion); + + void setLibraries(const NS::Array* libraries); + + void setLibraryType(MTL::LibraryType libraryType); + + void setMathFloatingPointFunctions(MTL::MathFloatingPointFunctions mathFloatingPointFunctions); + + void setMathMode(MTL::MathMode mathMode); + + void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup); + + void setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel); + + void setPreprocessorMacros(const NS::Dictionary* preprocessorMacros); + + void setPreserveInvariance(bool preserveInvariance); + + void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup); +}; +class FunctionReflection : public NS::Referencing +{ +public: + static FunctionReflection* alloc(); + + NS::Array* bindings() const; + + FunctionReflection* init(); +}; +class Library : public NS::Referencing +{ +public: + Device* device() const; + + NS::Array* functionNames() const; + + NS::String* installName() const; + + NS::String* label() const; + + Function* newFunction(const NS::String* functionName); + Function* newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, NS::Error** error); + void newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*)); + void newFunction(const MTL::FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*)); + Function* newFunction(const MTL::FunctionDescriptor* descriptor, NS::Error** error); + void newFunction(const NS::String* pFunctionName, const MTL::FunctionConstantValues* pConstantValues, const MTL::FunctionCompletionHandlerFunction& completionHandler); + void newFunction(const MTL::FunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler); + + void newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*)); + Function* newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, NS::Error** error); + void newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler); + + FunctionReflection* reflectionForFunction(const NS::String* functionName); + + void setLabel(const NS::String* label); + + LibraryType type() const; +}; + +} +_MTL_INLINE bool MTL::VertexAttribute::active() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexAttribute)); +} + +_MTL_INLINE NS::UInteger MTL::VertexAttribute::attributeIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributeIndex)); +} + +_MTL_INLINE MTL::DataType MTL::VertexAttribute::attributeType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributeType)); +} + +_MTL_INLINE MTL::VertexAttribute* MTL::VertexAttribute::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::VertexAttribute::isActive() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE bool MTL::VertexAttribute::isPatchControlPointData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchControlPointData)); +} + +_MTL_INLINE bool MTL::VertexAttribute::isPatchData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchData)); +} + +_MTL_INLINE NS::String* MTL::VertexAttribute::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE bool MTL::VertexAttribute::patchControlPointData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchControlPointData)); +} + +_MTL_INLINE bool MTL::VertexAttribute::patchData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchData)); +} + +_MTL_INLINE bool MTL::Attribute::active() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE MTL::Attribute* MTL::Attribute::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAttribute)); +} + +_MTL_INLINE NS::UInteger MTL::Attribute::attributeIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributeIndex)); +} + +_MTL_INLINE MTL::DataType MTL::Attribute::attributeType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributeType)); +} + +_MTL_INLINE MTL::Attribute* MTL::Attribute::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::Attribute::isActive() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isActive)); +} + +_MTL_INLINE bool MTL::Attribute::isPatchControlPointData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchControlPointData)); +} + +_MTL_INLINE bool MTL::Attribute::isPatchData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchData)); +} + +_MTL_INLINE NS::String* MTL::Attribute::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE bool MTL::Attribute::patchControlPointData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchControlPointData)); +} + +_MTL_INLINE bool MTL::Attribute::patchData() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isPatchData)); +} + +_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionConstant)); +} + +_MTL_INLINE NS::UInteger MTL::FunctionConstant::index() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(index)); +} + +_MTL_INLINE MTL::FunctionConstant* MTL::FunctionConstant::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::FunctionConstant::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE bool MTL::FunctionConstant::required() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(required)); +} + +_MTL_INLINE MTL::DataType MTL::FunctionConstant::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} + +_MTL_INLINE MTL::Device* MTL::Function::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::Dictionary* MTL::Function::functionConstantsDictionary() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionConstantsDictionary)); +} + +_MTL_INLINE MTL::FunctionType MTL::Function::functionType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionType)); +} + +_MTL_INLINE NS::String* MTL::Function::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::String* MTL::Function::name() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(name)); +} + +_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_), bufferIndex); +} + +_MTL_INLINE MTL::ArgumentEncoder* MTL::Function::newArgumentEncoder(NS::UInteger bufferIndex, const MTL::AutoreleasedArgument* reflection) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newArgumentEncoderWithBufferIndex_reflection_), bufferIndex, reflection); +} + +_MTL_INLINE MTL::FunctionOptions MTL::Function::options() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(options)); +} + +_MTL_INLINE NS::Integer MTL::Function::patchControlPointCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(patchControlPointCount)); +} + +_MTL_INLINE MTL::PatchType MTL::Function::patchType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(patchType)); +} + +_MTL_INLINE void MTL::Function::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE NS::Array* MTL::Function::stageInputAttributes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stageInputAttributes)); +} + +_MTL_INLINE NS::Array* MTL::Function::vertexAttributes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexAttributes)); +} + +_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLCompileOptions)); +} + +_MTL_INLINE bool MTL::CompileOptions::allowReferencingUndefinedSymbols() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allowReferencingUndefinedSymbols)); +} + +_MTL_INLINE MTL::CompileSymbolVisibility MTL::CompileOptions::compileSymbolVisibility() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(compileSymbolVisibility)); +} + +_MTL_INLINE bool MTL::CompileOptions::enableLogging() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(enableLogging)); +} + +_MTL_INLINE bool MTL::CompileOptions::fastMathEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fastMathEnabled)); +} + +_MTL_INLINE MTL::CompileOptions* MTL::CompileOptions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::CompileOptions::installName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(installName)); +} + +_MTL_INLINE MTL::LanguageVersion MTL::CompileOptions::languageVersion() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(languageVersion)); +} + +_MTL_INLINE NS::Array* MTL::CompileOptions::libraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(libraries)); +} + +_MTL_INLINE MTL::LibraryType MTL::CompileOptions::libraryType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(libraryType)); +} + +_MTL_INLINE MTL::MathFloatingPointFunctions MTL::CompileOptions::mathFloatingPointFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mathFloatingPointFunctions)); +} + +_MTL_INLINE MTL::MathMode MTL::CompileOptions::mathMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mathMode)); +} + +_MTL_INLINE NS::UInteger MTL::CompileOptions::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE MTL::LibraryOptimizationLevel MTL::CompileOptions::optimizationLevel() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(optimizationLevel)); +} + +_MTL_INLINE NS::Dictionary* MTL::CompileOptions::preprocessorMacros() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(preprocessorMacros)); +} + +_MTL_INLINE bool MTL::CompileOptions::preserveInvariance() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(preserveInvariance)); +} + +_MTL_INLINE MTL::Size MTL::CompileOptions::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE void MTL::CompileOptions::setAllowReferencingUndefinedSymbols(bool allowReferencingUndefinedSymbols) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAllowReferencingUndefinedSymbols_), allowReferencingUndefinedSymbols); +} + +_MTL_INLINE void MTL::CompileOptions::setCompileSymbolVisibility(MTL::CompileSymbolVisibility compileSymbolVisibility) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCompileSymbolVisibility_), compileSymbolVisibility); +} + +_MTL_INLINE void MTL::CompileOptions::setEnableLogging(bool enableLogging) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEnableLogging_), enableLogging); +} + +_MTL_INLINE void MTL::CompileOptions::setFastMathEnabled(bool fastMathEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFastMathEnabled_), fastMathEnabled); +} + +_MTL_INLINE void MTL::CompileOptions::setInstallName(const NS::String* installName) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInstallName_), installName); +} + +_MTL_INLINE void MTL::CompileOptions::setLanguageVersion(MTL::LanguageVersion languageVersion) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLanguageVersion_), languageVersion); +} + +_MTL_INLINE void MTL::CompileOptions::setLibraries(const NS::Array* libraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLibraries_), libraries); +} + +_MTL_INLINE void MTL::CompileOptions::setLibraryType(MTL::LibraryType libraryType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLibraryType_), libraryType); +} + +_MTL_INLINE void MTL::CompileOptions::setMathFloatingPointFunctions(MTL::MathFloatingPointFunctions mathFloatingPointFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMathFloatingPointFunctions_), mathFloatingPointFunctions); +} + +_MTL_INLINE void MTL::CompileOptions::setMathMode(MTL::MathMode mathMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMathMode_), mathMode); +} + +_MTL_INLINE void MTL::CompileOptions::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL::CompileOptions::setOptimizationLevel(MTL::LibraryOptimizationLevel optimizationLevel) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOptimizationLevel_), optimizationLevel); +} + +_MTL_INLINE void MTL::CompileOptions::setPreprocessorMacros(const NS::Dictionary* preprocessorMacros) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPreprocessorMacros_), preprocessorMacros); +} + +_MTL_INLINE void MTL::CompileOptions::setPreserveInvariance(bool preserveInvariance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPreserveInvariance_), preserveInvariance); +} + +_MTL_INLINE void MTL::CompileOptions::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup); +} + +_MTL_INLINE MTL::FunctionReflection* MTL::FunctionReflection::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLFunctionReflection)); +} + +_MTL_INLINE NS::Array* MTL::FunctionReflection::bindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bindings)); +} + +_MTL_INLINE MTL::FunctionReflection* MTL::FunctionReflection::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Device* MTL::Library::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::Array* MTL::Library::functionNames() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionNames)); +} + +_MTL_INLINE NS::String* MTL::Library::installName() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(installName)); +} + +_MTL_INLINE NS::String* MTL::Library::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* functionName) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newFunctionWithName_), functionName); +} + +_MTL_INLINE MTL::Function* MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_error_), name, constantValues, error); +} + +_MTL_INLINE void MTL::Library::newFunction(const NS::String* name, const MTL::FunctionConstantValues* constantValues, void (^completionHandler)(MTL::Function*, NS::Error*)) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newFunctionWithName_constantValues_completionHandler_), name, constantValues, completionHandler); +} + +_MTL_INLINE void MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*)) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE MTL::Function* MTL::Library::newFunction(const MTL::FunctionDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newFunctionWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE void MTL::Library::newFunction(const NS::String* pFunctionName, const MTL::FunctionConstantValues* pConstantValues, const MTL::FunctionCompletionHandlerFunction& completionHandler) +{ + __block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newFunction(pFunctionName, pConstantValues, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); }); +} + +_MTL_INLINE void MTL::Library::newFunction(const MTL::FunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler) +{ + __block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newFunction(pDescriptor, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); }); +} + +_MTL_INLINE void MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, void (^completionHandler)(MTL::Function*, NS::Error*)) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_completionHandler_), descriptor, completionHandler); +} + +_MTL_INLINE MTL::Function* MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* descriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIntersectionFunctionWithDescriptor_error_), descriptor, error); +} + +_MTL_INLINE void MTL::Library::newIntersectionFunction(const MTL::IntersectionFunctionDescriptor* pDescriptor, const MTL::FunctionCompletionHandlerFunction& completionHandler) +{ + __block MTL::FunctionCompletionHandlerFunction blockCompletionHandler = completionHandler; + newIntersectionFunction(pDescriptor, ^(MTL::Function* pFunction, NS::Error* pError) { blockCompletionHandler(pFunction, pError); }); +} + +_MTL_INLINE MTL::FunctionReflection* MTL::Library::reflectionForFunction(const NS::String* functionName) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(reflectionForFunctionWithName_), functionName); +} + +_MTL_INLINE void MTL::Library::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE MTL::LibraryType MTL::Library::type() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(type)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLLinkedFunctions.hpp b/thirdparty/metal-cpp/Metal/MTLLinkedFunctions.hpp new file mode 100644 index 0000000000..4b1bd95383 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLLinkedFunctions.hpp @@ -0,0 +1,110 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLLinkedFunctions.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ + +class LinkedFunctions : public NS::Copying +{ +public: + static LinkedFunctions* alloc(); + + NS::Array* binaryFunctions() const; + NS::Array* functions() const; + + NS::Dictionary* groups() const; + + LinkedFunctions* init(); + + static LinkedFunctions* linkedFunctions(); + + NS::Array* privateFunctions() const; + + void setBinaryFunctions(const NS::Array* binaryFunctions); + + void setFunctions(const NS::Array* functions); + + void setGroups(const NS::Dictionary* groups); + + void setPrivateFunctions(const NS::Array* privateFunctions); +}; + +} +_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLLinkedFunctions)); +} + +_MTL_INLINE NS::Array* MTL::LinkedFunctions::binaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryFunctions)); +} + +_MTL_INLINE NS::Array* MTL::LinkedFunctions::functions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functions)); +} + +_MTL_INLINE NS::Dictionary* MTL::LinkedFunctions::groups() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(groups)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::LinkedFunctions::linkedFunctions() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLLinkedFunctions), _MTL_PRIVATE_SEL(linkedFunctions)); +} + +_MTL_INLINE NS::Array* MTL::LinkedFunctions::privateFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(privateFunctions)); +} + +_MTL_INLINE void MTL::LinkedFunctions::setBinaryFunctions(const NS::Array* binaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryFunctions_), binaryFunctions); +} + +_MTL_INLINE void MTL::LinkedFunctions::setFunctions(const NS::Array* functions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctions_), functions); +} + +_MTL_INLINE void MTL::LinkedFunctions::setGroups(const NS::Dictionary* groups) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setGroups_), groups); +} + +_MTL_INLINE void MTL::LinkedFunctions::setPrivateFunctions(const NS::Array* privateFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPrivateFunctions_), privateFunctions); +} diff --git a/thirdparty/metal-cpp/Metal/MTLLogState.hpp b/thirdparty/metal-cpp/Metal/MTLLogState.hpp new file mode 100644 index 0000000000..b802adf357 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLLogState.hpp @@ -0,0 +1,111 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLLogState.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class LogStateDescriptor; +_MTL_ENUM(NS::Integer, LogLevel) { + LogLevelUndefined = 0, + LogLevelDebug = 1, + LogLevelInfo = 2, + LogLevelNotice = 3, + LogLevelError = 4, + LogLevelFault = 5, +}; + +_MTL_ENUM(NS::UInteger, LogStateError) { + LogStateErrorInvalidSize = 1, + LogStateErrorInvalid = 2, +}; + +using LogHandlerFunction = std::function; + +_MTL_CONST(NS::ErrorDomain, LogStateErrorDomain); +class LogState : public NS::Referencing +{ +public: + void addLogHandler(void (^block)(NS::String*, NS::String*, MTL::LogLevel, NS::String*)); + void addLogHandler(const MTL::LogHandlerFunction& handler); +}; +class LogStateDescriptor : public NS::Copying +{ +public: + static LogStateDescriptor* alloc(); + + NS::Integer bufferSize() const; + + LogStateDescriptor* init(); + + LogLevel level() const; + + void setBufferSize(NS::Integer bufferSize); + + void setLevel(MTL::LogLevel level); +}; + +} +_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, LogStateErrorDomain); +_MTL_INLINE void MTL::LogState::addLogHandler(void (^block)(NS::String*, NS::String*, MTL::LogLevel, NS::String*)) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addLogHandler_), block); +} + +_MTL_INLINE void MTL::LogState::addLogHandler(const MTL::LogHandlerFunction& handler) +{ + __block LogHandlerFunction function = handler; + addLogHandler(^void(NS::String* subsystem, NS::String* category, MTL::LogLevel logLevel, NS::String* message) { function(subsystem, category, logLevel, message); }); +} + +_MTL_INLINE MTL::LogStateDescriptor* MTL::LogStateDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLLogStateDescriptor)); +} + +_MTL_INLINE NS::Integer MTL::LogStateDescriptor::bufferSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferSize)); +} + +_MTL_INLINE MTL::LogStateDescriptor* MTL::LogStateDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::LogLevel MTL::LogStateDescriptor::level() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(level)); +} + +_MTL_INLINE void MTL::LogStateDescriptor::setBufferSize(NS::Integer bufferSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBufferSize_), bufferSize); +} + +_MTL_INLINE void MTL::LogStateDescriptor::setLevel(MTL::LogLevel level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLevel_), level); +} diff --git a/thirdparty/metal-cpp/Metal/MTLParallelRenderCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLParallelRenderCommandEncoder.hpp new file mode 100644 index 0000000000..8c34512622 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLParallelRenderCommandEncoder.hpp @@ -0,0 +1,83 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLParallelRenderCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderPass.hpp" + +namespace MTL +{ +class RenderCommandEncoder; + +class ParallelRenderCommandEncoder : public NS::Referencing +{ +public: + RenderCommandEncoder* renderCommandEncoder(); + + void setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex); + void setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex); + + void setDepthStoreAction(MTL::StoreAction storeAction); + void setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions); + + void setStencilStoreAction(MTL::StoreAction storeAction); + void setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions); +}; + +} +_MTL_INLINE MTL::RenderCommandEncoder* MTL::ParallelRenderCommandEncoder::renderCommandEncoder() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderCommandEncoder)); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction); +} + +_MTL_INLINE void MTL::ParallelRenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions); +} diff --git a/thirdparty/metal-cpp/Metal/MTLPipeline.hpp b/thirdparty/metal-cpp/Metal/MTLPipeline.hpp new file mode 100644 index 0000000000..930bb7ebb1 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLPipeline.hpp @@ -0,0 +1,104 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class PipelineBufferDescriptor; +class PipelineBufferDescriptorArray; +_MTL_ENUM(NS::UInteger, Mutability) { + MutabilityDefault = 0, + MutabilityMutable = 1, + MutabilityImmutable = 2, +}; + +_MTL_ENUM(NS::Integer, ShaderValidation) { + ShaderValidationDefault = 0, + ShaderValidationEnabled = 1, + ShaderValidationDisabled = 2, +}; + +class PipelineBufferDescriptor : public NS::Copying +{ +public: + static PipelineBufferDescriptor* alloc(); + + PipelineBufferDescriptor* init(); + + Mutability mutability() const; + void setMutability(MTL::Mutability mutability); +}; +class PipelineBufferDescriptorArray : public NS::Referencing +{ +public: + static PipelineBufferDescriptorArray* alloc(); + + PipelineBufferDescriptorArray* init(); + + PipelineBufferDescriptor* object(NS::UInteger bufferIndex); + void setObject(const MTL::PipelineBufferDescriptor* buffer, NS::UInteger bufferIndex); +}; + +} +_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLPipelineBufferDescriptor)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::Mutability MTL::PipelineBufferDescriptor::mutability() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mutability)); +} + +_MTL_INLINE void MTL::PipelineBufferDescriptor::setMutability(MTL::Mutability mutability) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMutability_), mutability); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::PipelineBufferDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLPipelineBufferDescriptorArray)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::PipelineBufferDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::PipelineBufferDescriptor* MTL::PipelineBufferDescriptorArray::object(NS::UInteger bufferIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), bufferIndex); +} + +_MTL_INLINE void MTL::PipelineBufferDescriptorArray::setObject(const MTL::PipelineBufferDescriptor* buffer, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), buffer, bufferIndex); +} diff --git a/thirdparty/metal-cpp/Metal/MTLPixelFormat.hpp b/thirdparty/metal-cpp/Metal/MTLPixelFormat.hpp new file mode 100644 index 0000000000..6d5d886c31 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLPixelFormat.hpp @@ -0,0 +1,173 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLPixelFormat.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +_MTL_ENUM(NS::UInteger, PixelFormat) { + PixelFormatInvalid = 0, + PixelFormatA8Unorm = 1, + PixelFormatR8Unorm = 10, + PixelFormatR8Unorm_sRGB = 11, + PixelFormatR8Snorm = 12, + PixelFormatR8Uint = 13, + PixelFormatR8Sint = 14, + PixelFormatR16Unorm = 20, + PixelFormatR16Snorm = 22, + PixelFormatR16Uint = 23, + PixelFormatR16Sint = 24, + PixelFormatR16Float = 25, + PixelFormatRG8Unorm = 30, + PixelFormatRG8Unorm_sRGB = 31, + PixelFormatRG8Snorm = 32, + PixelFormatRG8Uint = 33, + PixelFormatRG8Sint = 34, + PixelFormatB5G6R5Unorm = 40, + PixelFormatA1BGR5Unorm = 41, + PixelFormatABGR4Unorm = 42, + PixelFormatBGR5A1Unorm = 43, + PixelFormatR32Uint = 53, + PixelFormatR32Sint = 54, + PixelFormatR32Float = 55, + PixelFormatRG16Unorm = 60, + PixelFormatRG16Snorm = 62, + PixelFormatRG16Uint = 63, + PixelFormatRG16Sint = 64, + PixelFormatRG16Float = 65, + PixelFormatRGBA8Unorm = 70, + PixelFormatRGBA8Unorm_sRGB = 71, + PixelFormatRGBA8Snorm = 72, + PixelFormatRGBA8Uint = 73, + PixelFormatRGBA8Sint = 74, + PixelFormatBGRA8Unorm = 80, + PixelFormatBGRA8Unorm_sRGB = 81, + PixelFormatRGB10A2Unorm = 90, + PixelFormatRGB10A2Uint = 91, + PixelFormatRG11B10Float = 92, + PixelFormatRGB9E5Float = 93, + PixelFormatBGR10A2Unorm = 94, + PixelFormatBGR10_XR = 554, + PixelFormatBGR10_XR_sRGB = 555, + PixelFormatRG32Uint = 103, + PixelFormatRG32Sint = 104, + PixelFormatRG32Float = 105, + PixelFormatRGBA16Unorm = 110, + PixelFormatRGBA16Snorm = 112, + PixelFormatRGBA16Uint = 113, + PixelFormatRGBA16Sint = 114, + PixelFormatRGBA16Float = 115, + PixelFormatBGRA10_XR = 552, + PixelFormatBGRA10_XR_sRGB = 553, + PixelFormatRGBA32Uint = 123, + PixelFormatRGBA32Sint = 124, + PixelFormatRGBA32Float = 125, + PixelFormatBC1_RGBA = 130, + PixelFormatBC1_RGBA_sRGB = 131, + PixelFormatBC2_RGBA = 132, + PixelFormatBC2_RGBA_sRGB = 133, + PixelFormatBC3_RGBA = 134, + PixelFormatBC3_RGBA_sRGB = 135, + PixelFormatBC4_RUnorm = 140, + PixelFormatBC4_RSnorm = 141, + PixelFormatBC5_RGUnorm = 142, + PixelFormatBC5_RGSnorm = 143, + PixelFormatBC6H_RGBFloat = 150, + PixelFormatBC6H_RGBUfloat = 151, + PixelFormatBC7_RGBAUnorm = 152, + PixelFormatBC7_RGBAUnorm_sRGB = 153, + PixelFormatPVRTC_RGB_2BPP = 160, + PixelFormatPVRTC_RGB_2BPP_sRGB = 161, + PixelFormatPVRTC_RGB_4BPP = 162, + PixelFormatPVRTC_RGB_4BPP_sRGB = 163, + PixelFormatPVRTC_RGBA_2BPP = 164, + PixelFormatPVRTC_RGBA_2BPP_sRGB = 165, + PixelFormatPVRTC_RGBA_4BPP = 166, + PixelFormatPVRTC_RGBA_4BPP_sRGB = 167, + PixelFormatEAC_R11Unorm = 170, + PixelFormatEAC_R11Snorm = 172, + PixelFormatEAC_RG11Unorm = 174, + PixelFormatEAC_RG11Snorm = 176, + PixelFormatEAC_RGBA8 = 178, + PixelFormatEAC_RGBA8_sRGB = 179, + PixelFormatETC2_RGB8 = 180, + PixelFormatETC2_RGB8_sRGB = 181, + PixelFormatETC2_RGB8A1 = 182, + PixelFormatETC2_RGB8A1_sRGB = 183, + PixelFormatASTC_4x4_sRGB = 186, + PixelFormatASTC_5x4_sRGB = 187, + PixelFormatASTC_5x5_sRGB = 188, + PixelFormatASTC_6x5_sRGB = 189, + PixelFormatASTC_6x6_sRGB = 190, + PixelFormatASTC_8x5_sRGB = 192, + PixelFormatASTC_8x6_sRGB = 193, + PixelFormatASTC_8x8_sRGB = 194, + PixelFormatASTC_10x5_sRGB = 195, + PixelFormatASTC_10x6_sRGB = 196, + PixelFormatASTC_10x8_sRGB = 197, + PixelFormatASTC_10x10_sRGB = 198, + PixelFormatASTC_12x10_sRGB = 199, + PixelFormatASTC_12x12_sRGB = 200, + PixelFormatASTC_4x4_LDR = 204, + PixelFormatASTC_5x4_LDR = 205, + PixelFormatASTC_5x5_LDR = 206, + PixelFormatASTC_6x5_LDR = 207, + PixelFormatASTC_6x6_LDR = 208, + PixelFormatASTC_8x5_LDR = 210, + PixelFormatASTC_8x6_LDR = 211, + PixelFormatASTC_8x8_LDR = 212, + PixelFormatASTC_10x5_LDR = 213, + PixelFormatASTC_10x6_LDR = 214, + PixelFormatASTC_10x8_LDR = 215, + PixelFormatASTC_10x10_LDR = 216, + PixelFormatASTC_12x10_LDR = 217, + PixelFormatASTC_12x12_LDR = 218, + PixelFormatASTC_4x4_HDR = 222, + PixelFormatASTC_5x4_HDR = 223, + PixelFormatASTC_5x5_HDR = 224, + PixelFormatASTC_6x5_HDR = 225, + PixelFormatASTC_6x6_HDR = 226, + PixelFormatASTC_8x5_HDR = 228, + PixelFormatASTC_8x6_HDR = 229, + PixelFormatASTC_8x8_HDR = 230, + PixelFormatASTC_10x5_HDR = 231, + PixelFormatASTC_10x6_HDR = 232, + PixelFormatASTC_10x8_HDR = 233, + PixelFormatASTC_10x10_HDR = 234, + PixelFormatASTC_12x10_HDR = 235, + PixelFormatASTC_12x12_HDR = 236, + PixelFormatGBGR422 = 240, + PixelFormatBGRG422 = 241, + PixelFormatDepth16Unorm = 250, + PixelFormatDepth32Float = 252, + PixelFormatStencil8 = 253, + PixelFormatDepth24Unorm_Stencil8 = 255, + PixelFormatDepth32Float_Stencil8 = 260, + PixelFormatX32_Stencil8 = 261, + PixelFormatX24_Stencil8 = 262, + PixelFormatUnspecialized = 263, +}; + +} diff --git a/thirdparty/metal-cpp/Metal/MTLPrivate.hpp b/thirdparty/metal-cpp/Metal/MTLPrivate.hpp new file mode 100644 index 0000000000..41bcaa508c --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLPrivate.hpp @@ -0,0 +1,156 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLPrivate.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLDefines.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _MTL_PRIVATE_CLS(symbol) (MTL::Private::Class::s_k##symbol) +#define _MTL_PRIVATE_SEL(accessor) (MTL::Private::Selector::s_k##accessor) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#if defined(MTL_PRIVATE_IMPLEMENTATION) + +#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN +#define _MTL_PRIVATE_VISIBILITY __attribute__((visibility("hidden"))) +#else +#define _MTL_PRIVATE_VISIBILITY __attribute__((visibility("default"))) +#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN + +#define _MTL_PRIVATE_IMPORT __attribute__((weak_import)) + +#ifdef __OBJC__ +#define _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol)) +#define _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol)) +#else +#define _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol) +#define _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol) +#endif // __OBJC__ + +#define _MTL_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _MTL_PRIVATE_VISIBILITY = _MTL_PRIVATE_OBJC_LOOKUP_CLASS(symbol) +#define _MTL_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _MTL_PRIVATE_VISIBILITY = _MTL_PRIVATE_OBJC_GET_PROTOCOL(symbol) +#define _MTL_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _MTL_PRIVATE_VISIBILITY = sel_registerName(symbol) + +#include +#define MTL_DEF_FUNC( name, signature ) \ + using Fn##name = signature; \ + Fn##name name = reinterpret_cast< Fn##name >( dlsym( RTLD_DEFAULT, #name ) ) + +namespace MTL::Private +{ + template + inline _Type const LoadSymbol(const char* pSymbol) + { + const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol)); + + return pAddress ? *pAddress : nullptr; + } +} // MTL::Private + +#if defined(__MAC_26_0) || defined(__IPHONE_26_0) || defined(__TVOS_26_0) + +#define _MTL_PRIVATE_DEF_STR(type, symbol) \ + _MTL_EXTERN type const MTL##symbol _MTL_PRIVATE_IMPORT; \ + type const MTL::symbol = (nullptr != &MTL##symbol) ? MTL##symbol : nullptr + +#define _MTL_PRIVATE_DEF_CONST(type, symbol) \ + _MTL_EXTERN type const MTL##symbol _MTL_PRIVATE_IMPORT; \ + type const MTL::symbol = (nullptr != &MTL##symbol) ? MTL##symbol : nullptr + +#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) \ + _MTL_EXTERN type const MTL##symbol; \ + type const MTL::symbol = MTL::Private::LoadSymbol("MTL" #symbol) + +#else + +#define _MTL_PRIVATE_DEF_STR(type, symbol) \ + _MTL_EXTERN type const MTL##symbol; \ + type const MTL::symbol = MTL::Private::LoadSymbol("MTL" #symbol) + +#define _MTL_PRIVATE_DEF_CONST(type, symbol) \ + _MTL_EXTERN type const MTL##symbol; \ + type const MTL::symbol = MTL::Private::LoadSymbol("MTL" #symbol) + +#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) _MTL_PRIVATE_DEF_CONST(type, symbol) + +#endif + +#else + +#define _MTL_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol +#define _MTL_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol +#define _MTL_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor +#define _MTL_PRIVATE_DEF_STR(type, symbol) extern type const MTL::symbol +#define _MTL_PRIVATE_DEF_CONST(type, symbol) extern type const MTL::symbol +#define _MTL_PRIVATE_DEF_WEAK_CONST(type, symbol) extern type const MTL::symbol + +#endif // MTL_PRIVATE_IMPLEMENTATION + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL +{ +namespace Private +{ + namespace Class + { + + } // Class +} // Private +} // MTL + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL +{ +namespace Private +{ + namespace Protocol + { + + } // Protocol +} // Private +} // MTL + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL +{ +namespace Private +{ + namespace Selector + { + + _MTL_PRIVATE_DEF_SEL(beginScope, + "beginScope"); + _MTL_PRIVATE_DEF_SEL(endScope, + "endScope"); + } // Class +} // Private +} // MTL + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/Metal/MTLRasterizationRate.hpp b/thirdparty/metal-cpp/Metal/MTLRasterizationRate.hpp new file mode 100644 index 0000000000..b2804fa84b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLRasterizationRate.hpp @@ -0,0 +1,337 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLRasterizationRate.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLDevice.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Buffer; +class Device; +class RasterizationRateLayerArray; +class RasterizationRateLayerDescriptor; +class RasterizationRateMapDescriptor; +class RasterizationRateSampleArray; + +class RasterizationRateSampleArray : public NS::Referencing +{ +public: + static RasterizationRateSampleArray* alloc(); + + RasterizationRateSampleArray* init(); + + NS::Number* object(NS::UInteger index); + void setObject(const NS::Number* value, NS::UInteger index); +}; +class RasterizationRateLayerDescriptor : public NS::Copying +{ +public: + static RasterizationRateLayerDescriptor* alloc(); + + RasterizationRateSampleArray* horizontal() const; + float* horizontalSampleStorage() const; + + RasterizationRateLayerDescriptor* init(); + RasterizationRateLayerDescriptor* init(MTL::Size sampleCount); + RasterizationRateLayerDescriptor* init(MTL::Size sampleCount, const float* horizontal, const float* vertical); + + Size maxSampleCount() const; + Size sampleCount() const; + void setSampleCount(MTL::Size sampleCount); + + RasterizationRateSampleArray* vertical() const; + float* verticalSampleStorage() const; +}; +class RasterizationRateLayerArray : public NS::Referencing +{ +public: + static RasterizationRateLayerArray* alloc(); + + RasterizationRateLayerArray* init(); + + RasterizationRateLayerDescriptor* object(NS::UInteger layerIndex); + void setObject(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex); +}; +class RasterizationRateMapDescriptor : public NS::Copying +{ +public: + static RasterizationRateMapDescriptor* alloc(); + + RasterizationRateMapDescriptor* init(); + + NS::String* label() const; + + RasterizationRateLayerDescriptor* layer(NS::UInteger layerIndex); + NS::UInteger layerCount() const; + + RasterizationRateLayerArray* layers() const; + + static RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize); + static RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize, const MTL::RasterizationRateLayerDescriptor* layer); + static RasterizationRateMapDescriptor* rasterizationRateMapDescriptor(MTL::Size screenSize, NS::UInteger layerCount, const MTL::RasterizationRateLayerDescriptor* const* layers); + + Size screenSize() const; + + void setLabel(const NS::String* label); + + void setLayer(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex); + + void setScreenSize(MTL::Size screenSize); +}; +class RasterizationRateMap : public NS::Referencing +{ +public: + void copyParameterDataToBuffer(const MTL::Buffer* buffer, NS::UInteger offset); + + Device* device() const; + + NS::String* label() const; + + NS::UInteger layerCount() const; + + Coordinate2D mapPhysicalToScreenCoordinates(MTL::Coordinate2D physicalCoordinates, NS::UInteger layerIndex); + + Coordinate2D mapScreenToPhysicalCoordinates(MTL::Coordinate2D screenCoordinates, NS::UInteger layerIndex); + + SizeAndAlign parameterBufferSizeAndAlign() const; + + Size physicalGranularity() const; + + Size physicalSize(NS::UInteger layerIndex); + + Size screenSize() const; +}; + +} +_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateSampleArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRasterizationRateSampleArray)); +} + +_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateSampleArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Number* MTL::RasterizationRateSampleArray::object(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index); +} + +_MTL_INLINE void MTL::RasterizationRateSampleArray::setObject(const NS::Number* value, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), value, index); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRasterizationRateLayerDescriptor)); +} + +_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateLayerDescriptor::horizontal() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(horizontal)); +} + +_MTL_INLINE float* MTL::RasterizationRateLayerDescriptor::horizontalSampleStorage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(horizontalSampleStorage)); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init(MTL::Size sampleCount) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithSampleCount_), sampleCount); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerDescriptor::init(MTL::Size sampleCount, const float* horizontal, const float* vertical) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithSampleCount_horizontal_vertical_), sampleCount, horizontal, vertical); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateLayerDescriptor::maxSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxSampleCount)); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateLayerDescriptor::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} + +_MTL_INLINE void MTL::RasterizationRateLayerDescriptor::setSampleCount(MTL::Size sampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount); +} + +_MTL_INLINE MTL::RasterizationRateSampleArray* MTL::RasterizationRateLayerDescriptor::vertical() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertical)); +} + +_MTL_INLINE float* MTL::RasterizationRateLayerDescriptor::verticalSampleStorage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(verticalSampleStorage)); +} + +_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateLayerArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRasterizationRateLayerArray)); +} + +_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateLayerArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateLayerArray::object(NS::UInteger layerIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), layerIndex); +} + +_MTL_INLINE void MTL::RasterizationRateLayerArray::setObject(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), layer, layerIndex); +} + +_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor)); +} + +_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::RasterizationRateMapDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::RasterizationRateLayerDescriptor* MTL::RasterizationRateMapDescriptor::layer(NS::UInteger layerIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layerAtIndex_), layerIndex); +} + +_MTL_INLINE NS::UInteger MTL::RasterizationRateMapDescriptor::layerCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layerCount)); +} + +_MTL_INLINE MTL::RasterizationRateLayerArray* MTL::RasterizationRateMapDescriptor::layers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layers)); +} + +_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_), screenSize); +} + +_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize, const MTL::RasterizationRateLayerDescriptor* layer) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_layer_), screenSize, layer); +} + +_MTL_INLINE MTL::RasterizationRateMapDescriptor* MTL::RasterizationRateMapDescriptor::rasterizationRateMapDescriptor(MTL::Size screenSize, NS::UInteger layerCount, const MTL::RasterizationRateLayerDescriptor* const* layers) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLRasterizationRateMapDescriptor), _MTL_PRIVATE_SEL(rasterizationRateMapDescriptorWithScreenSize_layerCount_layers_), screenSize, layerCount, layers); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateMapDescriptor::screenSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(screenSize)); +} + +_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setLayer(const MTL::RasterizationRateLayerDescriptor* layer, NS::UInteger layerIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLayer_atIndex_), layer, layerIndex); +} + +_MTL_INLINE void MTL::RasterizationRateMapDescriptor::setScreenSize(MTL::Size screenSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScreenSize_), screenSize); +} + +_MTL_INLINE void MTL::RasterizationRateMap::copyParameterDataToBuffer(const MTL::Buffer* buffer, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(copyParameterDataToBuffer_offset_), buffer, offset); +} + +_MTL_INLINE MTL::Device* MTL::RasterizationRateMap::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::RasterizationRateMap::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::RasterizationRateMap::layerCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layerCount)); +} + +_MTL_INLINE MTL::Coordinate2D MTL::RasterizationRateMap::mapPhysicalToScreenCoordinates(MTL::Coordinate2D physicalCoordinates, NS::UInteger layerIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mapPhysicalToScreenCoordinates_forLayer_), physicalCoordinates, layerIndex); +} + +_MTL_INLINE MTL::Coordinate2D MTL::RasterizationRateMap::mapScreenToPhysicalCoordinates(MTL::Coordinate2D screenCoordinates, NS::UInteger layerIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mapScreenToPhysicalCoordinates_forLayer_), screenCoordinates, layerIndex); +} + +_MTL_INLINE MTL::SizeAndAlign MTL::RasterizationRateMap::parameterBufferSizeAndAlign() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(parameterBufferSizeAndAlign)); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateMap::physicalGranularity() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(physicalGranularity)); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateMap::physicalSize(NS::UInteger layerIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(physicalSizeForLayer_), layerIndex); +} + +_MTL_INLINE MTL::Size MTL::RasterizationRateMap::screenSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(screenSize)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLRenderCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLRenderCommandEncoder.hpp new file mode 100644 index 0000000000..b2667b77e1 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLRenderCommandEncoder.hpp @@ -0,0 +1,1019 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResourceStatePass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLArgument.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderPass.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class AccelerationStructure; +class Buffer; +class CounterSampleBuffer; +class DepthStencilState; +class Fence; +class Heap; +class IndirectCommandBuffer; +class IntersectionFunctionTable; +class LogicalToPhysicalColorAttachmentMap; +class RenderPipelineState; +class Resource; +class SamplerState; +struct ScissorRect; +class Texture; +struct VertexAmplificationViewMapping; +struct Viewport; +class VisibleFunctionTable; +_MTL_ENUM(NS::UInteger, PrimitiveType) { + PrimitiveTypePoint = 0, + PrimitiveTypeLine = 1, + PrimitiveTypeLineStrip = 2, + PrimitiveTypeTriangle = 3, + PrimitiveTypeTriangleStrip = 4, +}; + +_MTL_ENUM(NS::UInteger, VisibilityResultMode) { + VisibilityResultModeDisabled = 0, + VisibilityResultModeBoolean = 1, + VisibilityResultModeCounting = 2, +}; + +_MTL_ENUM(NS::UInteger, CullMode) { + CullModeNone = 0, + CullModeFront = 1, + CullModeBack = 2, +}; + +_MTL_ENUM(NS::UInteger, Winding) { + WindingClockwise = 0, + WindingCounterClockwise = 1, +}; + +_MTL_ENUM(NS::UInteger, DepthClipMode) { + DepthClipModeClip = 0, + DepthClipModeClamp = 1, +}; + +_MTL_ENUM(NS::UInteger, TriangleFillMode) { + TriangleFillModeFill = 0, + TriangleFillModeLines = 1, +}; + +_MTL_OPTIONS(NS::UInteger, RenderStages) { + RenderStageVertex = 1, + RenderStageFragment = 1 << 1, + RenderStageTile = 1 << 2, + RenderStageObject = 1 << 3, + RenderStageMesh = 1 << 4, +}; + +struct ScissorRect +{ + NS::UInteger x; + NS::UInteger y; + NS::UInteger width; + NS::UInteger height; +} _MTL_PACKED; + +struct Viewport +{ + double originX; + double originY; + double width; + double height; + double znear; + double zfar; +} _MTL_PACKED; + +struct DrawPrimitivesIndirectArguments +{ + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t vertexStart; + uint32_t baseInstance; +} _MTL_PACKED; + +struct DrawIndexedPrimitivesIndirectArguments +{ + uint32_t indexCount; + uint32_t instanceCount; + uint32_t indexStart; + int32_t baseVertex; + uint32_t baseInstance; +} _MTL_PACKED; + +struct VertexAmplificationViewMapping +{ + uint32_t viewportArrayIndexOffset; + uint32_t renderTargetArrayIndexOffset; +} _MTL_PACKED; + +struct DrawPatchIndirectArguments +{ + uint32_t patchCount; + uint32_t instanceCount; + uint32_t patchStart; + uint32_t baseInstance; +} _MTL_PACKED; + +struct QuadTessellationFactorsHalf +{ + uint16_t edgeTessellationFactor[4]; + uint16_t insideTessellationFactor[2]; +} _MTL_PACKED; + +struct TriangleTessellationFactorsHalf +{ + uint16_t edgeTessellationFactor[3]; + uint16_t insideTessellationFactor; +} _MTL_PACKED; + +class RenderCommandEncoder : public NS::Referencing +{ +public: + void dispatchThreadsPerTile(MTL::Size threadsPerTile); + + void drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance); + void drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance); + void drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + + void drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + void drawMeshThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup); + + void drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance); + void drawPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount); + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount); + void drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance); + void drawPrimitives(MTL::PrimitiveType primitiveType, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange); + void executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset); + + void memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before); + void memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before); + + void sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier); + + void setBlendColor(float red, float green, float blue, float alpha); + + void setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping); + + void setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex); + void setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex); + + void setCullMode(MTL::CullMode cullMode); + + void setDepthBias(float depthBias, float slopeScale, float clamp); + + void setDepthClipMode(MTL::DepthClipMode depthClipMode); + + void setDepthStencilState(const MTL::DepthStencilState* depthStencilState); + + void setDepthStoreAction(MTL::StoreAction storeAction); + void setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions); + + void setDepthTestBounds(float minBound, float maxBound); + + void setFragmentAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex); + + void setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index); + + void setFragmentBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range); + + void setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + + void setFragmentIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex); + void setFragmentIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range); + + void setFragmentSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setFragmentSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setFragmentSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setFragmentSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range); + + void setFragmentTexture(const MTL::Texture* texture, NS::UInteger index); + void setFragmentTextures(const MTL::Texture* const textures[], NS::Range range); + + void setFragmentVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex); + void setFragmentVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range); + + void setFrontFacingWinding(MTL::Winding frontFacingWinding); + + void setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setMeshBufferOffset(NS::UInteger offset, NS::UInteger index); + + void setMeshBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range); + + void setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + + void setMeshSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setMeshSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setMeshSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setMeshSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range); + + void setMeshTexture(const MTL::Texture* texture, NS::UInteger index); + void setMeshTextures(const MTL::Texture* const textures[], NS::Range range); + + void setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setObjectBufferOffset(NS::UInteger offset, NS::UInteger index); + + void setObjectBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range); + + void setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + + void setObjectSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setObjectSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setObjectSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setObjectSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range); + + void setObjectTexture(const MTL::Texture* texture, NS::UInteger index); + void setObjectTextures(const MTL::Texture* const textures[], NS::Range range); + + void setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index); + + void setRenderPipelineState(const MTL::RenderPipelineState* pipelineState); + + void setScissorRect(MTL::ScissorRect rect); + void setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count); + + void setStencilReferenceValue(uint32_t referenceValue); + void setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue); + + void setStencilStoreAction(MTL::StoreAction storeAction); + void setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions); + + void setTessellationFactorBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride); + + void setTessellationFactorScale(float scale); + + void setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index); + + void setTileAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex); + + void setTileBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setTileBufferOffset(NS::UInteger offset, NS::UInteger index); + + void setTileBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range); + + void setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + + void setTileIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex); + void setTileIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range); + + void setTileSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setTileSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setTileSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setTileSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range); + + void setTileTexture(const MTL::Texture* texture, NS::UInteger index); + void setTileTextures(const MTL::Texture* const textures[], NS::Range range); + + void setTileVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex); + void setTileVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range); + + void setTriangleFillMode(MTL::TriangleFillMode fillMode); + + void setVertexAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex); + + void setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings); + + void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index); + void setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index); + void setVertexBufferOffset(NS::UInteger offset, NS::UInteger index); + void setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index); + + void setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range); + void setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range); + + void setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index); + void setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index); + + void setVertexIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex); + void setVertexIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range); + + void setVertexSamplerState(const MTL::SamplerState* sampler, NS::UInteger index); + void setVertexSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index); + void setVertexSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range); + void setVertexSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range); + + void setVertexTexture(const MTL::Texture* texture, NS::UInteger index); + void setVertexTextures(const MTL::Texture* const textures[], NS::Range range); + + void setVertexVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex); + void setVertexVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range); + + void setViewport(MTL::Viewport viewport); + void setViewports(const MTL::Viewport* viewports, NS::UInteger count); + + void setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset); + + void textureBarrier(); + + NS::UInteger tileHeight() const; + + NS::UInteger tileWidth() const; + + void updateFence(const MTL::Fence* fence, MTL::RenderStages stages); + + void useHeap(const MTL::Heap* heap); + void useHeap(const MTL::Heap* heap, MTL::RenderStages stages); + void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count); + void useHeaps(const MTL::Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages); + + void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage); + void useResource(const MTL::Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages); + void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage); + void useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages); + + void waitForFence(const MTL::Fence* fence, MTL::RenderStages stages); +}; + +} + +_MTL_INLINE void MTL::RenderCommandEncoder::dispatchThreadsPerTile(MTL::Size threadsPerTile) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(dispatchThreadsPerTile_), threadsPerTile); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_), primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_), primitiveType, vertexStart, vertexCount, instanceCount); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_), primitiveType, vertexStart, vertexCount); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_), primitiveType, indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_afterStages_beforeStages_), scope, after, before); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_), resources, count, after, before); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setBlendColor(float red, float green, float blue, float alpha) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBlendColorRed_green_blue_alpha_), red, green, blue, alpha); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setColorAttachmentMap(const MTL::LogicalToPhysicalColorAttachmentMap* mapping) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorAttachmentMap_), mapping); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setCullMode(MTL::CullMode cullMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthBias(float depthBias, float slopeScale, float clamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthClipMode(MTL::DepthClipMode depthClipMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setDepthTestBounds(float minBound, float maxBound) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthTestMinBound_maxBound_), minBound, maxBound); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTables_withBufferRange_), functionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setFrontFacingWinding(MTL::Winding frontFacingWinding) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWinding); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setMeshTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setScissorRect(MTL::ScissorRect rect) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScissorRect_), rect); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setScissorRects_count_), scissorRects, count); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValue(uint32_t referenceValue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilReferenceValue_), referenceValue); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilFrontReferenceValue_backReferenceValue_), frontReferenceValue, backReferenceValue); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationFactorBuffer_offset_instanceStride_), buffer, offset, instanceStride); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorScale(float scale) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationFactorScale_), scale); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_offset_atIndex_), length, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTables_withBufferRange_), functionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setTriangleFillMode(MTL::TriangleFillMode fillMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexAmplificationCount_viewMappings_), count, viewMappings); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_atIndex_), offset, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_attributeStride_atIndex_), offset, stride, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_withRange_), buffers, offsets, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBytes_length_atIndex_), bytes, length, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexBytes_length_attributeStride_atIndex_), bytes, length, stride, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexSamplerState_atIndex_), sampler, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_withRange_), samplers, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexTexture(const MTL::Texture* texture, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexTexture_atIndex_), texture, index); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexTextures(const MTL::Texture* const textures[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexTextures_withRange_), textures, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTables_withBufferRange_), functionTables, range); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setViewport(MTL::Viewport viewport) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setViewport_), viewport); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setViewports(const MTL::Viewport* viewports, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setViewports_count_), viewports, count); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultMode_offset_), mode, offset); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::textureBarrier() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(textureBarrier)); +} + +_MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileHeight)); +} + +_MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileWidth)); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::updateFence(const MTL::Fence* fence, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_afterStages_), fence, stages); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeap_), heap); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeap_stages_), heap, stages); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useHeaps_count_stages_), heaps, count, stages); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResource_usage_stages_), resource, usage, stages); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(useResources_count_usage_stages_), resources, count, usage, stages); +} + +_MTL_INLINE void MTL::RenderCommandEncoder::waitForFence(const MTL::Fence* fence, MTL::RenderStages stages) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_beforeStages_), fence, stages); +} diff --git a/thirdparty/metal-cpp/Metal/MTLRenderPass.hpp b/thirdparty/metal-cpp/Metal/MTLRenderPass.hpp new file mode 100644 index 0000000000..ed2172d731 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLRenderPass.hpp @@ -0,0 +1,792 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLRenderPass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +namespace MTL +{ +class Buffer; +class CounterSampleBuffer; +class RasterizationRateMap; +class RenderPassAttachmentDescriptor; +class RenderPassColorAttachmentDescriptor; +class RenderPassColorAttachmentDescriptorArray; +class RenderPassDepthAttachmentDescriptor; +class RenderPassDescriptor; +class RenderPassSampleBufferAttachmentDescriptor; +class RenderPassSampleBufferAttachmentDescriptorArray; +class RenderPassStencilAttachmentDescriptor; +struct SamplePosition; +class Texture; +_MTL_ENUM(NS::UInteger, LoadAction) { + LoadActionDontCare = 0, + LoadActionLoad = 1, + LoadActionClear = 2, +}; + +_MTL_ENUM(NS::UInteger, StoreAction) { + StoreActionDontCare = 0, + StoreActionStore = 1, + StoreActionMultisampleResolve = 2, + StoreActionStoreAndMultisampleResolve = 3, + StoreActionUnknown = 4, + StoreActionCustomSampleDepthStore = 5, +}; + +_MTL_ENUM(NS::Integer, VisibilityResultType) { + VisibilityResultTypeReset = 0, + VisibilityResultTypeAccumulate = 1, +}; + +_MTL_ENUM(NS::UInteger, MultisampleDepthResolveFilter) { + MultisampleDepthResolveFilterSample0 = 0, + MultisampleDepthResolveFilterMin = 1, + MultisampleDepthResolveFilterMax = 2, +}; + +_MTL_ENUM(NS::UInteger, MultisampleStencilResolveFilter) { + MultisampleStencilResolveFilterSample0 = 0, + MultisampleStencilResolveFilterDepthResolvedSample = 1, +}; + +_MTL_OPTIONS(NS::UInteger, StoreActionOptions) { + StoreActionOptionNone = 0, + StoreActionOptionCustomSamplePositions = 1, + StoreActionOptionValidMask = 1, +}; + +struct ClearColor +{ + ClearColor() = default; + + ClearColor(double red, double green, double blue, double alpha); + + static ClearColor Make(double red, double green, double blue, double alpha); + + double red; + double green; + double blue; + double alpha; +} _MTL_PACKED; + +class RenderPassAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPassAttachmentDescriptor* alloc(); + + NS::UInteger depthPlane() const; + + RenderPassAttachmentDescriptor* init(); + + NS::UInteger level() const; + + LoadAction loadAction() const; + + NS::UInteger resolveDepthPlane() const; + + NS::UInteger resolveLevel() const; + + NS::UInteger resolveSlice() const; + + Texture* resolveTexture() const; + + void setDepthPlane(NS::UInteger depthPlane); + + void setLevel(NS::UInteger level); + + void setLoadAction(MTL::LoadAction loadAction); + + void setResolveDepthPlane(NS::UInteger resolveDepthPlane); + + void setResolveLevel(NS::UInteger resolveLevel); + + void setResolveSlice(NS::UInteger resolveSlice); + + void setResolveTexture(const MTL::Texture* resolveTexture); + + void setSlice(NS::UInteger slice); + + void setStoreAction(MTL::StoreAction storeAction); + void setStoreActionOptions(MTL::StoreActionOptions storeActionOptions); + + void setTexture(const MTL::Texture* texture); + + NS::UInteger slice() const; + + StoreAction storeAction() const; + StoreActionOptions storeActionOptions() const; + + Texture* texture() const; +}; +class RenderPassColorAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPassColorAttachmentDescriptor* alloc(); + + ClearColor clearColor() const; + + RenderPassColorAttachmentDescriptor* init(); + + void setClearColor(MTL::ClearColor clearColor); +}; +class RenderPassDepthAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPassDepthAttachmentDescriptor* alloc(); + + double clearDepth() const; + + MultisampleDepthResolveFilter depthResolveFilter() const; + + RenderPassDepthAttachmentDescriptor* init(); + + void setClearDepth(double clearDepth); + + void setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter); +}; +class RenderPassStencilAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPassStencilAttachmentDescriptor* alloc(); + + uint32_t clearStencil() const; + + RenderPassStencilAttachmentDescriptor* init(); + + void setClearStencil(uint32_t clearStencil); + + void setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter); + MultisampleStencilResolveFilter stencilResolveFilter() const; +}; +class RenderPassColorAttachmentDescriptorArray : public NS::Referencing +{ +public: + static RenderPassColorAttachmentDescriptorArray* alloc(); + + RenderPassColorAttachmentDescriptorArray* init(); + + RenderPassColorAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class RenderPassSampleBufferAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPassSampleBufferAttachmentDescriptor* alloc(); + + NS::UInteger endOfFragmentSampleIndex() const; + + NS::UInteger endOfVertexSampleIndex() const; + + RenderPassSampleBufferAttachmentDescriptor* init(); + + CounterSampleBuffer* sampleBuffer() const; + + void setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex); + + void setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex); + + void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer); + + void setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex); + + void setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex); + + NS::UInteger startOfFragmentSampleIndex() const; + + NS::UInteger startOfVertexSampleIndex() const; +}; +class RenderPassSampleBufferAttachmentDescriptorArray : public NS::Referencing +{ +public: + static RenderPassSampleBufferAttachmentDescriptorArray* alloc(); + + RenderPassSampleBufferAttachmentDescriptorArray* init(); + + RenderPassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class RenderPassDescriptor : public NS::Copying +{ +public: + static RenderPassDescriptor* alloc(); + + RenderPassColorAttachmentDescriptorArray* colorAttachments() const; + + NS::UInteger defaultRasterSampleCount() const; + + RenderPassDepthAttachmentDescriptor* depthAttachment() const; + + NS::UInteger getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count); + + NS::UInteger imageblockSampleLength() const; + + RenderPassDescriptor* init(); + + RasterizationRateMap* rasterizationRateMap() const; + + static RenderPassDescriptor* renderPassDescriptor(); + + NS::UInteger renderTargetArrayLength() const; + + NS::UInteger renderTargetHeight() const; + + NS::UInteger renderTargetWidth() const; + + RenderPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const; + + void setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount); + + void setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment); + + void setImageblockSampleLength(NS::UInteger imageblockSampleLength); + + void setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap); + + void setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength); + + void setRenderTargetHeight(NS::UInteger renderTargetHeight); + + void setRenderTargetWidth(NS::UInteger renderTargetWidth); + + void setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count); + + void setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment); + + void setSupportColorAttachmentMapping(bool supportColorAttachmentMapping); + + void setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength); + + void setTileHeight(NS::UInteger tileHeight); + + void setTileWidth(NS::UInteger tileWidth); + + void setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer); + + void setVisibilityResultType(MTL::VisibilityResultType visibilityResultType); + + RenderPassStencilAttachmentDescriptor* stencilAttachment() const; + + bool supportColorAttachmentMapping() const; + + NS::UInteger threadgroupMemoryLength() const; + + NS::UInteger tileHeight() const; + + NS::UInteger tileWidth() const; + + Buffer* visibilityResultBuffer() const; + + VisibilityResultType visibilityResultType() const; +}; + +} +_MTL_INLINE MTL::ClearColor::ClearColor(double red, double green, double blue, double alpha) + : red(red) + , green(green) + , blue(blue) + , alpha(alpha) +{ +} + +_MTL_INLINE MTL::ClearColor MTL::ClearColor::Make(double red, double green, double blue, double alpha) +{ + return ClearColor(red, green, blue, alpha); +} + +_MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::depthPlane() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthPlane)); +} + +_MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::level() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(level)); +} + +_MTL_INLINE MTL::LoadAction MTL::RenderPassAttachmentDescriptor::loadAction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(loadAction)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveDepthPlane() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveDepthPlane)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveLevel() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveLevel)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveSlice() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveSlice)); +} + +_MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::resolveTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resolveTexture)); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setDepthPlane(NS::UInteger depthPlane) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthPlane_), depthPlane); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLevel(NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLevel_), level); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLoadAction(MTL::LoadAction loadAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLoadAction_), loadAction); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveDepthPlane(NS::UInteger resolveDepthPlane) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResolveDepthPlane_), resolveDepthPlane); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveLevel(NS::UInteger resolveLevel) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResolveLevel_), resolveLevel); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveSlice(NS::UInteger resolveSlice) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResolveSlice_), resolveSlice); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveTexture(const MTL::Texture* resolveTexture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResolveTexture_), resolveTexture); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setSlice(NS::UInteger slice) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSlice_), slice); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreAction(MTL::StoreAction storeAction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStoreAction_), storeAction); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreActionOptions(MTL::StoreActionOptions storeActionOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStoreActionOptions_), storeActionOptions); +} + +_MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setTexture(const MTL::Texture* texture) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTexture_), texture); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::slice() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(slice)); +} + +_MTL_INLINE MTL::StoreAction MTL::RenderPassAttachmentDescriptor::storeAction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storeAction)); +} + +_MTL_INLINE MTL::StoreActionOptions MTL::RenderPassAttachmentDescriptor::storeActionOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storeActionOptions)); +} + +_MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::texture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(texture)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptor)); +} + +_MTL_INLINE MTL::ClearColor MTL::RenderPassColorAttachmentDescriptor::clearColor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(clearColor)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::RenderPassColorAttachmentDescriptor::setClearColor(MTL::ClearColor clearColor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setClearColor_), clearColor); +} + +_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassDepthAttachmentDescriptor)); +} + +_MTL_INLINE double MTL::RenderPassDepthAttachmentDescriptor::clearDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(clearDepth)); +} + +_MTL_INLINE MTL::MultisampleDepthResolveFilter MTL::RenderPassDepthAttachmentDescriptor::depthResolveFilter() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthResolveFilter)); +} + +_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setClearDepth(double clearDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setClearDepth_), clearDepth); +} + +_MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthResolveFilter_), depthResolveFilter); +} + +_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassStencilAttachmentDescriptor)); +} + +_MTL_INLINE uint32_t MTL::RenderPassStencilAttachmentDescriptor::clearStencil() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(clearStencil)); +} + +_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setClearStencil(uint32_t clearStencil) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setClearStencil_), clearStencil); +} + +_MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilResolveFilter_), stencilResolveFilter); +} + +_MTL_INLINE MTL::MultisampleStencilResolveFilter MTL::RenderPassStencilAttachmentDescriptor::stencilResolveFilter() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilResolveFilter)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::RenderPassColorAttachmentDescriptorArray::setObject(const MTL::RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfFragmentSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfFragmentSampleIndex)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfVertexSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfVertexSampleIndex)); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::RenderPassSampleBufferAttachmentDescriptor::sampleBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBuffer)); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfFragmentSampleIndex_), endOfFragmentSampleIndex); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfVertexSampleIndex_), endOfVertexSampleIndex); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfFragmentSampleIndex_), startOfFragmentSampleIndex); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfVertexSampleIndex_), startOfVertexSampleIndex); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfFragmentSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfFragmentSampleIndex)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfVertexSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfVertexSampleIndex)); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor)); +} + +_MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::defaultRasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(defaultRasterSampleCount)); +} + +_MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDescriptor::depthAttachment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthAttachment)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(getSamplePositions_count_), positions, count); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::imageblockSampleLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(imageblockSampleLength)); +} + +_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RasterizationRateMap* MTL::RenderPassDescriptor::rasterizationRateMap() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterizationRateMap)); +} + +_MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::renderPassDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor), _MTL_PRIVATE_SEL(renderPassDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetArrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetArrayLength)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetHeight)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(renderTargetWidth)); +} + +_MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassDescriptor::sampleBufferAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBufferAttachments)); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDefaultRasterSampleCount_), defaultRasterSampleCount); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthAttachment_), depthAttachment); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setImageblockSampleLength(NS::UInteger imageblockSampleLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setImageblockSampleLength_), imageblockSampleLength); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationRateMap_), rasterizationRateMap); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetArrayLength_), renderTargetArrayLength); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetHeight(NS::UInteger renderTargetHeight) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetHeight_), renderTargetHeight); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetWidth(NS::UInteger renderTargetWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRenderTargetWidth_), renderTargetWidth); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSamplePositions_count_), positions, count); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilAttachment_), stencilAttachment); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setSupportColorAttachmentMapping(bool supportColorAttachmentMapping) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportColorAttachmentMapping_), supportColorAttachmentMapping); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_), threadgroupMemoryLength); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setTileHeight(NS::UInteger tileHeight) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileHeight_), tileHeight); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setTileWidth(NS::UInteger tileWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileWidth_), tileWidth); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultBuffer_), visibilityResultBuffer); +} + +_MTL_INLINE void MTL::RenderPassDescriptor::setVisibilityResultType(MTL::VisibilityResultType visibilityResultType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVisibilityResultType_), visibilityResultType); +} + +_MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassDescriptor::stencilAttachment() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilAttachment)); +} + +_MTL_INLINE bool MTL::RenderPassDescriptor::supportColorAttachmentMapping() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportColorAttachmentMapping)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::threadgroupMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupMemoryLength)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileHeight() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileHeight)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileWidth)); +} + +_MTL_INLINE MTL::Buffer* MTL::RenderPassDescriptor::visibilityResultBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(visibilityResultBuffer)); +} + +_MTL_INLINE MTL::VisibilityResultType MTL::RenderPassDescriptor::visibilityResultType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(visibilityResultType)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLRenderPipeline.hpp b/thirdparty/metal-cpp/Metal/MTLRenderPipeline.hpp new file mode 100644 index 0000000000..aaa9cdad67 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLRenderPipeline.hpp @@ -0,0 +1,1876 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLRenderPipeline.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAllocation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPipeline.hpp" +#include "MTLPixelFormat.hpp" +#include "MTLPrivate.hpp" +#include "MTLRenderCommandEncoder.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Device; +class Function; +class FunctionHandle; +class IntersectionFunctionTable; +class IntersectionFunctionTableDescriptor; +class LinkedFunctions; +class LogicalToPhysicalColorAttachmentMap; +class MeshRenderPipelineDescriptor; +class PipelineBufferDescriptorArray; +class RenderPipelineColorAttachmentDescriptor; +class RenderPipelineColorAttachmentDescriptorArray; +class RenderPipelineDescriptor; +class RenderPipelineFunctionsDescriptor; +class RenderPipelineReflection; +class RenderPipelineState; +class TileRenderPipelineColorAttachmentDescriptor; +class TileRenderPipelineColorAttachmentDescriptorArray; +class TileRenderPipelineDescriptor; +class VertexDescriptor; +class VisibleFunctionTable; +class VisibleFunctionTableDescriptor; + +} +namespace MTL4 +{ +class BinaryFunction; +class PipelineDescriptor; +class RenderPipelineBinaryFunctionsDescriptor; + +} +namespace MTL +{ +_MTL_ENUM(NS::UInteger, BlendFactor) { + BlendFactorZero = 0, + BlendFactorOne = 1, + BlendFactorSourceColor = 2, + BlendFactorOneMinusSourceColor = 3, + BlendFactorSourceAlpha = 4, + BlendFactorOneMinusSourceAlpha = 5, + BlendFactorDestinationColor = 6, + BlendFactorOneMinusDestinationColor = 7, + BlendFactorDestinationAlpha = 8, + BlendFactorOneMinusDestinationAlpha = 9, + BlendFactorSourceAlphaSaturated = 10, + BlendFactorBlendColor = 11, + BlendFactorOneMinusBlendColor = 12, + BlendFactorBlendAlpha = 13, + BlendFactorOneMinusBlendAlpha = 14, + BlendFactorSource1Color = 15, + BlendFactorOneMinusSource1Color = 16, + BlendFactorSource1Alpha = 17, + BlendFactorOneMinusSource1Alpha = 18, + BlendFactorUnspecialized = 19, +}; + +_MTL_ENUM(NS::UInteger, BlendOperation) { + BlendOperationAdd = 0, + BlendOperationSubtract = 1, + BlendOperationReverseSubtract = 2, + BlendOperationMin = 3, + BlendOperationMax = 4, + BlendOperationUnspecialized = 5, +}; + +_MTL_ENUM(NS::UInteger, PrimitiveTopologyClass) { + PrimitiveTopologyClassUnspecified = 0, + PrimitiveTopologyClassPoint = 1, + PrimitiveTopologyClassLine = 2, + PrimitiveTopologyClassTriangle = 3, +}; + +_MTL_ENUM(NS::UInteger, TessellationPartitionMode) { + TessellationPartitionModePow2 = 0, + TessellationPartitionModeInteger = 1, + TessellationPartitionModeFractionalOdd = 2, + TessellationPartitionModeFractionalEven = 3, +}; + +_MTL_ENUM(NS::UInteger, TessellationFactorStepFunction) { + TessellationFactorStepFunctionConstant = 0, + TessellationFactorStepFunctionPerPatch = 1, + TessellationFactorStepFunctionPerInstance = 2, + TessellationFactorStepFunctionPerPatchAndPerInstance = 3, +}; + +_MTL_ENUM(NS::UInteger, TessellationFactorFormat) { + TessellationFactorFormatHalf = 0, +}; + +_MTL_ENUM(NS::UInteger, TessellationControlPointIndexType) { + TessellationControlPointIndexTypeNone = 0, + TessellationControlPointIndexTypeUInt16 = 1, + TessellationControlPointIndexTypeUInt32 = 2, +}; + +_MTL_OPTIONS(NS::UInteger, ColorWriteMask) { + ColorWriteMaskNone = 0, + ColorWriteMaskRed = 1 << 3, + ColorWriteMaskGreen = 1 << 2, + ColorWriteMaskBlue = 1 << 1, + ColorWriteMaskAlpha = 1, + ColorWriteMaskAll = 15, + ColorWriteMaskUnspecialized = 1 << 4, +}; + +class RenderPipelineColorAttachmentDescriptor : public NS::Copying +{ +public: + static RenderPipelineColorAttachmentDescriptor* alloc(); + + BlendOperation alphaBlendOperation() const; + + [[deprecated("please use isBlendingEnabled instead")]] + bool blendingEnabled() const; + + BlendFactor destinationAlphaBlendFactor() const; + + BlendFactor destinationRGBBlendFactor() const; + + RenderPipelineColorAttachmentDescriptor* init(); + + bool isBlendingEnabled() const; + + PixelFormat pixelFormat() const; + + BlendOperation rgbBlendOperation() const; + + void setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation); + + void setBlendingEnabled(bool blendingEnabled); + + void setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor); + + void setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor); + + void setPixelFormat(MTL::PixelFormat pixelFormat); + + void setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation); + + void setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor); + + void setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor); + + void setWriteMask(MTL::ColorWriteMask writeMask); + + BlendFactor sourceAlphaBlendFactor() const; + + BlendFactor sourceRGBBlendFactor() const; + + ColorWriteMask writeMask() const; +}; +class LogicalToPhysicalColorAttachmentMap : public NS::Copying +{ +public: + static LogicalToPhysicalColorAttachmentMap* alloc(); + + NS::UInteger getPhysicalIndex(NS::UInteger logicalIndex); + + LogicalToPhysicalColorAttachmentMap* init(); + + void reset(); + + void setPhysicalIndex(NS::UInteger physicalIndex, NS::UInteger logicalIndex); +}; +class RenderPipelineReflection : public NS::Referencing +{ +public: + static RenderPipelineReflection* alloc(); + + NS::Array* fragmentArguments() const; + + NS::Array* fragmentBindings() const; + + RenderPipelineReflection* init(); + + NS::Array* meshBindings() const; + + NS::Array* objectBindings() const; + + NS::Array* tileArguments() const; + + NS::Array* tileBindings() const; + + NS::Array* vertexArguments() const; + + NS::Array* vertexBindings() const; +}; +class RenderPipelineDescriptor : public NS::Copying +{ +public: + static RenderPipelineDescriptor* alloc(); + + [[deprecated("please use isAlphaToCoverageEnabled instead")]] + bool alphaToCoverageEnabled() const; + + [[deprecated("please use isAlphaToOneEnabled instead")]] + bool alphaToOneEnabled() const; + + NS::Array* binaryArchives() const; + + RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + PixelFormat depthAttachmentPixelFormat() const; + + PipelineBufferDescriptorArray* fragmentBuffers() const; + + Function* fragmentFunction() const; + + LinkedFunctions* fragmentLinkedFunctions() const; + + NS::Array* fragmentPreloadedLibraries() const; + + RenderPipelineDescriptor* init(); + + PrimitiveTopologyClass inputPrimitiveTopology() const; + + bool isAlphaToCoverageEnabled() const; + + bool isAlphaToOneEnabled() const; + + bool isRasterizationEnabled() const; + + bool isTessellationFactorScaleEnabled() const; + + NS::String* label() const; + + NS::UInteger maxFragmentCallStackDepth() const; + + NS::UInteger maxTessellationFactor() const; + + NS::UInteger maxVertexAmplificationCount() const; + + NS::UInteger maxVertexCallStackDepth() const; + + NS::UInteger rasterSampleCount() const; + + [[deprecated("please use isRasterizationEnabled instead")]] + bool rasterizationEnabled() const; + + void reset(); + + NS::UInteger sampleCount() const; + + void setAlphaToCoverageEnabled(bool alphaToCoverageEnabled); + + void setAlphaToOneEnabled(bool alphaToOneEnabled); + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat); + + void setFragmentFunction(const MTL::Function* fragmentFunction); + + void setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions); + + void setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries); + + void setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology); + + void setLabel(const NS::String* label); + + void setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth); + + void setMaxTessellationFactor(NS::UInteger maxTessellationFactor); + + void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount); + + void setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRasterizationEnabled(bool rasterizationEnabled); + + void setSampleCount(NS::UInteger sampleCount); + + void setShaderValidation(MTL::ShaderValidation shaderValidation); + + void setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat); + + void setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions); + + void setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions); + + void setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers); + + void setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType); + + void setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat); + + void setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled); + + void setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction); + + void setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder); + + void setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode); + + void setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor); + + void setVertexFunction(const MTL::Function* vertexFunction); + + void setVertexLinkedFunctions(const MTL::LinkedFunctions* vertexLinkedFunctions); + + void setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries); + + ShaderValidation shaderValidation() const; + + PixelFormat stencilAttachmentPixelFormat() const; + + bool supportAddingFragmentBinaryFunctions() const; + + bool supportAddingVertexBinaryFunctions() const; + + bool supportIndirectCommandBuffers() const; + + TessellationControlPointIndexType tessellationControlPointIndexType() const; + + TessellationFactorFormat tessellationFactorFormat() const; + + [[deprecated("please use isTessellationFactorScaleEnabled instead")]] + bool tessellationFactorScaleEnabled() const; + + TessellationFactorStepFunction tessellationFactorStepFunction() const; + + Winding tessellationOutputWindingOrder() const; + + TessellationPartitionMode tessellationPartitionMode() const; + + PipelineBufferDescriptorArray* vertexBuffers() const; + + VertexDescriptor* vertexDescriptor() const; + + Function* vertexFunction() const; + + LinkedFunctions* vertexLinkedFunctions() const; + + NS::Array* vertexPreloadedLibraries() const; +}; +class RenderPipelineFunctionsDescriptor : public NS::Copying +{ +public: + static RenderPipelineFunctionsDescriptor* alloc(); + + NS::Array* fragmentAdditionalBinaryFunctions() const; + + RenderPipelineFunctionsDescriptor* init(); + + void setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions); + + void setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions); + + void setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions); + + NS::Array* tileAdditionalBinaryFunctions() const; + + NS::Array* vertexAdditionalBinaryFunctions() const; +}; +class RenderPipelineState : public NS::Referencing +{ +public: + Device* device() const; + + FunctionHandle* functionHandle(const NS::String* name, MTL::RenderStages stage); + FunctionHandle* functionHandle(const MTL4::BinaryFunction* function, MTL::RenderStages stage); + FunctionHandle* functionHandle(const MTL::Function* function, MTL::RenderStages stage); + + ResourceID gpuResourceID() const; + + NS::UInteger imageblockMemoryLength(MTL::Size imageblockDimensions); + + NS::UInteger imageblockSampleLength() const; + + NS::String* label() const; + + NS::UInteger maxTotalThreadgroupsPerMeshGrid() const; + + NS::UInteger maxTotalThreadsPerMeshThreadgroup() const; + + NS::UInteger maxTotalThreadsPerObjectThreadgroup() const; + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + NS::UInteger meshThreadExecutionWidth() const; + + IntersectionFunctionTable* newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage); + + MTL4::PipelineDescriptor* newRenderPipelineDescriptor(); + + RenderPipelineState* newRenderPipelineState(const MTL4::RenderPipelineBinaryFunctionsDescriptor* binaryFunctionsDescriptor, NS::Error** error); + RenderPipelineState* newRenderPipelineState(const MTL::RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error); + + VisibleFunctionTable* newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage); + + NS::UInteger objectThreadExecutionWidth() const; + + RenderPipelineReflection* reflection() const; + + Size requiredThreadsPerMeshThreadgroup() const; + + Size requiredThreadsPerObjectThreadgroup() const; + + Size requiredThreadsPerTileThreadgroup() const; + + ShaderValidation shaderValidation() const; + + bool supportIndirectCommandBuffers() const; + + bool threadgroupSizeMatchesTileSize() const; +}; +class RenderPipelineColorAttachmentDescriptorArray : public NS::Referencing +{ +public: + static RenderPipelineColorAttachmentDescriptorArray* alloc(); + + RenderPipelineColorAttachmentDescriptorArray* init(); + + RenderPipelineColorAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class TileRenderPipelineColorAttachmentDescriptor : public NS::Copying +{ +public: + static TileRenderPipelineColorAttachmentDescriptor* alloc(); + + TileRenderPipelineColorAttachmentDescriptor* init(); + + PixelFormat pixelFormat() const; + void setPixelFormat(MTL::PixelFormat pixelFormat); +}; +class TileRenderPipelineColorAttachmentDescriptorArray : public NS::Referencing +{ +public: + static TileRenderPipelineColorAttachmentDescriptorArray* alloc(); + + TileRenderPipelineColorAttachmentDescriptorArray* init(); + + TileRenderPipelineColorAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class TileRenderPipelineDescriptor : public NS::Copying +{ +public: + static TileRenderPipelineDescriptor* alloc(); + + NS::Array* binaryArchives() const; + + TileRenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + TileRenderPipelineDescriptor* init(); + + NS::String* label() const; + + LinkedFunctions* linkedFunctions() const; + + NS::UInteger maxCallStackDepth() const; + + NS::UInteger maxTotalThreadsPerThreadgroup() const; + + NS::Array* preloadedLibraries() const; + + NS::UInteger rasterSampleCount() const; + + Size requiredThreadsPerThreadgroup() const; + + void reset(); + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setLabel(const NS::String* label); + + void setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions); + + void setMaxCallStackDepth(NS::UInteger maxCallStackDepth); + + void setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup); + + void setPreloadedLibraries(const NS::Array* preloadedLibraries); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup); + + void setShaderValidation(MTL::ShaderValidation shaderValidation); + + void setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions); + + void setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize); + + void setTileFunction(const MTL::Function* tileFunction); + + ShaderValidation shaderValidation() const; + + bool supportAddingBinaryFunctions() const; + + bool threadgroupSizeMatchesTileSize() const; + + PipelineBufferDescriptorArray* tileBuffers() const; + + Function* tileFunction() const; +}; +class MeshRenderPipelineDescriptor : public NS::Copying +{ +public: + static MeshRenderPipelineDescriptor* alloc(); + + [[deprecated("please use isAlphaToCoverageEnabled instead")]] + bool alphaToCoverageEnabled() const; + + [[deprecated("please use isAlphaToOneEnabled instead")]] + bool alphaToOneEnabled() const; + + NS::Array* binaryArchives() const; + + RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const; + + PixelFormat depthAttachmentPixelFormat() const; + + PipelineBufferDescriptorArray* fragmentBuffers() const; + + Function* fragmentFunction() const; + + LinkedFunctions* fragmentLinkedFunctions() const; + + MeshRenderPipelineDescriptor* init(); + + bool isAlphaToCoverageEnabled() const; + + bool isAlphaToOneEnabled() const; + + bool isRasterizationEnabled() const; + + NS::String* label() const; + + NS::UInteger maxTotalThreadgroupsPerMeshGrid() const; + + NS::UInteger maxTotalThreadsPerMeshThreadgroup() const; + + NS::UInteger maxTotalThreadsPerObjectThreadgroup() const; + + NS::UInteger maxVertexAmplificationCount() const; + + PipelineBufferDescriptorArray* meshBuffers() const; + + Function* meshFunction() const; + + LinkedFunctions* meshLinkedFunctions() const; + + bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const; + + PipelineBufferDescriptorArray* objectBuffers() const; + + Function* objectFunction() const; + + LinkedFunctions* objectLinkedFunctions() const; + + bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const; + + NS::UInteger payloadMemoryLength() const; + + NS::UInteger rasterSampleCount() const; + + [[deprecated("please use isRasterizationEnabled instead")]] + bool rasterizationEnabled() const; + + Size requiredThreadsPerMeshThreadgroup() const; + + Size requiredThreadsPerObjectThreadgroup() const; + + void reset(); + + void setAlphaToCoverageEnabled(bool alphaToCoverageEnabled); + + void setAlphaToOneEnabled(bool alphaToOneEnabled); + + void setBinaryArchives(const NS::Array* binaryArchives); + + void setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat); + + void setFragmentFunction(const MTL::Function* fragmentFunction); + + void setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions); + + void setLabel(const NS::String* label); + + void setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid); + + void setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup); + + void setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup); + + void setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount); + + void setMeshFunction(const MTL::Function* meshFunction); + + void setMeshLinkedFunctions(const MTL::LinkedFunctions* meshLinkedFunctions); + + void setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth); + + void setObjectFunction(const MTL::Function* objectFunction); + + void setObjectLinkedFunctions(const MTL::LinkedFunctions* objectLinkedFunctions); + + void setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth); + + void setPayloadMemoryLength(NS::UInteger payloadMemoryLength); + + void setRasterSampleCount(NS::UInteger rasterSampleCount); + + void setRasterizationEnabled(bool rasterizationEnabled); + + void setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup); + + void setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup); + + void setShaderValidation(MTL::ShaderValidation shaderValidation); + + void setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat); + + void setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers); + + ShaderValidation shaderValidation() const; + + PixelFormat stencilAttachmentPixelFormat() const; + + bool supportIndirectCommandBuffers() const; +}; + +} +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptor)); +} + +_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::alphaBlendOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(alphaBlendOperation)); +} + +_MTL_INLINE bool MTL::RenderPipelineColorAttachmentDescriptor::blendingEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isBlendingEnabled)); +} + +_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationAlphaBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(destinationAlphaBlendFactor)); +} + +_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationRGBBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(destinationRGBBlendFactor)); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::RenderPipelineColorAttachmentDescriptor::isBlendingEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isBlendingEnabled)); +} + +_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineColorAttachmentDescriptor::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::rgbBlendOperation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rgbBlendOperation)); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaBlendOperation_), alphaBlendOperation); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setBlendingEnabled(bool blendingEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBlendingEnabled_), blendingEnabled); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDestinationAlphaBlendFactor_), destinationAlphaBlendFactor); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDestinationRGBBlendFactor_), destinationRGBBlendFactor); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRgbBlendOperation_), rgbBlendOperation); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSourceAlphaBlendFactor_), sourceAlphaBlendFactor); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSourceRGBBlendFactor_), sourceRGBBlendFactor); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setWriteMask(MTL::ColorWriteMask writeMask) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask); +} + +_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceAlphaBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sourceAlphaBlendFactor)); +} + +_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceRGBBlendFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sourceRGBBlendFactor)); +} + +_MTL_INLINE MTL::ColorWriteMask MTL::RenderPipelineColorAttachmentDescriptor::writeMask() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(writeMask)); +} + +_MTL_INLINE MTL::LogicalToPhysicalColorAttachmentMap* MTL::LogicalToPhysicalColorAttachmentMap::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLLogicalToPhysicalColorAttachmentMap)); +} + +_MTL_INLINE NS::UInteger MTL::LogicalToPhysicalColorAttachmentMap::getPhysicalIndex(NS::UInteger logicalIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(getPhysicalIndexForLogicalIndex_), logicalIndex); +} + +_MTL_INLINE MTL::LogicalToPhysicalColorAttachmentMap* MTL::LogicalToPhysicalColorAttachmentMap::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::LogicalToPhysicalColorAttachmentMap::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::LogicalToPhysicalColorAttachmentMap::setPhysicalIndex(NS::UInteger physicalIndex, NS::UInteger logicalIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPhysicalIndex_forLogicalIndex_), physicalIndex, logicalIndex); +} + +_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPipelineReflection)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::fragmentArguments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentArguments)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::fragmentBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentBindings)); +} + +_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::meshBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshBindings)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::objectBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectBindings)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::tileArguments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileArguments)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::tileBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileBindings)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::vertexArguments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexArguments)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::vertexBindings() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBindings)); +} + +_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPipelineDescriptor)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToCoverageEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToOneEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::depthAttachmentPixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthAttachmentPixelFormat)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::fragmentBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentBuffers)); +} + +_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::fragmentFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentFunction)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::fragmentLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentLinkedFunctions)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::fragmentPreloadedLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentPreloadedLibraries)); +} + +_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::PrimitiveTopologyClass MTL::RenderPipelineDescriptor::inputPrimitiveTopology() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(inputPrimitiveTopology)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::isAlphaToCoverageEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::isAlphaToOneEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::isRasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::isTessellationFactorScaleEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isTessellationFactorScaleEnabled)); +} + +_MTL_INLINE NS::String* MTL::RenderPipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxFragmentCallStackDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxFragmentCallStackDepth)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxTessellationFactor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTessellationFactor)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexAmplificationCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexCallStackDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexCallStackDepth)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::rasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToCoverageEnabled(bool alphaToCoverageEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToCoverageEnabled_), alphaToCoverageEnabled); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToOneEnabled(bool alphaToOneEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToOneEnabled_), alphaToOneEnabled); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthAttachmentPixelFormat_), depthAttachmentPixelFormat); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentFunction(const MTL::Function* fragmentFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentFunction_), fragmentFunction); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentLinkedFunctions_), fragmentLinkedFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentPreloadedLibraries_), fragmentPreloadedLibraries); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInputPrimitiveTopology_), inputPrimitiveTopology); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxFragmentCallStackDepth_), maxFragmentCallStackDepth); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxTessellationFactor(NS::UInteger maxTessellationFactor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTessellationFactor_), maxTessellationFactor); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexCallStackDepth_), maxVertexCallStackDepth); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setSampleCount(NS::UInteger sampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setShaderValidation(MTL::ShaderValidation shaderValidation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilAttachmentPixelFormat_), stencilAttachmentPixelFormat); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportAddingFragmentBinaryFunctions_), supportAddingFragmentBinaryFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportAddingVertexBinaryFunctions_), supportAddingVertexBinaryFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationControlPointIndexType_), tessellationControlPointIndexType); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationFactorFormat_), tessellationFactorFormat); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationFactorScaleEnabled_), tessellationFactorScaleEnabled); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationFactorStepFunction_), tessellationFactorStepFunction); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationOutputWindingOrder_), tessellationOutputWindingOrder); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTessellationPartitionMode_), tessellationPartitionMode); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexDescriptor_), vertexDescriptor); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexFunction(const MTL::Function* vertexFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexFunction_), vertexFunction); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexLinkedFunctions(const MTL::LinkedFunctions* vertexLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexLinkedFunctions_), vertexLinkedFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexPreloadedLibraries_), vertexPreloadedLibraries); +} + +_MTL_INLINE MTL::ShaderValidation MTL::RenderPipelineDescriptor::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::stencilAttachmentPixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilAttachmentPixelFormat)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingFragmentBinaryFunctions() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportAddingFragmentBinaryFunctions)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingVertexBinaryFunctions() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportAddingVertexBinaryFunctions)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE MTL::TessellationControlPointIndexType MTL::RenderPipelineDescriptor::tessellationControlPointIndexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tessellationControlPointIndexType)); +} + +_MTL_INLINE MTL::TessellationFactorFormat MTL::RenderPipelineDescriptor::tessellationFactorFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tessellationFactorFormat)); +} + +_MTL_INLINE bool MTL::RenderPipelineDescriptor::tessellationFactorScaleEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isTessellationFactorScaleEnabled)); +} + +_MTL_INLINE MTL::TessellationFactorStepFunction MTL::RenderPipelineDescriptor::tessellationFactorStepFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tessellationFactorStepFunction)); +} + +_MTL_INLINE MTL::Winding MTL::RenderPipelineDescriptor::tessellationOutputWindingOrder() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tessellationOutputWindingOrder)); +} + +_MTL_INLINE MTL::TessellationPartitionMode MTL::RenderPipelineDescriptor::tessellationPartitionMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tessellationPartitionMode)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::vertexBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexBuffers)); +} + +_MTL_INLINE MTL::VertexDescriptor* MTL::RenderPipelineDescriptor::vertexDescriptor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexDescriptor)); +} + +_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::vertexFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexFunction)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::vertexLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexLinkedFunctions)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::vertexPreloadedLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexPreloadedLibraries)); +} + +_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPipelineFunctionsDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::fragmentAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentAdditionalBinaryFunctions)); +} + +_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentAdditionalBinaryFunctions_), fragmentAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileAdditionalBinaryFunctions_), tileAdditionalBinaryFunctions); +} + +_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setVertexAdditionalBinaryFunctions_), vertexAdditionalBinaryFunctions); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::tileAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileAdditionalBinaryFunctions)); +} + +_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::vertexAdditionalBinaryFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(vertexAdditionalBinaryFunctions)); +} + +_MTL_INLINE MTL::Device* MTL::RenderPipelineState::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::RenderPipelineState::functionHandle(const NS::String* name, MTL::RenderStages stage) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithName_stage_), name, stage); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::RenderPipelineState::functionHandle(const MTL4::BinaryFunction* function, MTL::RenderStages stage) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithBinaryFunction_stage_), function, stage); +} + +_MTL_INLINE MTL::FunctionHandle* MTL::RenderPipelineState::functionHandle(const MTL::Function* function, MTL::RenderStages stage) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_stage_), function, stage); +} + +_MTL_INLINE MTL::ResourceID MTL::RenderPipelineState::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockSampleLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(imageblockSampleLength)); +} + +_MTL_INLINE NS::String* MTL::RenderPipelineState::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadgroupsPerMeshGrid() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::meshThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshThreadExecutionWidth)); +} + +_MTL_INLINE MTL::IntersectionFunctionTable* MTL::RenderPipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_stage_), descriptor, stage); +} + +_MTL_INLINE MTL4::PipelineDescriptor* MTL::RenderPipelineState::newRenderPipelineDescriptor() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineDescriptorForSpecialization)); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::RenderPipelineState::newRenderPipelineState(const MTL4::RenderPipelineBinaryFunctionsDescriptor* binaryFunctionsDescriptor, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithBinaryFunctions_error_), binaryFunctionsDescriptor, error); +} + +_MTL_INLINE MTL::RenderPipelineState* MTL::RenderPipelineState::newRenderPipelineState(const MTL::RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_), additionalBinaryFunctions, error); +} + +_MTL_INLINE MTL::VisibleFunctionTable* MTL::RenderPipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_stage_), descriptor, stage); +} + +_MTL_INLINE NS::UInteger MTL::RenderPipelineState::objectThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectThreadExecutionWidth)); +} + +_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineState::reflection() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(reflection)); +} + +_MTL_INLINE MTL::Size MTL::RenderPipelineState::requiredThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE MTL::Size MTL::RenderPipelineState::requiredThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE MTL::Size MTL::RenderPipelineState::requiredThreadsPerTileThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerTileThreadgroup)); +} + +_MTL_INLINE MTL::ShaderValidation MTL::RenderPipelineState::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE bool MTL::RenderPipelineState::supportIndirectCommandBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} + +_MTL_INLINE bool MTL::RenderPipelineState::threadgroupSizeMatchesTileSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize)); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptor)); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::PixelFormat MTL::TileRenderPipelineColorAttachmentDescriptor::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTileRenderPipelineDescriptor)); +} + +_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::TileRenderPipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::TileRenderPipelineDescriptor::linkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(linkedFunctions)); +} + +_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxCallStackDepth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxCallStackDepth)); +} + +_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxTotalThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup)); +} + +_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::preloadedLibraries() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(preloadedLibraries)); +} + +_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE MTL::Size MTL::TileRenderPipelineDescriptor::requiredThreadsPerThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerThreadgroup)); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setRequiredThreadsPerThreadgroup(MTL::Size requiredThreadsPerThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerThreadgroup_), requiredThreadsPerThreadgroup); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setShaderValidation(MTL::ShaderValidation shaderValidation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setThreadgroupSizeMatchesTileSize_), threadgroupSizeMatchesTileSize); +} + +_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setTileFunction(const MTL::Function* tileFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTileFunction_), tileFunction); +} + +_MTL_INLINE MTL::ShaderValidation MTL::TileRenderPipelineDescriptor::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::supportAddingBinaryFunctions() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions)); +} + +_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::threadgroupSizeMatchesTileSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::TileRenderPipelineDescriptor::tileBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileBuffers)); +} + +_MTL_INLINE MTL::Function* MTL::TileRenderPipelineDescriptor::tileFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tileFunction)); +} + +_MTL_INLINE MTL::MeshRenderPipelineDescriptor* MTL::MeshRenderPipelineDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLMeshRenderPipelineDescriptor)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::alphaToCoverageEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::alphaToOneEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled)); +} + +_MTL_INLINE NS::Array* MTL::MeshRenderPipelineDescriptor::binaryArchives() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(binaryArchives)); +} + +_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::MeshRenderPipelineDescriptor::colorAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(colorAttachments)); +} + +_MTL_INLINE MTL::PixelFormat MTL::MeshRenderPipelineDescriptor::depthAttachmentPixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depthAttachmentPixelFormat)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::fragmentBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentBuffers)); +} + +_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::fragmentFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentFunction)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::fragmentLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(fragmentLinkedFunctions)); +} + +_MTL_INLINE MTL::MeshRenderPipelineDescriptor* MTL::MeshRenderPipelineDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::isAlphaToCoverageEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::isAlphaToOneEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::isRasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE NS::String* MTL::MeshRenderPipelineDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadgroupsPerMeshGrid() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadgroupsPerMeshGrid)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxTotalThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::maxVertexAmplificationCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::meshBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshBuffers)); +} + +_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::meshFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshFunction)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::meshLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshLinkedFunctions)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::meshThreadgroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(meshThreadgroupSizeIsMultipleOfThreadExecutionWidth)); +} + +_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::MeshRenderPipelineDescriptor::objectBuffers() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectBuffers)); +} + +_MTL_INLINE MTL::Function* MTL::MeshRenderPipelineDescriptor::objectFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectFunction)); +} + +_MTL_INLINE MTL::LinkedFunctions* MTL::MeshRenderPipelineDescriptor::objectLinkedFunctions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectLinkedFunctions)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::objectThreadgroupSizeIsMultipleOfThreadExecutionWidth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectThreadgroupSizeIsMultipleOfThreadExecutionWidth)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::payloadMemoryLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(payloadMemoryLength)); +} + +_MTL_INLINE NS::UInteger MTL::MeshRenderPipelineDescriptor::rasterSampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rasterSampleCount)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::rasterizationEnabled() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isRasterizationEnabled)); +} + +_MTL_INLINE MTL::Size MTL::MeshRenderPipelineDescriptor::requiredThreadsPerMeshThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerMeshThreadgroup)); +} + +_MTL_INLINE MTL::Size MTL::MeshRenderPipelineDescriptor::requiredThreadsPerObjectThreadgroup() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(requiredThreadsPerObjectThreadgroup)); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setAlphaToCoverageEnabled(bool alphaToCoverageEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToCoverageEnabled_), alphaToCoverageEnabled); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setAlphaToOneEnabled(bool alphaToOneEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAlphaToOneEnabled_), alphaToOneEnabled); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepthAttachmentPixelFormat_), depthAttachmentPixelFormat); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setFragmentFunction(const MTL::Function* fragmentFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentFunction_), fragmentFunction); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFragmentLinkedFunctions_), fragmentLinkedFunctions); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadgroupsPerMeshGrid(NS::UInteger maxTotalThreadgroupsPerMeshGrid) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadgroupsPerMeshGrid_), maxTotalThreadgroupsPerMeshGrid); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerMeshThreadgroup(NS::UInteger maxTotalThreadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerMeshThreadgroup_), maxTotalThreadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxTotalThreadsPerObjectThreadgroup(NS::UInteger maxTotalThreadsPerObjectThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerObjectThreadgroup_), maxTotalThreadsPerObjectThreadgroup); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshFunction(const MTL::Function* meshFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshFunction_), meshFunction); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshLinkedFunctions(const MTL::LinkedFunctions* meshLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshLinkedFunctions_), meshLinkedFunctions); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool meshThreadgroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMeshThreadgroupSizeIsMultipleOfThreadExecutionWidth_), meshThreadgroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectFunction(const MTL::Function* objectFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectFunction_), objectFunction); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectLinkedFunctions(const MTL::LinkedFunctions* objectLinkedFunctions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectLinkedFunctions_), objectLinkedFunctions); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth(bool objectThreadgroupSizeIsMultipleOfThreadExecutionWidth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObjectThreadgroupSizeIsMultipleOfThreadExecutionWidth_), objectThreadgroupSizeIsMultipleOfThreadExecutionWidth); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setPayloadMemoryLength(NS::UInteger payloadMemoryLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPayloadMemoryLength_), payloadMemoryLength); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRequiredThreadsPerMeshThreadgroup(MTL::Size requiredThreadsPerMeshThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerMeshThreadgroup_), requiredThreadsPerMeshThreadgroup); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setRequiredThreadsPerObjectThreadgroup(MTL::Size requiredThreadsPerObjectThreadgroup) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRequiredThreadsPerObjectThreadgroup_), requiredThreadsPerObjectThreadgroup); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setShaderValidation(MTL::ShaderValidation shaderValidation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setShaderValidation_), shaderValidation); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStencilAttachmentPixelFormat_), stencilAttachmentPixelFormat); +} + +_MTL_INLINE void MTL::MeshRenderPipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers); +} + +_MTL_INLINE MTL::ShaderValidation MTL::MeshRenderPipelineDescriptor::shaderValidation() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(shaderValidation)); +} + +_MTL_INLINE MTL::PixelFormat MTL::MeshRenderPipelineDescriptor::stencilAttachmentPixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stencilAttachmentPixelFormat)); +} + +_MTL_INLINE bool MTL::MeshRenderPipelineDescriptor::supportIndirectCommandBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLResidencySet.hpp b/thirdparty/metal-cpp/Metal/MTLResidencySet.hpp new file mode 100644 index 0000000000..d073972d99 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLResidencySet.hpp @@ -0,0 +1,178 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResidencySet.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +namespace MTL +{ +class Allocation; +class Device; +class ResidencySetDescriptor; + +class ResidencySetDescriptor : public NS::Copying +{ +public: + static ResidencySetDescriptor* alloc(); + + ResidencySetDescriptor* init(); + NS::UInteger initialCapacity() const; + + NS::String* label() const; + + void setInitialCapacity(NS::UInteger initialCapacity); + + void setLabel(const NS::String* label); +}; +class ResidencySet : public NS::Referencing +{ +public: + void addAllocation(const MTL::Allocation* allocation); + void addAllocations(const MTL::Allocation* const allocations[], NS::UInteger count); + + NS::Array* allAllocations() const; + + uint64_t allocatedSize() const; + + NS::UInteger allocationCount() const; + + void commit(); + + bool containsAllocation(const MTL::Allocation* anAllocation); + + Device* device() const; + + void endResidency(); + + NS::String* label() const; + + void removeAllAllocations(); + + void removeAllocation(const MTL::Allocation* allocation); + void removeAllocations(const MTL::Allocation* const allocations[], NS::UInteger count); + + void requestResidency(); +}; + +} +_MTL_INLINE MTL::ResidencySetDescriptor* MTL::ResidencySetDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLResidencySetDescriptor)); +} + +_MTL_INLINE MTL::ResidencySetDescriptor* MTL::ResidencySetDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::ResidencySetDescriptor::initialCapacity() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initialCapacity)); +} + +_MTL_INLINE NS::String* MTL::ResidencySetDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::ResidencySetDescriptor::setInitialCapacity(NS::UInteger initialCapacity) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setInitialCapacity_), initialCapacity); +} + +_MTL_INLINE void MTL::ResidencySetDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::ResidencySet::addAllocation(const MTL::Allocation* allocation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addAllocation_), allocation); +} + +_MTL_INLINE void MTL::ResidencySet::addAllocations(const MTL::Allocation* const allocations[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(addAllocations_count_), allocations, count); +} + +_MTL_INLINE NS::Array* MTL::ResidencySet::allAllocations() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allAllocations)); +} + +_MTL_INLINE uint64_t MTL::ResidencySet::allocatedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allocatedSize)); +} + +_MTL_INLINE NS::UInteger MTL::ResidencySet::allocationCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allocationCount)); +} + +_MTL_INLINE void MTL::ResidencySet::commit() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(commit)); +} + +_MTL_INLINE bool MTL::ResidencySet::containsAllocation(const MTL::Allocation* anAllocation) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(containsAllocation_), anAllocation); +} + +_MTL_INLINE MTL::Device* MTL::ResidencySet::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE void MTL::ResidencySet::endResidency() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(endResidency)); +} + +_MTL_INLINE NS::String* MTL::ResidencySet::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::ResidencySet::removeAllAllocations() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeAllAllocations)); +} + +_MTL_INLINE void MTL::ResidencySet::removeAllocation(const MTL::Allocation* allocation) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeAllocation_), allocation); +} + +_MTL_INLINE void MTL::ResidencySet::removeAllocations(const MTL::Allocation* const allocations[], NS::UInteger count) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(removeAllocations_count_), allocations, count); +} + +_MTL_INLINE void MTL::ResidencySet::requestResidency() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(requestResidency)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLResource.hpp b/thirdparty/metal-cpp/Metal/MTLResource.hpp new file mode 100644 index 0000000000..21e49bb935 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLResource.hpp @@ -0,0 +1,190 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResource.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLAllocation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include + +namespace MTL +{ +class Device; +class Heap; +_MTL_ENUM(NS::UInteger, PurgeableState) { + PurgeableStateKeepCurrent = 1, + PurgeableStateNonVolatile = 2, + PurgeableStateVolatile = 3, + PurgeableStateEmpty = 4, +}; + +_MTL_ENUM(NS::UInteger, CPUCacheMode) { + CPUCacheModeDefaultCache = 0, + CPUCacheModeWriteCombined = 1, +}; + +_MTL_ENUM(NS::UInteger, StorageMode) { + StorageModeShared = 0, + StorageModeManaged = 1, + StorageModePrivate = 2, + StorageModeMemoryless = 3, +}; + +_MTL_ENUM(NS::UInteger, HazardTrackingMode) { + HazardTrackingModeDefault = 0, + HazardTrackingModeUntracked = 1, + HazardTrackingModeTracked = 2, +}; + +_MTL_ENUM(NS::Integer, SparsePageSize) { + SparsePageSize16 = 101, + SparsePageSize64 = 102, + SparsePageSize256 = 103, +}; + +_MTL_ENUM(NS::Integer, BufferSparseTier) { + BufferSparseTierNone = 0, + BufferSparseTier1 = 1, +}; + +_MTL_ENUM(NS::Integer, TextureSparseTier) { + TextureSparseTierNone = 0, + TextureSparseTier1 = 1, + TextureSparseTier2 = 2, +}; + +_MTL_OPTIONS(NS::UInteger, ResourceOptions) { + ResourceCPUCacheModeDefaultCache = 0, + ResourceCPUCacheModeWriteCombined = 1, + ResourceStorageModeShared = 0, + ResourceStorageModeManaged = 1 << 4, + ResourceStorageModePrivate = 1 << 5, + ResourceStorageModeMemoryless = 1 << 5, + ResourceHazardTrackingModeDefault = 0, + ResourceHazardTrackingModeUntracked = 1 << 8, + ResourceHazardTrackingModeTracked = 1 << 9, + ResourceOptionCPUCacheModeDefault = 0, + ResourceOptionCPUCacheModeWriteCombined = 1, +}; + +class Resource : public NS::Referencing +{ +public: + NS::UInteger allocatedSize() const; + + CPUCacheMode cpuCacheMode() const; + + Device* device() const; + + HazardTrackingMode hazardTrackingMode() const; + + Heap* heap() const; + NS::UInteger heapOffset() const; + + bool isAliasable(); + + NS::String* label() const; + + void makeAliasable(); + + ResourceOptions resourceOptions() const; + + void setLabel(const NS::String* label); + + kern_return_t setOwner(task_id_token_t task_id_token); + + PurgeableState setPurgeableState(MTL::PurgeableState state); + + StorageMode storageMode() const; +}; + +} +_MTL_INLINE NS::UInteger MTL::Resource::allocatedSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allocatedSize)); +} + +_MTL_INLINE MTL::CPUCacheMode MTL::Resource::cpuCacheMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(cpuCacheMode)); +} + +_MTL_INLINE MTL::Device* MTL::Resource::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::HazardTrackingMode MTL::Resource::hazardTrackingMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hazardTrackingMode)); +} + +_MTL_INLINE MTL::Heap* MTL::Resource::heap() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heap)); +} + +_MTL_INLINE NS::UInteger MTL::Resource::heapOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(heapOffset)); +} + +_MTL_INLINE bool MTL::Resource::isAliasable() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isAliasable)); +} + +_MTL_INLINE NS::String* MTL::Resource::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE void MTL::Resource::makeAliasable() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(makeAliasable)); +} + +_MTL_INLINE MTL::ResourceOptions MTL::Resource::resourceOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceOptions)); +} + +_MTL_INLINE void MTL::Resource::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE kern_return_t MTL::Resource::setOwner(task_id_token_t task_id_token) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setOwnerWithIdentity_), task_id_token); +} + +_MTL_INLINE MTL::PurgeableState MTL::Resource::setPurgeableState(MTL::PurgeableState state) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setPurgeableState_), state); +} + +_MTL_INLINE MTL::StorageMode MTL::Resource::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLResourceStateCommandEncoder.hpp b/thirdparty/metal-cpp/Metal/MTLResourceStateCommandEncoder.hpp new file mode 100644 index 0000000000..3f565c30fa --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLResourceStateCommandEncoder.hpp @@ -0,0 +1,98 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResourceStateCommandEncoder.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class Buffer; +class Fence; +struct Region; +class Texture; +_MTL_ENUM(NS::UInteger, SparseTextureMappingMode) { + SparseTextureMappingModeMap = 0, + SparseTextureMappingModeUnmap = 1, +}; + +struct MapIndirectArguments +{ + uint32_t regionOriginX; + uint32_t regionOriginY; + uint32_t regionOriginZ; + uint32_t regionSizeWidth; + uint32_t regionSizeHeight; + uint32_t regionSizeDepth; + uint32_t mipMapLevel; + uint32_t sliceId; +} _MTL_PACKED; + +class ResourceStateCommandEncoder : public NS::Referencing +{ +public: + void moveTextureMappingsFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin); + + void updateFence(const MTL::Fence* fence); + + void updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region region, const NS::UInteger mipLevel, const NS::UInteger slice); + void updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset); + void updateTextureMappings(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region* regions, const NS::UInteger* mipLevels, const NS::UInteger* slices, NS::UInteger numRegions); + + void waitForFence(const MTL::Fence* fence); +}; + +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::moveTextureMappingsFromTexture(const MTL::Texture* sourceTexture, NS::UInteger sourceSlice, NS::UInteger sourceLevel, MTL::Origin sourceOrigin, MTL::Size sourceSize, const MTL::Texture* destinationTexture, NS::UInteger destinationSlice, NS::UInteger destinationLevel, MTL::Origin destinationOrigin) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(moveTextureMappingsFromTexture_sourceSlice_sourceLevel_sourceOrigin_sourceSize_toTexture_destinationSlice_destinationLevel_destinationOrigin_), sourceTexture, sourceSlice, sourceLevel, sourceOrigin, sourceSize, destinationTexture, destinationSlice, destinationLevel, destinationOrigin); +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateFence_), fence); +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region region, const NS::UInteger mipLevel, const NS::UInteger slice) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateTextureMapping_mode_region_mipLevel_slice_), texture, mode, region, mipLevel, slice); +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMapping(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateTextureMapping_mode_indirectBuffer_indirectBufferOffset_), texture, mode, indirectBuffer, indirectBufferOffset); +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::updateTextureMappings(const MTL::Texture* texture, const MTL::SparseTextureMappingMode mode, const MTL::Region* regions, const NS::UInteger* mipLevels, const NS::UInteger* slices, NS::UInteger numRegions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(updateTextureMappings_mode_regions_mipLevels_slices_numRegions_), texture, mode, regions, mipLevels, slices, numRegions); +} + +_MTL_INLINE void MTL::ResourceStateCommandEncoder::waitForFence(const MTL::Fence* fence) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(waitForFence_), fence); +} diff --git a/thirdparty/metal-cpp/Metal/MTLResourceStatePass.hpp b/thirdparty/metal-cpp/Metal/MTLResourceStatePass.hpp new file mode 100644 index 0000000000..f3689012eb --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLResourceStatePass.hpp @@ -0,0 +1,154 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResourceStatePass.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class CounterSampleBuffer; +class ResourceStatePassDescriptor; +class ResourceStatePassSampleBufferAttachmentDescriptor; +class ResourceStatePassSampleBufferAttachmentDescriptorArray; + +class ResourceStatePassSampleBufferAttachmentDescriptor : public NS::Copying +{ +public: + static ResourceStatePassSampleBufferAttachmentDescriptor* alloc(); + + NS::UInteger endOfEncoderSampleIndex() const; + + ResourceStatePassSampleBufferAttachmentDescriptor* init(); + + CounterSampleBuffer* sampleBuffer() const; + + void setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex); + + void setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer); + + void setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex); + NS::UInteger startOfEncoderSampleIndex() const; +}; +class ResourceStatePassSampleBufferAttachmentDescriptorArray : public NS::Referencing +{ +public: + static ResourceStatePassSampleBufferAttachmentDescriptorArray* alloc(); + + ResourceStatePassSampleBufferAttachmentDescriptorArray* init(); + + ResourceStatePassSampleBufferAttachmentDescriptor* object(NS::UInteger attachmentIndex); + void setObject(const MTL::ResourceStatePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex); +}; +class ResourceStatePassDescriptor : public NS::Copying +{ +public: + static ResourceStatePassDescriptor* alloc(); + + ResourceStatePassDescriptor* init(); + + static ResourceStatePassDescriptor* resourceStatePassDescriptor(); + + ResourceStatePassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const; +}; + +} +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::ResourceStatePassSampleBufferAttachmentDescriptor::endOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(endOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::CounterSampleBuffer* MTL::ResourceStatePassSampleBufferAttachmentDescriptor::sampleBuffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBuffer)); +} + +_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setEndOfEncoderSampleIndex(NS::UInteger endOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setEndOfEncoderSampleIndex_), endOfEncoderSampleIndex); +} + +_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer); +} + +_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptor::setStartOfEncoderSampleIndex(NS::UInteger startOfEncoderSampleIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStartOfEncoderSampleIndex_), startOfEncoderSampleIndex); +} + +_MTL_INLINE NS::UInteger MTL::ResourceStatePassSampleBufferAttachmentDescriptor::startOfEncoderSampleIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(startOfEncoderSampleIndex)); +} + +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLResourceStatePassSampleBufferAttachmentDescriptorArray)); +} + +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptor* MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex); +} + +_MTL_INLINE void MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray::setObject(const MTL::ResourceStatePassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex); +} + +_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLResourceStatePassDescriptor)); +} + +_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ResourceStatePassDescriptor* MTL::ResourceStatePassDescriptor::resourceStatePassDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLResourceStatePassDescriptor), _MTL_PRIVATE_SEL(resourceStatePassDescriptor)); +} + +_MTL_INLINE MTL::ResourceStatePassSampleBufferAttachmentDescriptorArray* MTL::ResourceStatePassDescriptor::sampleBufferAttachments() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleBufferAttachments)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLResourceViewPool.hpp b/thirdparty/metal-cpp/Metal/MTLResourceViewPool.hpp new file mode 100644 index 0000000000..aa8bfda353 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLResourceViewPool.hpp @@ -0,0 +1,118 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLResourceViewPool.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Device; +class ResourceViewPool; +class ResourceViewPoolDescriptor; + +class ResourceViewPoolDescriptor : public NS::Copying +{ +public: + static ResourceViewPoolDescriptor* alloc(); + + ResourceViewPoolDescriptor* init(); + + NS::String* label() const; + + NS::UInteger resourceViewCount() const; + + void setLabel(const NS::String* label); + + void setResourceViewCount(NS::UInteger resourceViewCount); +}; +class ResourceViewPool : public NS::Referencing +{ +public: + ResourceID baseResourceID() const; + + ResourceID copyResourceViewsFromPool(const MTL::ResourceViewPool* sourcePool, NS::Range sourceRange, NS::UInteger destinationIndex); + + Device* device() const; + + NS::String* label() const; + + NS::UInteger resourceViewCount() const; +}; + +} +_MTL_INLINE MTL::ResourceViewPoolDescriptor* MTL::ResourceViewPoolDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLResourceViewPoolDescriptor)); +} + +_MTL_INLINE MTL::ResourceViewPoolDescriptor* MTL::ResourceViewPoolDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::ResourceViewPoolDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::ResourceViewPoolDescriptor::resourceViewCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceViewCount)); +} + +_MTL_INLINE void MTL::ResourceViewPoolDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::ResourceViewPoolDescriptor::setResourceViewCount(NS::UInteger resourceViewCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResourceViewCount_), resourceViewCount); +} + +_MTL_INLINE MTL::ResourceID MTL::ResourceViewPool::baseResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(baseResourceID)); +} + +_MTL_INLINE MTL::ResourceID MTL::ResourceViewPool::copyResourceViewsFromPool(const MTL::ResourceViewPool* sourcePool, NS::Range sourceRange, NS::UInteger destinationIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(copyResourceViewsFromPool_sourceRange_destinationIndex_), sourcePool, sourceRange, destinationIndex); +} + +_MTL_INLINE MTL::Device* MTL::ResourceViewPool::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE NS::String* MTL::ResourceViewPool::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE NS::UInteger MTL::ResourceViewPool::resourceViewCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceViewCount)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLSampler.hpp b/thirdparty/metal-cpp/Metal/MTLSampler.hpp new file mode 100644 index 0000000000..f2286656f2 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLSampler.hpp @@ -0,0 +1,345 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLSampler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLDepthStencil.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Device; +class SamplerDescriptor; +_MTL_ENUM(NS::UInteger, SamplerMinMagFilter) { + SamplerMinMagFilterNearest = 0, + SamplerMinMagFilterLinear = 1, +}; + +_MTL_ENUM(NS::UInteger, SamplerMipFilter) { + SamplerMipFilterNotMipmapped = 0, + SamplerMipFilterNearest = 1, + SamplerMipFilterLinear = 2, +}; + +_MTL_ENUM(NS::UInteger, SamplerAddressMode) { + SamplerAddressModeClampToEdge = 0, + SamplerAddressModeMirrorClampToEdge = 1, + SamplerAddressModeRepeat = 2, + SamplerAddressModeMirrorRepeat = 3, + SamplerAddressModeClampToZero = 4, + SamplerAddressModeClampToBorderColor = 5, +}; + +_MTL_ENUM(NS::UInteger, SamplerBorderColor) { + SamplerBorderColorTransparentBlack = 0, + SamplerBorderColorOpaqueBlack = 1, + SamplerBorderColorOpaqueWhite = 2, +}; + +_MTL_ENUM(NS::UInteger, SamplerReductionMode) { + SamplerReductionModeWeightedAverage = 0, + SamplerReductionModeMinimum = 1, + SamplerReductionModeMaximum = 2, +}; + +class SamplerDescriptor : public NS::Copying +{ +public: + static SamplerDescriptor* alloc(); + + SamplerBorderColor borderColor() const; + + CompareFunction compareFunction() const; + + SamplerDescriptor* init(); + + NS::String* label() const; + + bool lodAverage() const; + + float lodBias() const; + + float lodMaxClamp() const; + + float lodMinClamp() const; + + SamplerMinMagFilter magFilter() const; + + NS::UInteger maxAnisotropy() const; + + SamplerMinMagFilter minFilter() const; + + SamplerMipFilter mipFilter() const; + + bool normalizedCoordinates() const; + + SamplerAddressMode rAddressMode() const; + + SamplerReductionMode reductionMode() const; + + SamplerAddressMode sAddressMode() const; + + void setBorderColor(MTL::SamplerBorderColor borderColor); + + void setCompareFunction(MTL::CompareFunction compareFunction); + + void setLabel(const NS::String* label); + + void setLodAverage(bool lodAverage); + + void setLodBias(float lodBias); + + void setLodMaxClamp(float lodMaxClamp); + + void setLodMinClamp(float lodMinClamp); + + void setMagFilter(MTL::SamplerMinMagFilter magFilter); + + void setMaxAnisotropy(NS::UInteger maxAnisotropy); + + void setMinFilter(MTL::SamplerMinMagFilter minFilter); + + void setMipFilter(MTL::SamplerMipFilter mipFilter); + + void setNormalizedCoordinates(bool normalizedCoordinates); + + void setRAddressMode(MTL::SamplerAddressMode rAddressMode); + + void setReductionMode(MTL::SamplerReductionMode reductionMode); + + void setSAddressMode(MTL::SamplerAddressMode sAddressMode); + + void setSupportArgumentBuffers(bool supportArgumentBuffers); + + void setTAddressMode(MTL::SamplerAddressMode tAddressMode); + + bool supportArgumentBuffers() const; + + SamplerAddressMode tAddressMode() const; +}; +class SamplerState : public NS::Referencing +{ +public: + Device* device() const; + + ResourceID gpuResourceID() const; + + NS::String* label() const; +}; + +} +_MTL_INLINE MTL::SamplerDescriptor* MTL::SamplerDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLSamplerDescriptor)); +} + +_MTL_INLINE MTL::SamplerBorderColor MTL::SamplerDescriptor::borderColor() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(borderColor)); +} + +_MTL_INLINE MTL::CompareFunction MTL::SamplerDescriptor::compareFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(compareFunction)); +} + +_MTL_INLINE MTL::SamplerDescriptor* MTL::SamplerDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::SamplerDescriptor::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE bool MTL::SamplerDescriptor::lodAverage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(lodAverage)); +} + +_MTL_INLINE float MTL::SamplerDescriptor::lodBias() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(lodBias)); +} + +_MTL_INLINE float MTL::SamplerDescriptor::lodMaxClamp() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(lodMaxClamp)); +} + +_MTL_INLINE float MTL::SamplerDescriptor::lodMinClamp() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(lodMinClamp)); +} + +_MTL_INLINE MTL::SamplerMinMagFilter MTL::SamplerDescriptor::magFilter() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(magFilter)); +} + +_MTL_INLINE NS::UInteger MTL::SamplerDescriptor::maxAnisotropy() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(maxAnisotropy)); +} + +_MTL_INLINE MTL::SamplerMinMagFilter MTL::SamplerDescriptor::minFilter() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(minFilter)); +} + +_MTL_INLINE MTL::SamplerMipFilter MTL::SamplerDescriptor::mipFilter() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mipFilter)); +} + +_MTL_INLINE bool MTL::SamplerDescriptor::normalizedCoordinates() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(normalizedCoordinates)); +} + +_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::rAddressMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rAddressMode)); +} + +_MTL_INLINE MTL::SamplerReductionMode MTL::SamplerDescriptor::reductionMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(reductionMode)); +} + +_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::sAddressMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sAddressMode)); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setBorderColor(MTL::SamplerBorderColor borderColor) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBorderColor_), borderColor); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setCompareFunction(MTL::CompareFunction compareFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCompareFunction_), compareFunction); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setLabel(const NS::String* label) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLabel_), label); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setLodAverage(bool lodAverage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLodAverage_), lodAverage); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setLodBias(float lodBias) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLodBias_), lodBias); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setLodMaxClamp(float lodMaxClamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLodMaxClamp_), lodMaxClamp); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setLodMinClamp(float lodMinClamp) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLodMinClamp_), lodMinClamp); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setMagFilter(MTL::SamplerMinMagFilter magFilter) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMagFilter_), magFilter); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setMaxAnisotropy(NS::UInteger maxAnisotropy) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMaxAnisotropy_), maxAnisotropy); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setMinFilter(MTL::SamplerMinMagFilter minFilter) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMinFilter_), minFilter); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setMipFilter(MTL::SamplerMipFilter mipFilter) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMipFilter_), mipFilter); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setNormalizedCoordinates(bool normalizedCoordinates) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setNormalizedCoordinates_), normalizedCoordinates); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setRAddressMode(MTL::SamplerAddressMode rAddressMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setRAddressMode_), rAddressMode); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setReductionMode(MTL::SamplerReductionMode reductionMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setReductionMode_), reductionMode); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setSAddressMode(MTL::SamplerAddressMode sAddressMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSAddressMode_), sAddressMode); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setSupportArgumentBuffers(bool supportArgumentBuffers) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSupportArgumentBuffers_), supportArgumentBuffers); +} + +_MTL_INLINE void MTL::SamplerDescriptor::setTAddressMode(MTL::SamplerAddressMode tAddressMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTAddressMode_), tAddressMode); +} + +_MTL_INLINE bool MTL::SamplerDescriptor::supportArgumentBuffers() const +{ + return Object::sendMessageSafe(this, _MTL_PRIVATE_SEL(supportArgumentBuffers)); +} + +_MTL_INLINE MTL::SamplerAddressMode MTL::SamplerDescriptor::tAddressMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tAddressMode)); +} + +_MTL_INLINE MTL::Device* MTL::SamplerState::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::ResourceID MTL::SamplerState::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::String* MTL::SamplerState::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLStageInputOutputDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTLStageInputOutputDescriptor.hpp new file mode 100644 index 0000000000..b9a7a48392 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLStageInputOutputDescriptor.hpp @@ -0,0 +1,356 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLStageInputOutputDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLArgument.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class AttributeDescriptor; +class AttributeDescriptorArray; +class BufferLayoutDescriptor; +class BufferLayoutDescriptorArray; +class StageInputOutputDescriptor; +_MTL_ENUM(NS::UInteger, AttributeFormat) { + AttributeFormatInvalid = 0, + AttributeFormatUChar2 = 1, + AttributeFormatUChar3 = 2, + AttributeFormatUChar4 = 3, + AttributeFormatChar2 = 4, + AttributeFormatChar3 = 5, + AttributeFormatChar4 = 6, + AttributeFormatUChar2Normalized = 7, + AttributeFormatUChar3Normalized = 8, + AttributeFormatUChar4Normalized = 9, + AttributeFormatChar2Normalized = 10, + AttributeFormatChar3Normalized = 11, + AttributeFormatChar4Normalized = 12, + AttributeFormatUShort2 = 13, + AttributeFormatUShort3 = 14, + AttributeFormatUShort4 = 15, + AttributeFormatShort2 = 16, + AttributeFormatShort3 = 17, + AttributeFormatShort4 = 18, + AttributeFormatUShort2Normalized = 19, + AttributeFormatUShort3Normalized = 20, + AttributeFormatUShort4Normalized = 21, + AttributeFormatShort2Normalized = 22, + AttributeFormatShort3Normalized = 23, + AttributeFormatShort4Normalized = 24, + AttributeFormatHalf2 = 25, + AttributeFormatHalf3 = 26, + AttributeFormatHalf4 = 27, + AttributeFormatFloat = 28, + AttributeFormatFloat2 = 29, + AttributeFormatFloat3 = 30, + AttributeFormatFloat4 = 31, + AttributeFormatInt = 32, + AttributeFormatInt2 = 33, + AttributeFormatInt3 = 34, + AttributeFormatInt4 = 35, + AttributeFormatUInt = 36, + AttributeFormatUInt2 = 37, + AttributeFormatUInt3 = 38, + AttributeFormatUInt4 = 39, + AttributeFormatInt1010102Normalized = 40, + AttributeFormatUInt1010102Normalized = 41, + AttributeFormatUChar4Normalized_BGRA = 42, + AttributeFormatUChar = 45, + AttributeFormatChar = 46, + AttributeFormatUCharNormalized = 47, + AttributeFormatCharNormalized = 48, + AttributeFormatUShort = 49, + AttributeFormatShort = 50, + AttributeFormatUShortNormalized = 51, + AttributeFormatShortNormalized = 52, + AttributeFormatHalf = 53, + AttributeFormatFloatRG11B10 = 54, + AttributeFormatFloatRGB9E5 = 55, +}; + +_MTL_ENUM(NS::UInteger, StepFunction) { + StepFunctionConstant = 0, + StepFunctionPerVertex = 1, + StepFunctionPerInstance = 2, + StepFunctionPerPatch = 3, + StepFunctionPerPatchControlPoint = 4, + StepFunctionThreadPositionInGridX = 5, + StepFunctionThreadPositionInGridY = 6, + StepFunctionThreadPositionInGridXIndexed = 7, + StepFunctionThreadPositionInGridYIndexed = 8, +}; + +class BufferLayoutDescriptor : public NS::Copying +{ +public: + static BufferLayoutDescriptor* alloc(); + + BufferLayoutDescriptor* init(); + + void setStepFunction(MTL::StepFunction stepFunction); + + void setStepRate(NS::UInteger stepRate); + + void setStride(NS::UInteger stride); + + StepFunction stepFunction() const; + + NS::UInteger stepRate() const; + + NS::UInteger stride() const; +}; +class BufferLayoutDescriptorArray : public NS::Referencing +{ +public: + static BufferLayoutDescriptorArray* alloc(); + + BufferLayoutDescriptorArray* init(); + + BufferLayoutDescriptor* object(NS::UInteger index); + void setObject(const MTL::BufferLayoutDescriptor* bufferDesc, NS::UInteger index); +}; +class AttributeDescriptor : public NS::Copying +{ +public: + static AttributeDescriptor* alloc(); + + NS::UInteger bufferIndex() const; + + AttributeFormat format() const; + + AttributeDescriptor* init(); + + NS::UInteger offset() const; + + void setBufferIndex(NS::UInteger bufferIndex); + + void setFormat(MTL::AttributeFormat format); + + void setOffset(NS::UInteger offset); +}; +class AttributeDescriptorArray : public NS::Referencing +{ +public: + static AttributeDescriptorArray* alloc(); + + AttributeDescriptorArray* init(); + + AttributeDescriptor* object(NS::UInteger index); + void setObject(const MTL::AttributeDescriptor* attributeDesc, NS::UInteger index); +}; +class StageInputOutputDescriptor : public NS::Copying +{ +public: + static StageInputOutputDescriptor* alloc(); + + AttributeDescriptorArray* attributes() const; + + NS::UInteger indexBufferIndex() const; + + IndexType indexType() const; + + StageInputOutputDescriptor* init(); + + BufferLayoutDescriptorArray* layouts() const; + + void reset(); + + void setIndexBufferIndex(NS::UInteger indexBufferIndex); + + void setIndexType(MTL::IndexType indexType); + + static StageInputOutputDescriptor* stageInputOutputDescriptor(); +}; + +} +_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBufferLayoutDescriptor)); +} + +_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::BufferLayoutDescriptor::setStepFunction(MTL::StepFunction stepFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStepFunction_), stepFunction); +} + +_MTL_INLINE void MTL::BufferLayoutDescriptor::setStepRate(NS::UInteger stepRate) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStepRate_), stepRate); +} + +_MTL_INLINE void MTL::BufferLayoutDescriptor::setStride(NS::UInteger stride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStride_), stride); +} + +_MTL_INLINE MTL::StepFunction MTL::BufferLayoutDescriptor::stepFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stepFunction)); +} + +_MTL_INLINE NS::UInteger MTL::BufferLayoutDescriptor::stepRate() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stepRate)); +} + +_MTL_INLINE NS::UInteger MTL::BufferLayoutDescriptor::stride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stride)); +} + +_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::BufferLayoutDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLBufferLayoutDescriptorArray)); +} + +_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::BufferLayoutDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::BufferLayoutDescriptor* MTL::BufferLayoutDescriptorArray::object(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index); +} + +_MTL_INLINE void MTL::BufferLayoutDescriptorArray::setObject(const MTL::BufferLayoutDescriptor* bufferDesc, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), bufferDesc, index); +} + +_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAttributeDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::AttributeDescriptor::bufferIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferIndex)); +} + +_MTL_INLINE MTL::AttributeFormat MTL::AttributeDescriptor::format() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(format)); +} + +_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::AttributeDescriptor::offset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(offset)); +} + +_MTL_INLINE void MTL::AttributeDescriptor::setBufferIndex(NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBufferIndex_), bufferIndex); +} + +_MTL_INLINE void MTL::AttributeDescriptor::setFormat(MTL::AttributeFormat format) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFormat_), format); +} + +_MTL_INLINE void MTL::AttributeDescriptor::setOffset(NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOffset_), offset); +} + +_MTL_INLINE MTL::AttributeDescriptorArray* MTL::AttributeDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLAttributeDescriptorArray)); +} + +_MTL_INLINE MTL::AttributeDescriptorArray* MTL::AttributeDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::AttributeDescriptor* MTL::AttributeDescriptorArray::object(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index); +} + +_MTL_INLINE void MTL::AttributeDescriptorArray::setObject(const MTL::AttributeDescriptor* attributeDesc, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attributeDesc, index); +} + +_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLStageInputOutputDescriptor)); +} + +_MTL_INLINE MTL::AttributeDescriptorArray* MTL::StageInputOutputDescriptor::attributes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributes)); +} + +_MTL_INLINE NS::UInteger MTL::StageInputOutputDescriptor::indexBufferIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexBufferIndex)); +} + +_MTL_INLINE MTL::IndexType MTL::StageInputOutputDescriptor::indexType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(indexType)); +} + +_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::BufferLayoutDescriptorArray* MTL::StageInputOutputDescriptor::layouts() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layouts)); +} + +_MTL_INLINE void MTL::StageInputOutputDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE void MTL::StageInputOutputDescriptor::setIndexBufferIndex(NS::UInteger indexBufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexBufferIndex_), indexBufferIndex); +} + +_MTL_INLINE void MTL::StageInputOutputDescriptor::setIndexType(MTL::IndexType indexType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setIndexType_), indexType); +} + +_MTL_INLINE MTL::StageInputOutputDescriptor* MTL::StageInputOutputDescriptor::stageInputOutputDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLStageInputOutputDescriptor), _MTL_PRIVATE_SEL(stageInputOutputDescriptor)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLTensor.hpp b/thirdparty/metal-cpp/Metal/MTLTensor.hpp new file mode 100644 index 0000000000..221b8c9f15 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLTensor.hpp @@ -0,0 +1,297 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLTensor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Buffer; +class TensorDescriptor; +class TensorExtents; + +_MTL_CONST(NS::ErrorDomain, TensorDomain); + +_MTL_ENUM(NS::Integer, TensorDataType) { + TensorDataTypeNone = 0, + TensorDataTypeFloat32 = 3, + TensorDataTypeFloat16 = 16, + TensorDataTypeBFloat16 = 121, + TensorDataTypeInt8 = 45, + TensorDataTypeUInt8 = 49, + TensorDataTypeInt16 = 37, + TensorDataTypeUInt16 = 41, + TensorDataTypeInt32 = 29, + TensorDataTypeUInt32 = 33, +}; + +_MTL_ENUM(NS::Integer, TensorError) { + TensorErrorNone = 0, + TensorErrorInternalError = 1, + TensorErrorInvalidDescriptor = 2, +}; + +_MTL_OPTIONS(NS::UInteger, TensorUsage) { + TensorUsageCompute = 1, + TensorUsageRender = 1 << 1, + TensorUsageMachineLearning = 1 << 2, +}; + +class TensorExtents : public NS::Referencing +{ +public: + static TensorExtents* alloc(); + + NS::Integer extentAtDimensionIndex(NS::UInteger dimensionIndex); + + TensorExtents* init(); + TensorExtents* init(NS::UInteger rank, const NS::Integer* values); + + NS::UInteger rank() const; +}; +class TensorDescriptor : public NS::Copying +{ +public: + static TensorDescriptor* alloc(); + + CPUCacheMode cpuCacheMode() const; + + TensorDataType dataType() const; + + TensorExtents* dimensions() const; + + HazardTrackingMode hazardTrackingMode() const; + + TensorDescriptor* init(); + + ResourceOptions resourceOptions() const; + + void setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode); + + void setDataType(MTL::TensorDataType dataType); + + void setDimensions(const MTL::TensorExtents* dimensions); + + void setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode); + + void setResourceOptions(MTL::ResourceOptions resourceOptions); + + void setStorageMode(MTL::StorageMode storageMode); + + void setStrides(const MTL::TensorExtents* strides); + + void setUsage(MTL::TensorUsage usage); + + StorageMode storageMode() const; + + TensorExtents* strides() const; + + TensorUsage usage() const; +}; +class Tensor : public NS::Referencing +{ +public: + Buffer* buffer() const; + NS::UInteger bufferOffset() const; + + TensorDataType dataType() const; + + TensorExtents* dimensions() const; + + void getBytes(void* bytes, const MTL::TensorExtents* strides, const MTL::TensorExtents* sliceOrigin, const MTL::TensorExtents* sliceDimensions); + + ResourceID gpuResourceID() const; + + void replaceSliceOrigin(const MTL::TensorExtents* sliceOrigin, const MTL::TensorExtents* sliceDimensions, const void* bytes, const MTL::TensorExtents* strides); + + TensorExtents* strides() const; + + TensorUsage usage() const; +}; + +} + +_MTL_PRIVATE_DEF_CONST(NS::ErrorDomain, TensorDomain); + +_MTL_INLINE MTL::TensorExtents* MTL::TensorExtents::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTensorExtents)); +} + +_MTL_INLINE NS::Integer MTL::TensorExtents::extentAtDimensionIndex(NS::UInteger dimensionIndex) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(extentAtDimensionIndex_), dimensionIndex); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorExtents::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorExtents::init(NS::UInteger rank, const NS::Integer* values) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(initWithRank_values_), rank, values); +} + +_MTL_INLINE NS::UInteger MTL::TensorExtents::rank() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rank)); +} + +_MTL_INLINE MTL::TensorDescriptor* MTL::TensorDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTensorDescriptor)); +} + +_MTL_INLINE MTL::CPUCacheMode MTL::TensorDescriptor::cpuCacheMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(cpuCacheMode)); +} + +_MTL_INLINE MTL::TensorDataType MTL::TensorDescriptor::dataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataType)); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorDescriptor::dimensions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dimensions)); +} + +_MTL_INLINE MTL::HazardTrackingMode MTL::TensorDescriptor::hazardTrackingMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hazardTrackingMode)); +} + +_MTL_INLINE MTL::TensorDescriptor* MTL::TensorDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::ResourceOptions MTL::TensorDescriptor::resourceOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceOptions)); +} + +_MTL_INLINE void MTL::TensorDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode); +} + +_MTL_INLINE void MTL::TensorDescriptor::setDataType(MTL::TensorDataType dataType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDataType_), dataType); +} + +_MTL_INLINE void MTL::TensorDescriptor::setDimensions(const MTL::TensorExtents* dimensions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDimensions_), dimensions); +} + +_MTL_INLINE void MTL::TensorDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode); +} + +_MTL_INLINE void MTL::TensorDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions); +} + +_MTL_INLINE void MTL::TensorDescriptor::setStorageMode(MTL::StorageMode storageMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode); +} + +_MTL_INLINE void MTL::TensorDescriptor::setStrides(const MTL::TensorExtents* strides) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStrides_), strides); +} + +_MTL_INLINE void MTL::TensorDescriptor::setUsage(MTL::TensorUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setUsage_), usage); +} + +_MTL_INLINE MTL::StorageMode MTL::TensorDescriptor::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} + +_MTL_INLINE MTL::TensorExtents* MTL::TensorDescriptor::strides() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(strides)); +} + +_MTL_INLINE MTL::TensorUsage MTL::TensorDescriptor::usage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usage)); +} + +_MTL_INLINE MTL::Buffer* MTL::Tensor::buffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(buffer)); +} + +_MTL_INLINE NS::UInteger MTL::Tensor::bufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferOffset)); +} + +_MTL_INLINE MTL::TensorDataType MTL::Tensor::dataType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dataType)); +} + +_MTL_INLINE MTL::TensorExtents* MTL::Tensor::dimensions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(dimensions)); +} + +_MTL_INLINE void MTL::Tensor::getBytes(void* bytes, const MTL::TensorExtents* strides, const MTL::TensorExtents* sliceOrigin, const MTL::TensorExtents* sliceDimensions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(getBytes_strides_fromSliceOrigin_sliceDimensions_), bytes, strides, sliceOrigin, sliceDimensions); +} + +_MTL_INLINE MTL::ResourceID MTL::Tensor::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE void MTL::Tensor::replaceSliceOrigin(const MTL::TensorExtents* sliceOrigin, const MTL::TensorExtents* sliceDimensions, const void* bytes, const MTL::TensorExtents* strides) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(replaceSliceOrigin_sliceDimensions_withBytes_strides_), sliceOrigin, sliceDimensions, bytes, strides); +} + +_MTL_INLINE MTL::TensorExtents* MTL::Tensor::strides() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(strides)); +} + +_MTL_INLINE MTL::TensorUsage MTL::Tensor::usage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usage)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLTexture.hpp b/thirdparty/metal-cpp/Metal/MTLTexture.hpp new file mode 100644 index 0000000000..631d9202fc --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLTexture.hpp @@ -0,0 +1,803 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLTexture.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPixelFormat.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTypes.hpp" +#include + +namespace MTL +{ +class Buffer; +class Device; +class Resource; +class SharedTextureHandle; +class Texture; +class TextureDescriptor; +class TextureViewDescriptor; +} + +namespace MTL +{ +_MTL_ENUM(NS::UInteger, TextureType) { + TextureType1D = 0, + TextureType1DArray = 1, + TextureType2D = 2, + TextureType2DArray = 3, + TextureType2DMultisample = 4, + TextureTypeCube = 5, + TextureTypeCubeArray = 6, + TextureType3D = 7, + TextureType2DMultisampleArray = 8, + TextureTypeTextureBuffer = 9, +}; + +_MTL_ENUM(uint8_t, TextureSwizzle) { + TextureSwizzleZero = 0, + TextureSwizzleOne = 1, + TextureSwizzleRed = 2, + TextureSwizzleGreen = 3, + TextureSwizzleBlue = 4, + TextureSwizzleAlpha = 5, +}; + +_MTL_ENUM(NS::Integer, TextureCompressionType) { + TextureCompressionTypeLossless = 0, + TextureCompressionTypeLossy = 1, +}; + +_MTL_OPTIONS(NS::UInteger, TextureUsage) { + TextureUsageUnknown = 0, + TextureUsageShaderRead = 1, + TextureUsageShaderWrite = 1 << 1, + TextureUsageRenderTarget = 1 << 2, + TextureUsagePixelFormatView = 1 << 4, + TextureUsageShaderAtomic = 1 << 5, +}; + +struct TextureSwizzleChannels +{ + + TextureSwizzleChannels(MTL::TextureSwizzle r, MTL::TextureSwizzle g, MTL::TextureSwizzle b, MTL::TextureSwizzle a); + + TextureSwizzleChannels(); + + static TextureSwizzleChannels Default(); + + static TextureSwizzleChannels Make(MTL::TextureSwizzle r, MTL::TextureSwizzle g, MTL::TextureSwizzle b, MTL::TextureSwizzle a); + + MTL::TextureSwizzle red; + MTL::TextureSwizzle green; + MTL::TextureSwizzle blue; + MTL::TextureSwizzle alpha; +} _MTL_PACKED; + +class SharedTextureHandle : public NS::SecureCoding +{ +public: + static SharedTextureHandle* alloc(); + + Device* device() const; + + SharedTextureHandle* init(); + + NS::String* label() const; +}; +class TextureDescriptor : public NS::Copying +{ +public: + static TextureDescriptor* alloc(); + + bool allowGPUOptimizedContents() const; + + NS::UInteger arrayLength() const; + + TextureCompressionType compressionType() const; + + CPUCacheMode cpuCacheMode() const; + + NS::UInteger depth() const; + + HazardTrackingMode hazardTrackingMode() const; + + NS::UInteger height() const; + + TextureDescriptor* init(); + + NS::UInteger mipmapLevelCount() const; + + PixelFormat pixelFormat() const; + + SparsePageSize placementSparsePageSize() const; + + ResourceOptions resourceOptions() const; + + NS::UInteger sampleCount() const; + + void setAllowGPUOptimizedContents(bool allowGPUOptimizedContents); + + void setArrayLength(NS::UInteger arrayLength); + + void setCompressionType(MTL::TextureCompressionType compressionType); + + void setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode); + + void setDepth(NS::UInteger depth); + + void setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode); + + void setHeight(NS::UInteger height); + + void setMipmapLevelCount(NS::UInteger mipmapLevelCount); + + void setPixelFormat(MTL::PixelFormat pixelFormat); + + void setPlacementSparsePageSize(MTL::SparsePageSize placementSparsePageSize); + + void setResourceOptions(MTL::ResourceOptions resourceOptions); + + void setSampleCount(NS::UInteger sampleCount); + + void setStorageMode(MTL::StorageMode storageMode); + + void setSwizzle(MTL::TextureSwizzleChannels swizzle); + + void setTextureType(MTL::TextureType textureType); + + void setUsage(MTL::TextureUsage usage); + + void setWidth(NS::UInteger width); + + StorageMode storageMode() const; + + TextureSwizzleChannels swizzle() const; + + static TextureDescriptor* texture2DDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, NS::UInteger height, bool mipmapped); + + static TextureDescriptor* textureBufferDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, MTL::ResourceOptions resourceOptions, MTL::TextureUsage usage); + + static TextureDescriptor* textureCubeDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger size, bool mipmapped); + + TextureType textureType() const; + + TextureUsage usage() const; + + NS::UInteger width() const; +}; +class TextureViewDescriptor : public NS::Copying +{ +public: + static TextureViewDescriptor* alloc(); + + TextureViewDescriptor* init(); + + NS::Range levelRange() const; + + PixelFormat pixelFormat() const; + + void setLevelRange(NS::Range levelRange); + + void setPixelFormat(MTL::PixelFormat pixelFormat); + + void setSliceRange(NS::Range sliceRange); + + void setSwizzle(MTL::TextureSwizzleChannels swizzle); + + void setTextureType(MTL::TextureType textureType); + + NS::Range sliceRange() const; + + TextureSwizzleChannels swizzle() const; + + TextureType textureType() const; +}; +class Texture : public NS::Referencing +{ +public: + bool allowGPUOptimizedContents() const; + + NS::UInteger arrayLength() const; + + Buffer* buffer() const; + NS::UInteger bufferBytesPerRow() const; + + NS::UInteger bufferOffset() const; + + TextureCompressionType compressionType() const; + + NS::UInteger depth() const; + + NS::UInteger firstMipmapInTail() const; + + [[deprecated("please use isFramebufferOnly instead")]] + bool framebufferOnly() const; + + void getBytes(void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage, MTL::Region region, NS::UInteger level, NS::UInteger slice); + void getBytes(void* pixelBytes, NS::UInteger bytesPerRow, MTL::Region region, NS::UInteger level); + + ResourceID gpuResourceID() const; + + NS::UInteger height() const; + + IOSurfaceRef iosurface() const; + NS::UInteger iosurfacePlane() const; + + bool isFramebufferOnly() const; + + bool isShareable() const; + + bool isSparse() const; + + NS::UInteger mipmapLevelCount() const; + + Texture* newRemoteTextureViewForDevice(const MTL::Device* device); + + SharedTextureHandle* newSharedTextureHandle(); + + Texture* newTextureView(MTL::PixelFormat pixelFormat); + Texture* newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange); + Texture* newTextureView(const MTL::TextureViewDescriptor* descriptor); + Texture* newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange, MTL::TextureSwizzleChannels swizzle); + + NS::UInteger parentRelativeLevel() const; + + NS::UInteger parentRelativeSlice() const; + + Texture* parentTexture() const; + + PixelFormat pixelFormat() const; + + Texture* remoteStorageTexture() const; + + void replaceRegion(MTL::Region region, NS::UInteger level, NS::UInteger slice, const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage); + void replaceRegion(MTL::Region region, NS::UInteger level, const void* pixelBytes, NS::UInteger bytesPerRow); + + Resource* rootResource() const; + + NS::UInteger sampleCount() const; + + [[deprecated("please use isShareable instead")]] + bool shareable() const; + + TextureSparseTier sparseTextureTier() const; + + TextureSwizzleChannels swizzle() const; + + NS::UInteger tailSizeInBytes() const; + + TextureType textureType() const; + + TextureUsage usage() const; + + NS::UInteger width() const; +}; + +} +_MTL_INLINE MTL::TextureSwizzleChannels::TextureSwizzleChannels(MTL::TextureSwizzle r, MTL::TextureSwizzle g, MTL::TextureSwizzle b, MTL::TextureSwizzle a) + : red(r) + , green(g) + , blue(b) + , alpha(a) +{ +} + +_MTL_INLINE MTL::TextureSwizzleChannels::TextureSwizzleChannels() + : red(MTL::TextureSwizzleRed) + , green(MTL::TextureSwizzleGreen) + , blue(MTL::TextureSwizzleBlue) + , alpha(MTL::TextureSwizzleAlpha) +{ +} + +_MTL_INLINE MTL::TextureSwizzleChannels MTL::TextureSwizzleChannels::Default() +{ + return MTL::TextureSwizzleChannels(); +} + +_MTL_INLINE MTL::TextureSwizzleChannels MTL::TextureSwizzleChannels::Make(MTL::TextureSwizzle r, MTL::TextureSwizzle g, MTL::TextureSwizzle b, MTL::TextureSwizzle a) +{ + return TextureSwizzleChannels(r, g, b, a); +} + +_MTL_INLINE MTL::SharedTextureHandle* MTL::SharedTextureHandle::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLSharedTextureHandle)); +} + +_MTL_INLINE MTL::Device* MTL::SharedTextureHandle::device() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(device)); +} + +_MTL_INLINE MTL::SharedTextureHandle* MTL::SharedTextureHandle::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::String* MTL::SharedTextureHandle::label() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(label)); +} + +_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTextureDescriptor)); +} + +_MTL_INLINE bool MTL::TextureDescriptor::allowGPUOptimizedContents() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allowGPUOptimizedContents)); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE MTL::TextureCompressionType MTL::TextureDescriptor::compressionType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(compressionType)); +} + +_MTL_INLINE MTL::CPUCacheMode MTL::TextureDescriptor::cpuCacheMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(cpuCacheMode)); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::depth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depth)); +} + +_MTL_INLINE MTL::HazardTrackingMode MTL::TextureDescriptor::hazardTrackingMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(hazardTrackingMode)); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::height() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(height)); +} + +_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::mipmapLevelCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mipmapLevelCount)); +} + +_MTL_INLINE MTL::PixelFormat MTL::TextureDescriptor::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE MTL::SparsePageSize MTL::TextureDescriptor::placementSparsePageSize() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(placementSparsePageSize)); +} + +_MTL_INLINE MTL::ResourceOptions MTL::TextureDescriptor::resourceOptions() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(resourceOptions)); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} + +_MTL_INLINE void MTL::TextureDescriptor::setAllowGPUOptimizedContents(bool allowGPUOptimizedContents) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setAllowGPUOptimizedContents_), allowGPUOptimizedContents); +} + +_MTL_INLINE void MTL::TextureDescriptor::setArrayLength(NS::UInteger arrayLength) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setArrayLength_), arrayLength); +} + +_MTL_INLINE void MTL::TextureDescriptor::setCompressionType(MTL::TextureCompressionType compressionType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCompressionType_), compressionType); +} + +_MTL_INLINE void MTL::TextureDescriptor::setCpuCacheMode(MTL::CPUCacheMode cpuCacheMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setCpuCacheMode_), cpuCacheMode); +} + +_MTL_INLINE void MTL::TextureDescriptor::setDepth(NS::UInteger depth) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setDepth_), depth); +} + +_MTL_INLINE void MTL::TextureDescriptor::setHazardTrackingMode(MTL::HazardTrackingMode hazardTrackingMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setHazardTrackingMode_), hazardTrackingMode); +} + +_MTL_INLINE void MTL::TextureDescriptor::setHeight(NS::UInteger height) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setHeight_), height); +} + +_MTL_INLINE void MTL::TextureDescriptor::setMipmapLevelCount(NS::UInteger mipmapLevelCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setMipmapLevelCount_), mipmapLevelCount); +} + +_MTL_INLINE void MTL::TextureDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat); +} + +_MTL_INLINE void MTL::TextureDescriptor::setPlacementSparsePageSize(MTL::SparsePageSize placementSparsePageSize) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPlacementSparsePageSize_), placementSparsePageSize); +} + +_MTL_INLINE void MTL::TextureDescriptor::setResourceOptions(MTL::ResourceOptions resourceOptions) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setResourceOptions_), resourceOptions); +} + +_MTL_INLINE void MTL::TextureDescriptor::setSampleCount(NS::UInteger sampleCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount); +} + +_MTL_INLINE void MTL::TextureDescriptor::setStorageMode(MTL::StorageMode storageMode) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStorageMode_), storageMode); +} + +_MTL_INLINE void MTL::TextureDescriptor::setSwizzle(MTL::TextureSwizzleChannels swizzle) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSwizzle_), swizzle); +} + +_MTL_INLINE void MTL::TextureDescriptor::setTextureType(MTL::TextureType textureType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureType_), textureType); +} + +_MTL_INLINE void MTL::TextureDescriptor::setUsage(MTL::TextureUsage usage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setUsage_), usage); +} + +_MTL_INLINE void MTL::TextureDescriptor::setWidth(NS::UInteger width) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setWidth_), width); +} + +_MTL_INLINE MTL::StorageMode MTL::TextureDescriptor::storageMode() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(storageMode)); +} + +_MTL_INLINE MTL::TextureSwizzleChannels MTL::TextureDescriptor::swizzle() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(swizzle)); +} + +_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::texture2DDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, NS::UInteger height, bool mipmapped) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(texture2DDescriptorWithPixelFormat_width_height_mipmapped_), pixelFormat, width, height, mipmapped); +} + +_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::textureBufferDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger width, MTL::ResourceOptions resourceOptions, MTL::TextureUsage usage) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(textureBufferDescriptorWithPixelFormat_width_resourceOptions_usage_), pixelFormat, width, resourceOptions, usage); +} + +_MTL_INLINE MTL::TextureDescriptor* MTL::TextureDescriptor::textureCubeDescriptor(MTL::PixelFormat pixelFormat, NS::UInteger size, bool mipmapped) +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLTextureDescriptor), _MTL_PRIVATE_SEL(textureCubeDescriptorWithPixelFormat_size_mipmapped_), pixelFormat, size, mipmapped); +} + +_MTL_INLINE MTL::TextureType MTL::TextureDescriptor::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE MTL::TextureUsage MTL::TextureDescriptor::usage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usage)); +} + +_MTL_INLINE NS::UInteger MTL::TextureDescriptor::width() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(width)); +} + +_MTL_INLINE MTL::TextureViewDescriptor* MTL::TextureViewDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLTextureViewDescriptor)); +} + +_MTL_INLINE MTL::TextureViewDescriptor* MTL::TextureViewDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::Range MTL::TextureViewDescriptor::levelRange() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(levelRange)); +} + +_MTL_INLINE MTL::PixelFormat MTL::TextureViewDescriptor::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE void MTL::TextureViewDescriptor::setLevelRange(NS::Range levelRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setLevelRange_), levelRange); +} + +_MTL_INLINE void MTL::TextureViewDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat); +} + +_MTL_INLINE void MTL::TextureViewDescriptor::setSliceRange(NS::Range sliceRange) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSliceRange_), sliceRange); +} + +_MTL_INLINE void MTL::TextureViewDescriptor::setSwizzle(MTL::TextureSwizzleChannels swizzle) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setSwizzle_), swizzle); +} + +_MTL_INLINE void MTL::TextureViewDescriptor::setTextureType(MTL::TextureType textureType) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureType_), textureType); +} + +_MTL_INLINE NS::Range MTL::TextureViewDescriptor::sliceRange() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sliceRange)); +} + +_MTL_INLINE MTL::TextureSwizzleChannels MTL::TextureViewDescriptor::swizzle() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(swizzle)); +} + +_MTL_INLINE MTL::TextureType MTL::TextureViewDescriptor::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE bool MTL::Texture::allowGPUOptimizedContents() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(allowGPUOptimizedContents)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::arrayLength() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(arrayLength)); +} + +_MTL_INLINE MTL::Buffer* MTL::Texture::buffer() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(buffer)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::bufferBytesPerRow() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferBytesPerRow)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::bufferOffset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferOffset)); +} + +_MTL_INLINE MTL::TextureCompressionType MTL::Texture::compressionType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(compressionType)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::depth() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(depth)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::firstMipmapInTail() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(firstMipmapInTail)); +} + +_MTL_INLINE bool MTL::Texture::framebufferOnly() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isFramebufferOnly)); +} + +_MTL_INLINE void MTL::Texture::getBytes(void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage, MTL::Region region, NS::UInteger level, NS::UInteger slice) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(getBytes_bytesPerRow_bytesPerImage_fromRegion_mipmapLevel_slice_), pixelBytes, bytesPerRow, bytesPerImage, region, level, slice); +} + +_MTL_INLINE void MTL::Texture::getBytes(void* pixelBytes, NS::UInteger bytesPerRow, MTL::Region region, NS::UInteger level) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(getBytes_bytesPerRow_fromRegion_mipmapLevel_), pixelBytes, bytesPerRow, region, level); +} + +_MTL_INLINE MTL::ResourceID MTL::Texture::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::height() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(height)); +} + +_MTL_INLINE IOSurfaceRef MTL::Texture::iosurface() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(iosurface)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::iosurfacePlane() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(iosurfacePlane)); +} + +_MTL_INLINE bool MTL::Texture::isFramebufferOnly() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isFramebufferOnly)); +} + +_MTL_INLINE bool MTL::Texture::isShareable() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isShareable)); +} + +_MTL_INLINE bool MTL::Texture::isSparse() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isSparse)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::mipmapLevelCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(mipmapLevelCount)); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::newRemoteTextureViewForDevice(const MTL::Device* device) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newRemoteTextureViewForDevice_), device); +} + +_MTL_INLINE MTL::SharedTextureHandle* MTL::Texture::newSharedTextureHandle() +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newSharedTextureHandle)); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_), pixelFormat); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_), pixelFormat, textureType, levelRange, sliceRange); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(const MTL::TextureViewDescriptor* descriptor) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureViewWithDescriptor_), descriptor); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::newTextureView(MTL::PixelFormat pixelFormat, MTL::TextureType textureType, NS::Range levelRange, NS::Range sliceRange, MTL::TextureSwizzleChannels swizzle) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(newTextureViewWithPixelFormat_textureType_levels_slices_swizzle_), pixelFormat, textureType, levelRange, sliceRange, swizzle); +} + +_MTL_INLINE NS::UInteger MTL::Texture::parentRelativeLevel() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(parentRelativeLevel)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::parentRelativeSlice() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(parentRelativeSlice)); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::parentTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(parentTexture)); +} + +_MTL_INLINE MTL::PixelFormat MTL::Texture::pixelFormat() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(pixelFormat)); +} + +_MTL_INLINE MTL::Texture* MTL::Texture::remoteStorageTexture() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(remoteStorageTexture)); +} + +_MTL_INLINE void MTL::Texture::replaceRegion(MTL::Region region, NS::UInteger level, NS::UInteger slice, const void* pixelBytes, NS::UInteger bytesPerRow, NS::UInteger bytesPerImage) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(replaceRegion_mipmapLevel_slice_withBytes_bytesPerRow_bytesPerImage_), region, level, slice, pixelBytes, bytesPerRow, bytesPerImage); +} + +_MTL_INLINE void MTL::Texture::replaceRegion(MTL::Region region, NS::UInteger level, const void* pixelBytes, NS::UInteger bytesPerRow) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(replaceRegion_mipmapLevel_withBytes_bytesPerRow_), region, level, pixelBytes, bytesPerRow); +} + +_MTL_INLINE MTL::Resource* MTL::Texture::rootResource() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(rootResource)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::sampleCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sampleCount)); +} + +_MTL_INLINE bool MTL::Texture::shareable() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(isShareable)); +} + +_MTL_INLINE MTL::TextureSparseTier MTL::Texture::sparseTextureTier() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(sparseTextureTier)); +} + +_MTL_INLINE MTL::TextureSwizzleChannels MTL::Texture::swizzle() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(swizzle)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::tailSizeInBytes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(tailSizeInBytes)); +} + +_MTL_INLINE MTL::TextureType MTL::Texture::textureType() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(textureType)); +} + +_MTL_INLINE MTL::TextureUsage MTL::Texture::usage() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(usage)); +} + +_MTL_INLINE NS::UInteger MTL::Texture::width() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(width)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLTextureViewPool.hpp b/thirdparty/metal-cpp/Metal/MTLTextureViewPool.hpp new file mode 100644 index 0000000000..cb7556f56a --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLTextureViewPool.hpp @@ -0,0 +1,59 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLTextureViewPool.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResourceViewPool.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class Buffer; +class Texture; +class TextureDescriptor; +class TextureViewDescriptor; + +class TextureViewPool : public NS::Referencing +{ +public: + ResourceID setTextureView(const MTL::Texture* texture, NS::UInteger index); + ResourceID setTextureView(const MTL::Texture* texture, const MTL::TextureViewDescriptor* descriptor, NS::UInteger index); + ResourceID setTextureViewFromBuffer(const MTL::Buffer* buffer, const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow, NS::UInteger index); +}; + +} +_MTL_INLINE MTL::ResourceID MTL::TextureViewPool::setTextureView(const MTL::Texture* texture, NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureView_atIndex_), texture, index); +} + +_MTL_INLINE MTL::ResourceID MTL::TextureViewPool::setTextureView(const MTL::Texture* texture, const MTL::TextureViewDescriptor* descriptor, NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureView_descriptor_atIndex_), texture, descriptor, index); +} + +_MTL_INLINE MTL::ResourceID MTL::TextureViewPool::setTextureViewFromBuffer(const MTL::Buffer* buffer, const MTL::TextureDescriptor* descriptor, NS::UInteger offset, NS::UInteger bytesPerRow, NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(setTextureViewFromBuffer_descriptor_offset_bytesPerRow_atIndex_), buffer, descriptor, offset, bytesPerRow, index); +} diff --git a/thirdparty/metal-cpp/Metal/MTLTypes.hpp b/thirdparty/metal-cpp/Metal/MTLTypes.hpp new file mode 100644 index 0000000000..c6bbc031fd --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLTypes.hpp @@ -0,0 +1,164 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLTypes.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +struct SamplePosition; + +using Coordinate2D = MTL::SamplePosition; + +struct Origin +{ + Origin() = default; + + Origin(NS::UInteger x, NS::UInteger y, NS::UInteger z); + + static Origin Make(NS::UInteger x, NS::UInteger y, NS::UInteger z); + + NS::UInteger x; + NS::UInteger y; + NS::UInteger z; +} _MTL_PACKED; + +struct Size +{ + Size() = default; + + Size(NS::UInteger width, NS::UInteger height, NS::UInteger depth); + + static Size Make(NS::UInteger width, NS::UInteger height, NS::UInteger depth); + + NS::UInteger width; + NS::UInteger height; + NS::UInteger depth; +} _MTL_PACKED; + +struct Region +{ + Region() = default; + + Region(NS::UInteger x, NS::UInteger width); + + Region(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height); + + Region(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth); + + static Region Make1D(NS::UInteger x, NS::UInteger width); + + static Region Make2D(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height); + + static Region Make3D(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth); + + MTL::Origin origin; + MTL::Size size; +} _MTL_PACKED; + +struct SamplePosition +{ + SamplePosition() = default; + + SamplePosition(float x, float y); + + static SamplePosition Make(float x, float y); + + float x; + float y; +} _MTL_PACKED; + +struct ResourceID +{ + uint64_t _impl; +} _MTL_PACKED; + +} +_MTL_INLINE MTL::Origin::Origin(NS::UInteger x, NS::UInteger y, NS::UInteger z) + : x(x) + , y(y) + , z(z) +{ +} + +_MTL_INLINE MTL::Origin MTL::Origin::Make(NS::UInteger x, NS::UInteger y, NS::UInteger z) +{ + return Origin(x, y, z); +} + +_MTL_INLINE MTL::Size::Size(NS::UInteger width, NS::UInteger height, NS::UInteger depth) + : width(width) + , height(height) + , depth(depth) +{ +} + +_MTL_INLINE MTL::Size MTL::Size::Make(NS::UInteger width, NS::UInteger height, NS::UInteger depth) +{ + return Size(width, height, depth); +} + +_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger width) + : origin(x, 0, 0) + , size(width, 1, 1) +{ +} + +_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height) + : origin(x, y, 0) + , size(width, height, 1) +{ +} + +_MTL_INLINE MTL::Region::Region(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth) + : origin(x, y, z) + , size(width, height, depth) +{ +} + +_MTL_INLINE MTL::Region MTL::Region::Make1D(NS::UInteger x, NS::UInteger width) +{ + return Region(x, width); +} + +_MTL_INLINE MTL::Region MTL::Region::Make2D(NS::UInteger x, NS::UInteger y, NS::UInteger width, NS::UInteger height) +{ + return Region(x, y, width, height); +} + +_MTL_INLINE MTL::Region MTL::Region::Make3D(NS::UInteger x, NS::UInteger y, NS::UInteger z, NS::UInteger width, NS::UInteger height, NS::UInteger depth) +{ + return Region(x, y, z, width, height, depth); +} + +_MTL_INLINE MTL::SamplePosition::SamplePosition(float x, float y) + : x(x) + , y(y) +{ +} + +_MTL_INLINE MTL::SamplePosition MTL::SamplePosition::Make(float x, float y) +{ + return SamplePosition(x, y); +} diff --git a/thirdparty/metal-cpp/Metal/MTLVersion.hpp b/thirdparty/metal-cpp/Metal/MTLVersion.hpp new file mode 100644 index 0000000000..d350397248 --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLVersion.hpp @@ -0,0 +1,32 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLVersion.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define METALCPP_VERSION_MAJOR 370 +#define METALCPP_VERSION_MINOR 63 +#define METALCPP_VERSION_PATCH 1 + +#define METALCPP_SUPPORTS_VERSION(major, minor, patch) \ + ((major < METALCPP_VERSION_MAJOR) || \ + (major == METALCPP_VERSION_MAJOR && minor < METALCPP_VERSION_MINOR) || \ + (major == METALCPP_VERSION_MAJOR && minor == METALCPP_VERSION_MINOR && patch <= METALCPP_VERSION_PATCH)) diff --git a/thirdparty/metal-cpp/Metal/MTLVertexDescriptor.hpp b/thirdparty/metal-cpp/Metal/MTLVertexDescriptor.hpp new file mode 100644 index 0000000000..4a38f3bc6b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLVertexDescriptor.hpp @@ -0,0 +1,326 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLVertexDescriptor.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" + +namespace MTL +{ +class VertexAttributeDescriptor; +class VertexAttributeDescriptorArray; +class VertexBufferLayoutDescriptor; +class VertexBufferLayoutDescriptorArray; +class VertexDescriptor; +_MTL_ENUM(NS::UInteger, VertexFormat) { + VertexFormatInvalid = 0, + VertexFormatUChar2 = 1, + VertexFormatUChar3 = 2, + VertexFormatUChar4 = 3, + VertexFormatChar2 = 4, + VertexFormatChar3 = 5, + VertexFormatChar4 = 6, + VertexFormatUChar2Normalized = 7, + VertexFormatUChar3Normalized = 8, + VertexFormatUChar4Normalized = 9, + VertexFormatChar2Normalized = 10, + VertexFormatChar3Normalized = 11, + VertexFormatChar4Normalized = 12, + VertexFormatUShort2 = 13, + VertexFormatUShort3 = 14, + VertexFormatUShort4 = 15, + VertexFormatShort2 = 16, + VertexFormatShort3 = 17, + VertexFormatShort4 = 18, + VertexFormatUShort2Normalized = 19, + VertexFormatUShort3Normalized = 20, + VertexFormatUShort4Normalized = 21, + VertexFormatShort2Normalized = 22, + VertexFormatShort3Normalized = 23, + VertexFormatShort4Normalized = 24, + VertexFormatHalf2 = 25, + VertexFormatHalf3 = 26, + VertexFormatHalf4 = 27, + VertexFormatFloat = 28, + VertexFormatFloat2 = 29, + VertexFormatFloat3 = 30, + VertexFormatFloat4 = 31, + VertexFormatInt = 32, + VertexFormatInt2 = 33, + VertexFormatInt3 = 34, + VertexFormatInt4 = 35, + VertexFormatUInt = 36, + VertexFormatUInt2 = 37, + VertexFormatUInt3 = 38, + VertexFormatUInt4 = 39, + VertexFormatInt1010102Normalized = 40, + VertexFormatUInt1010102Normalized = 41, + VertexFormatUChar4Normalized_BGRA = 42, + VertexFormatUChar = 45, + VertexFormatChar = 46, + VertexFormatUCharNormalized = 47, + VertexFormatCharNormalized = 48, + VertexFormatUShort = 49, + VertexFormatShort = 50, + VertexFormatUShortNormalized = 51, + VertexFormatShortNormalized = 52, + VertexFormatHalf = 53, + VertexFormatFloatRG11B10 = 54, + VertexFormatFloatRGB9E5 = 55, +}; + +_MTL_ENUM(NS::UInteger, VertexStepFunction) { + VertexStepFunctionConstant = 0, + VertexStepFunctionPerVertex = 1, + VertexStepFunctionPerInstance = 2, + VertexStepFunctionPerPatch = 3, + VertexStepFunctionPerPatchControlPoint = 4, +}; + +static const NS::UInteger BufferLayoutStrideDynamic = NS::UIntegerMax; + +class VertexBufferLayoutDescriptor : public NS::Copying +{ +public: + static VertexBufferLayoutDescriptor* alloc(); + + VertexBufferLayoutDescriptor* init(); + + void setStepFunction(MTL::VertexStepFunction stepFunction); + + void setStepRate(NS::UInteger stepRate); + + void setStride(NS::UInteger stride); + + VertexStepFunction stepFunction() const; + + NS::UInteger stepRate() const; + + NS::UInteger stride() const; +}; +class VertexBufferLayoutDescriptorArray : public NS::Referencing +{ +public: + static VertexBufferLayoutDescriptorArray* alloc(); + + VertexBufferLayoutDescriptorArray* init(); + + VertexBufferLayoutDescriptor* object(NS::UInteger index); + void setObject(const MTL::VertexBufferLayoutDescriptor* bufferDesc, NS::UInteger index); +}; +class VertexAttributeDescriptor : public NS::Copying +{ +public: + static VertexAttributeDescriptor* alloc(); + + NS::UInteger bufferIndex() const; + + VertexFormat format() const; + + VertexAttributeDescriptor* init(); + + NS::UInteger offset() const; + + void setBufferIndex(NS::UInteger bufferIndex); + + void setFormat(MTL::VertexFormat format); + + void setOffset(NS::UInteger offset); +}; +class VertexAttributeDescriptorArray : public NS::Referencing +{ +public: + static VertexAttributeDescriptorArray* alloc(); + + VertexAttributeDescriptorArray* init(); + + VertexAttributeDescriptor* object(NS::UInteger index); + void setObject(const MTL::VertexAttributeDescriptor* attributeDesc, NS::UInteger index); +}; +class VertexDescriptor : public NS::Copying +{ +public: + static VertexDescriptor* alloc(); + + VertexAttributeDescriptorArray* attributes() const; + + VertexDescriptor* init(); + + VertexBufferLayoutDescriptorArray* layouts() const; + + void reset(); + + static VertexDescriptor* vertexDescriptor(); +}; + +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexBufferLayoutDescriptor)); +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStepFunction(MTL::VertexStepFunction stepFunction) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStepFunction_), stepFunction); +} + +_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStepRate(NS::UInteger stepRate) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStepRate_), stepRate); +} + +_MTL_INLINE void MTL::VertexBufferLayoutDescriptor::setStride(NS::UInteger stride) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setStride_), stride); +} + +_MTL_INLINE MTL::VertexStepFunction MTL::VertexBufferLayoutDescriptor::stepFunction() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stepFunction)); +} + +_MTL_INLINE NS::UInteger MTL::VertexBufferLayoutDescriptor::stepRate() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stepRate)); +} + +_MTL_INLINE NS::UInteger MTL::VertexBufferLayoutDescriptor::stride() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(stride)); +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexBufferLayoutDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexBufferLayoutDescriptorArray)); +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexBufferLayoutDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptor* MTL::VertexBufferLayoutDescriptorArray::object(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index); +} + +_MTL_INLINE void MTL::VertexBufferLayoutDescriptorArray::setObject(const MTL::VertexBufferLayoutDescriptor* bufferDesc, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), bufferDesc, index); +} + +_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexAttributeDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::VertexAttributeDescriptor::bufferIndex() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(bufferIndex)); +} + +_MTL_INLINE MTL::VertexFormat MTL::VertexAttributeDescriptor::format() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(format)); +} + +_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE NS::UInteger MTL::VertexAttributeDescriptor::offset() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(offset)); +} + +_MTL_INLINE void MTL::VertexAttributeDescriptor::setBufferIndex(NS::UInteger bufferIndex) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setBufferIndex_), bufferIndex); +} + +_MTL_INLINE void MTL::VertexAttributeDescriptor::setFormat(MTL::VertexFormat format) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFormat_), format); +} + +_MTL_INLINE void MTL::VertexAttributeDescriptor::setOffset(NS::UInteger offset) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setOffset_), offset); +} + +_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexAttributeDescriptorArray::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexAttributeDescriptorArray)); +} + +_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexAttributeDescriptorArray::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::VertexAttributeDescriptor* MTL::VertexAttributeDescriptorArray::object(NS::UInteger index) +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), index); +} + +_MTL_INLINE void MTL::VertexAttributeDescriptorArray::setObject(const MTL::VertexAttributeDescriptor* attributeDesc, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attributeDesc, index); +} + +_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVertexDescriptor)); +} + +_MTL_INLINE MTL::VertexAttributeDescriptorArray* MTL::VertexDescriptor::attributes() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(attributes)); +} + +_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE MTL::VertexBufferLayoutDescriptorArray* MTL::VertexDescriptor::layouts() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(layouts)); +} + +_MTL_INLINE void MTL::VertexDescriptor::reset() +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(reset)); +} + +_MTL_INLINE MTL::VertexDescriptor* MTL::VertexDescriptor::vertexDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLVertexDescriptor), _MTL_PRIVATE_SEL(vertexDescriptor)); +} diff --git a/thirdparty/metal-cpp/Metal/MTLVisibleFunctionTable.hpp b/thirdparty/metal-cpp/Metal/MTLVisibleFunctionTable.hpp new file mode 100644 index 0000000000..de144ea2bb --- /dev/null +++ b/thirdparty/metal-cpp/Metal/MTLVisibleFunctionTable.hpp @@ -0,0 +1,96 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/MTLVisibleFunctionTable.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +#include "../Foundation/Foundation.hpp" +#include "MTLDefines.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLPrivate.hpp" +#include "MTLResource.hpp" +#include "MTLTypes.hpp" + +namespace MTL +{ +class FunctionHandle; +class VisibleFunctionTableDescriptor; + +class VisibleFunctionTableDescriptor : public NS::Copying +{ +public: + static VisibleFunctionTableDescriptor* alloc(); + + NS::UInteger functionCount() const; + + VisibleFunctionTableDescriptor* init(); + + void setFunctionCount(NS::UInteger functionCount); + + static VisibleFunctionTableDescriptor* visibleFunctionTableDescriptor(); +}; +class VisibleFunctionTable : public NS::Referencing +{ +public: + ResourceID gpuResourceID() const; + + void setFunction(const MTL::FunctionHandle* function, NS::UInteger index); + void setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range); +}; + +} +_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::alloc() +{ + return NS::Object::alloc(_MTL_PRIVATE_CLS(MTLVisibleFunctionTableDescriptor)); +} + +_MTL_INLINE NS::UInteger MTL::VisibleFunctionTableDescriptor::functionCount() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(functionCount)); +} + +_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::init() +{ + return NS::Object::init(); +} + +_MTL_INLINE void MTL::VisibleFunctionTableDescriptor::setFunctionCount(NS::UInteger functionCount) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctionCount_), functionCount); +} + +_MTL_INLINE MTL::VisibleFunctionTableDescriptor* MTL::VisibleFunctionTableDescriptor::visibleFunctionTableDescriptor() +{ + return Object::sendMessage(_MTL_PRIVATE_CLS(MTLVisibleFunctionTableDescriptor), _MTL_PRIVATE_SEL(visibleFunctionTableDescriptor)); +} + +_MTL_INLINE MTL::ResourceID MTL::VisibleFunctionTable::gpuResourceID() const +{ + return Object::sendMessage(this, _MTL_PRIVATE_SEL(gpuResourceID)); +} + +_MTL_INLINE void MTL::VisibleFunctionTable::setFunction(const MTL::FunctionHandle* function, NS::UInteger index) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunction_atIndex_), function, index); +} + +_MTL_INLINE void MTL::VisibleFunctionTable::setFunctions(const MTL::FunctionHandle* const functions[], NS::Range range) +{ + Object::sendMessage(this, _MTL_PRIVATE_SEL(setFunctions_withRange_), functions, range); +} diff --git a/thirdparty/metal-cpp/Metal/Metal.hpp b/thirdparty/metal-cpp/Metal/Metal.hpp new file mode 100644 index 0000000000..0d89cc044b --- /dev/null +++ b/thirdparty/metal-cpp/Metal/Metal.hpp @@ -0,0 +1,120 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// Metal/Metal.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLAccelerationStructure.hpp" +#include "MTLAccelerationStructureCommandEncoder.hpp" +#include "MTLAccelerationStructureTypes.hpp" +#include "MTLAllocation.hpp" +#include "MTLArgument.hpp" +#include "MTLArgumentEncoder.hpp" +#include "MTLBinaryArchive.hpp" +#include "MTLBlitCommandEncoder.hpp" +#include "MTLBlitPass.hpp" +#include "MTLBuffer.hpp" +#include "MTLCaptureManager.hpp" +#include "MTLCaptureScope.hpp" +#include "MTLCommandBuffer.hpp" +#include "MTLCommandEncoder.hpp" +#include "MTLCommandQueue.hpp" +#include "MTLComputeCommandEncoder.hpp" +#include "MTLComputePass.hpp" +#include "MTLComputePipeline.hpp" +#include "MTLCounters.hpp" +#include "MTLDefines.hpp" +#include "MTLDepthStencil.hpp" +#include "MTLDevice.hpp" +#include "MTLDrawable.hpp" +#include "MTLDynamicLibrary.hpp" +#include "MTLEvent.hpp" +#include "MTLFence.hpp" +#include "MTLFunctionConstantValues.hpp" +#include "MTLFunctionDescriptor.hpp" +#include "MTLFunctionHandle.hpp" +#include "MTLFunctionLog.hpp" +#include "MTLFunctionStitching.hpp" +#include "MTLHeaderBridge.hpp" +#include "MTLHeap.hpp" +#include "MTLIndirectCommandBuffer.hpp" +#include "MTLIndirectCommandEncoder.hpp" +#include "MTLIntersectionFunctionTable.hpp" +#include "MTLIOCommandBuffer.hpp" +#include "MTLIOCommandQueue.hpp" +#include "MTLIOCompressor.hpp" +#include "MTLLibrary.hpp" +#include "MTLLinkedFunctions.hpp" +#include "MTLLogState.hpp" +#include "MTLParallelRenderCommandEncoder.hpp" +#include "MTLPipeline.hpp" +#include "MTLPixelFormat.hpp" +#include "MTLPrivate.hpp" +#include "MTLRasterizationRate.hpp" +#include "MTLRenderCommandEncoder.hpp" +#include "MTLRenderPass.hpp" +#include "MTLRenderPipeline.hpp" +#include "MTLResidencySet.hpp" +#include "MTLResource.hpp" +#include "MTLResourceStateCommandEncoder.hpp" +#include "MTLResourceStatePass.hpp" +#include "MTLSampler.hpp" +#include "MTLStageInputOutputDescriptor.hpp" +#include "MTLTexture.hpp" +#include "MTLTypes.hpp" +#include "MTLVertexDescriptor.hpp" +#include "MTLVisibleFunctionTable.hpp" +#include "MTLVersion.hpp" +#include "MTLTensor.hpp" +#include "MTLResourceViewPool.hpp" +#include "MTLTextureViewPool.hpp" +#include "MTLDataType.hpp" +#include "MTL4ArgumentTable.hpp" +#include "MTL4BinaryFunction.hpp" +#include "MTL4CommandAllocator.hpp" +#include "MTL4CommandBuffer.hpp" +#include "MTL4CommandEncoder.hpp" +#include "MTL4CommandQueue.hpp" +#include "MTL4Counters.hpp" +#include "MTL4RenderPass.hpp" +#include "MTL4RenderCommandEncoder.hpp" +#include "MTL4ComputeCommandEncoder.hpp" +#include "MTL4MachineLearningCommandEncoder.hpp" +#include "MTL4Compiler.hpp" +#include "MTL4CompilerTask.hpp" +#include "MTL4LibraryDescriptor.hpp" +#include "MTL4FunctionDescriptor.hpp" +#include "MTL4LibraryFunctionDescriptor.hpp" +#include "MTL4SpecializedFunctionDescriptor.hpp" +#include "MTL4StitchedFunctionDescriptor.hpp" +#include "MTL4PipelineState.hpp" +#include "MTL4ComputePipeline.hpp" +#include "MTL4RenderPipeline.hpp" +#include "MTL4MachineLearningPipeline.hpp" +#include "MTL4TileRenderPipeline.hpp" +#include "MTL4MeshRenderPipeline.hpp" +#include "MTL4PipelineDataSetSerializer.hpp" +#include "MTL4Archive.hpp" +#include "MTL4CommitFeedback.hpp" +#include "MTL4BinaryFunctionDescriptor.hpp" +#include "MTL4LinkingDescriptor.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTL4FXFrameInterpolator.hpp b/thirdparty/metal-cpp/MetalFX/MTL4FXFrameInterpolator.hpp new file mode 100644 index 0000000000..1c50ec9e94 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTL4FXFrameInterpolator.hpp @@ -0,0 +1,47 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTL4FXFrameInterpolator.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "MTLFXFrameInterpolator.hpp" +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class FrameInterpolator : public NS::Referencing + { + public: + void encodeToCommandBuffer(MTL4::CommandBuffer* commandBuffer); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTL4FX::FrameInterpolator::encodeToCommandBuffer(MTL4::CommandBuffer* commandBuffer) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), commandBuffer ); +} diff --git a/thirdparty/metal-cpp/MetalFX/MTL4FXSpatialScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTL4FXSpatialScaler.hpp new file mode 100644 index 0000000000..8ea8dfdd59 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTL4FXSpatialScaler.hpp @@ -0,0 +1,49 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTL4FXSpatialScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "MTLFXSpatialScaler.hpp" +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class SpatialScaler : public NS::Referencing< SpatialScaler, MTLFX::SpatialScalerBase > + { + public: + void encodeToCommandBuffer( MTL4::CommandBuffer* pCommandBuffer ); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTL4FX::SpatialScaler::encodeToCommandBuffer( MTL4::CommandBuffer* pCommandBuffer ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalDenoisedScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalDenoisedScaler.hpp new file mode 100644 index 0000000000..73014bbc25 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalDenoisedScaler.hpp @@ -0,0 +1,49 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXTemporalDenoisedScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "MTLFXTemporalDenoisedScaler.hpp" +#include "../Metal/Metal.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class TemporalDenoisedScaler : public NS::Referencing< TemporalDenoisedScaler, MTLFX::TemporalDenoisedScalerBase > + { + public: + void encodeToCommandBuffer(MTL4::CommandBuffer* commandBuffer); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTL4FX::TemporalDenoisedScaler::encodeToCommandBuffer( MTL4::CommandBuffer* commandBuffer ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), commandBuffer ); +} diff --git a/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalScaler.hpp new file mode 100644 index 0000000000..3bda5dca8a --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTL4FXTemporalScaler.hpp @@ -0,0 +1,49 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTL4FXTemporalScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "MTLFXTemporalScaler.hpp" +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class TemporalScaler : public NS::Referencing< TemporalScaler, MTLFX::TemporalScalerBase > + { + public: + void encodeToCommandBuffer( MTL4::CommandBuffer* pCommandBuffer ); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTL4FX::TemporalScaler::encodeToCommandBuffer( MTL4::CommandBuffer* pCommandBuffer ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXDefines.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXDefines.hpp new file mode 100644 index 0000000000..320e0aa847 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXDefines.hpp @@ -0,0 +1,41 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXDefines.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "../Foundation/NSDefines.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _MTLFX_EXPORT _NS_EXPORT +#define _MTLFX_EXTERN _NS_EXTERN +#define _MTLFX_INLINE _NS_INLINE +#define _MTLFX_PACKED _NS_PACKED + +#define _MTLFX_CONST( type, name ) _NS_CONST( type, name ) +#define _MTLFX_ENUM( type, name ) _NS_ENUM( type, name ) +#define _MTLFX_OPTIONS( type, name ) _NS_OPTIONS( type, name ) + +#define _MTLFX_VALIDATE_SIZE( mtlfx, name ) _NS_VALIDATE_SIZE( mtlfx, name ) +#define _MTLFX_VALIDATE_ENUM( mtlfx, name ) _NS_VALIDATE_ENUM( mtlfx, name ) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXFrameInterpolator.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXFrameInterpolator.hpp new file mode 100644 index 0000000000..10ff69cbc4 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXFrameInterpolator.hpp @@ -0,0 +1,719 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXFrameInterpolator.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" +#include "MTLFXTemporalScaler.hpp" + +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class TemporalScaler; + class TemporalDenoisedScaler; + class FrameInterpolator; +} + +namespace MTLFX +{ + class FrameInterpolatorDescriptor : public NS::Copying< FrameInterpolatorDescriptor > + { + public: + static FrameInterpolatorDescriptor* alloc(); + FrameInterpolatorDescriptor* init(); + + MTL::PixelFormat colorTextureFormat() const; + void setColorTextureFormat(MTL::PixelFormat colorTextureFormat); + + MTL::PixelFormat outputTextureFormat() const; + void setOutputTextureFormat(MTL::PixelFormat outputTextureFormat); + + MTL::PixelFormat depthTextureFormat() const; + void setDepthTextureFormat(MTL::PixelFormat depthTextureFormat); + + MTL::PixelFormat motionTextureFormat() const; + void setMotionTextureFormat(MTL::PixelFormat motionTextureFormat); + + MTL::PixelFormat uiTextureFormat() const; + void setUITextureFormat(MTL::PixelFormat uiTextureFormat); + + MTLFX::FrameInterpolatableScaler* scaler() const; + void setScaler(MTLFX::FrameInterpolatableScaler* scaler); + + NS::UInteger inputWidth() const; + void setInputWidth( NS::UInteger inputWidth ); + + NS::UInteger inputHeight() const; + void setInputHeight( NS::UInteger inputHeight ); + + NS::UInteger outputWidth() const; + void setOutputWidth( NS::UInteger outputWidth ); + + NS::UInteger outputHeight() const; + void setOutputHeight( NS::UInteger outputHeight ); + + class FrameInterpolator* newFrameInterpolator( const MTL::Device* pDevice) const; + MTL4FX::FrameInterpolator* newFrameInterpolator( const MTL::Device* pDevice, const MTL4::Compiler* pCompiler) const; + + static bool supportsMetal4FX(MTL::Device* device); + static bool supportsDevice(MTL::Device* device); + }; + + class FrameInterpolatorBase : public NS::Referencing + { + public: + MTL::TextureUsage colorTextureUsage() const; + MTL::TextureUsage outputTextureUsage() const; + MTL::TextureUsage depthTextureUsage() const; + MTL::TextureUsage motionTextureUsage() const; + MTL::TextureUsage uiTextureUsage() const; + + MTL::PixelFormat colorTextureFormat() const; + MTL::PixelFormat depthTextureFormat() const; + MTL::PixelFormat motionTextureFormat() const; + MTL::PixelFormat outputTextureFormat() const; + + NS::UInteger inputWidth() const; + NS::UInteger inputHeight() const; + NS::UInteger outputWidth() const; + NS::UInteger outputHeight() const; + MTL::PixelFormat uiTextureFormat() const; + + MTL::Texture* colorTexture() const; + void setColorTexture(MTL::Texture* colorTexture); + + MTL::Texture* prevColorTexture() const; + void setPrevColorTexture(MTL::Texture* prevColorTexture); + + MTL::Texture* depthTexture() const; + void setDepthTexture(MTL::Texture* depthTexture); + + MTL::Texture* motionTexture() const; + void setMotionTexture(MTL::Texture* motionTexture); + + float motionVectorScaleX() const; + void setMotionVectorScaleX(float scaleX); + + float motionVectorScaleY() const; + void setMotionVectorScaleY(float scaleY); + + float deltaTime() const; + void setDeltaTime( float deltaTime ); + + float nearPlane() const; + void setNearPlane( float nearPlane ); + + float farPlane() const; + void setFarPlane( float farPlane ); + + float fieldOfView() const; + void setFieldOfView( float fieldOfView ); + + float aspectRatio() const; + void setAspectRatio( float aspectRatio ); + + MTL::Texture* uiTexture() const; + void setUITexture(MTL::Texture* uiTexture); + + float jitterOffsetX() const; + void setJitterOffsetX( float jitterOffsetX ); + + float jitterOffsetY() const; + void setJitterOffsetY( float jitterOffsetY ); + + bool isUITextureComposited() const; + void setIsUITextureComposited( bool uiTextureComposited ); + + bool shouldResetHistory() const; + void setShouldResetHistory( bool shouldResetHistory ); + + MTL::Texture* outputTexture() const; + void setOutputTexture( MTL::Texture* outputTexture ); + + MTL::Fence* fence() const; + void setFence( MTL::Fence* fence ); + + bool isDepthReversed() const; + void setDepthReversed( bool depthReversed ); + }; + + class FrameInterpolator : public NS::Referencing + { + public: + void encodeToCommandBuffer(MTL::CommandBuffer* commandBuffer); + }; + +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::FrameInterpolatorDescriptor* MTLFX::FrameInterpolatorDescriptor::alloc() +{ + return NS::Object::alloc< FrameInterpolatorDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXFrameInterpolatorDescriptor ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::FrameInterpolatorDescriptor* MTLFX::FrameInterpolatorDescriptor::init() +{ + return NS::Object::init< FrameInterpolatorDescriptor >(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorDescriptor::colorTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setColorTextureFormat( MTL::PixelFormat colorTextureFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTextureFormat_ ), colorTextureFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorDescriptor::outputTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setOutputTextureFormat( MTL::PixelFormat outputTextureFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTextureFormat_ ), outputTextureFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorDescriptor::depthTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setDepthTextureFormat( MTL::PixelFormat depthTextureFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTextureFormat_ ), depthTextureFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorDescriptor::motionTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setMotionTextureFormat( MTL::PixelFormat motionTextureFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTextureFormat_ ), motionTextureFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorDescriptor::uiTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( uiTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setUITextureFormat( MTL::PixelFormat uiTextureFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setUITextureFormat_ ), uiTextureFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::FrameInterpolatableScaler* MTLFX::FrameInterpolatorDescriptor::scaler() const +{ + return NS::Object::sendMessage< MTLFX::FrameInterpolatableScaler* >( this, _MTLFX_PRIVATE_SEL( scaler ) ); +} + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setScaler(MTLFX::FrameInterpolatableScaler* scaler) +{ + NS::Object::sendMessage< void >(this, _MTLFX_PRIVATE_SEL( setScaler_ ), scaler ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorDescriptor::inputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setInputWidth( NS::UInteger inputWidth ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputWidth_ ), inputWidth ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorDescriptor::inputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setInputHeight( NS::UInteger inputHeight ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputHeight_ ), inputHeight ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorDescriptor::outputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setOutputWidth( NS::UInteger outputWidth ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputWidth_ ), outputWidth ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorDescriptor::outputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorDescriptor::setOutputHeight( NS::UInteger outputHeight ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputHeight_ ), outputHeight ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::FrameInterpolator* MTLFX::FrameInterpolatorDescriptor::newFrameInterpolator( const MTL::Device* device ) const +{ + return NS::Object::sendMessage< MTLFX::FrameInterpolator* >( this, _MTLFX_PRIVATE_SEL( newFrameInterpolatorWithDevice_ ), device ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL4FX::FrameInterpolator* MTLFX::FrameInterpolatorDescriptor::newFrameInterpolator( const MTL::Device* device, const MTL4::Compiler* compiler ) const +{ + return NS::Object::sendMessage< MTL4FX::FrameInterpolator* >( this, _MTLFX_PRIVATE_SEL( newFrameInterpolatorWithDevice_compiler_ ), device, compiler ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::FrameInterpolatorDescriptor::supportsMetal4FX(MTL::Device* device) +{ + return NS::Object::sendMessageSafe< bool >( _MTLFX_PRIVATE_CLS(MTLFXFrameInterpolatorDescriptor), _MTLFX_PRIVATE_SEL( supportsMetal4FX_ ), device ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::FrameInterpolatorDescriptor::supportsDevice(MTL::Device* device) +{ + return NS::Object::sendMessageSafe< bool >( _MTLFX_PRIVATE_CLS(MTLFXFrameInterpolatorDescriptor), _MTLFX_PRIVATE_SEL( supportsDevice_ ), device ); +} + + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::FrameInterpolatorBase::colorTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::FrameInterpolatorBase::outputTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::FrameInterpolatorBase::depthTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( depthTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::FrameInterpolatorBase::motionTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( motionTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::FrameInterpolatorBase::uiTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( uiTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorBase::colorTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorBase::depthTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorBase::motionTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorBase::outputTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorBase::inputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorBase::inputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorBase::outputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::FrameInterpolatorBase::outputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::FrameInterpolatorBase::uiTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( uiTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::colorTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setColorTexture(MTL::Texture* colorTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTexture_ ), colorTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::prevColorTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( prevColorTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setPrevColorTexture(MTL::Texture* prevColorTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setPrevColorTexture_ ), prevColorTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::depthTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( depthTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setDepthTexture(MTL::Texture* depthTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTexture_ ), depthTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::motionTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( motionTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setMotionTexture(MTL::Texture* motionTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTexture_ ), motionTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::motionVectorScaleX() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setMotionVectorScaleX(float scaleX) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleX_ ), scaleX ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::motionVectorScaleY() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setMotionVectorScaleY(float scaleY) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleY_ ), scaleY ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::deltaTime() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( deltaTime ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setDeltaTime( float deltaTime ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDeltaTime_ ), deltaTime ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::nearPlane() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( nearPlane ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setNearPlane( float nearPlane ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setNearPlane_ ), nearPlane ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::farPlane() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( farPlane ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setFarPlane( float farPlane ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFarPlane_ ), farPlane ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::fieldOfView() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( fieldOfView ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setFieldOfView( float fieldOfView ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFieldOfView_ ), fieldOfView ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::aspectRatio() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( aspectRatio ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setAspectRatio( float aspectRatio ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setAspectRatio_ ), aspectRatio ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::uiTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( uiTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setUITexture(MTL::Texture* uiTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setUITexture_ ), uiTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::jitterOffsetX() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setJitterOffsetX( float jitterOffsetX ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetX_ ), jitterOffsetX ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::FrameInterpolatorBase::jitterOffsetY() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setJitterOffsetY( float jitterOffsetY ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetY_ ), jitterOffsetY ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::FrameInterpolatorBase::isUITextureComposited() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isUITextureComposited ) ); +} + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setIsUITextureComposited( bool uiTextureComposited ) +{ + NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setIsUITextureComposited_ ), uiTextureComposited ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::FrameInterpolatorBase::shouldResetHistory() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( shouldResetHistory ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setShouldResetHistory(bool shouldResetHistory) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setShouldResetHistory_ ), shouldResetHistory ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::FrameInterpolatorBase::outputTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setOutputTexture(MTL::Texture* outputTexture) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTexture_ ), outputTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Fence* MTLFX::FrameInterpolatorBase::fence() const +{ + return NS::Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setFence(MTL::Fence* fence) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFence_ ), fence ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::FrameInterpolatorBase::isDepthReversed() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isDepthReversed ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolatorBase::setDepthReversed(bool depthReversed) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthReversed_ ), depthReversed ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::FrameInterpolator::encodeToCommandBuffer(MTL::CommandBuffer* commandBuffer) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), commandBuffer ); +} diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXPrivate.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXPrivate.hpp new file mode 100644 index 0000000000..21fd728e40 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXPrivate.hpp @@ -0,0 +1,482 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXPrivate.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _MTLFX_PRIVATE_CLS( symbol ) ( MTLFX::Private::Class::s_k##symbol ) +#define _MTLFX_PRIVATE_SEL( accessor ) ( MTLFX::Private::Selector::s_k##accessor ) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#if defined( MTLFX_PRIVATE_IMPLEMENTATION ) + +#if defined( METALCPP_SYMBOL_VISIBILITY_HIDDEN ) +#define _MTLFX_PRIVATE_VISIBILITY __attribute__( ( visibility("hidden" ) ) ) +#else +#define _MTLFX_PRIVATE_VISIBILITY __attribute__( ( visibility("default" ) ) ) +#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN + +#define _MTLFX_PRIVATE_IMPORT __attribute__( ( weak_import ) ) + +#ifdef __OBJC__ +#define _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol ) ( ( __bridge void* ) objc_lookUpClass( #symbol ) ) +#define _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol ) ( ( __bridge void* ) objc_getProtocol( #symbol ) ) +#else +#define _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol ) objc_lookUpClass(#symbol) +#define _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol ) objc_getProtocol(#symbol) +#endif // __OBJC__ + +#define _MTLFX_PRIVATE_DEF_CLS( symbol ) void* s_k##symbol _MTLFX_PRIVATE_VISIBILITY = _MTLFX_PRIVATE_OBJC_LOOKUP_CLASS( symbol ) +#define _MTLFX_PRIVATE_DEF_PRO( symbol ) void* s_k##symbol _MTLFX_PRIVATE_VISIBILITY = _MTLFX_PRIVATE_OBJC_GET_PROTOCOL( symbol ) +#define _MTLFX_PRIVATE_DEF_SEL( accessor, symbol ) SEL s_k##accessor _MTLFX_PRIVATE_VISIBILITY = sel_registerName( symbol ) + +#include +#define MTLFX_DEF_FUNC( name, signature ) using Fn##name = signature; \ + Fn##name name = reinterpret_cast< Fn##name >( dlsym( RTLD_DEFAULT, #name ) ) + +namespace MTLFX::Private +{ + template + + inline _Type const LoadSymbol(const char* pSymbol) + { + const _Type* pAddress = static_cast<_Type*>(dlsym(RTLD_DEFAULT, pSymbol)); + + return pAddress ? *pAddress : nullptr; + } +} // MTLFX::Private + +#if defined(__MAC_26_0) || defined(__IPHONE_26_0) || defined(__TVOS_26_0) + +#define _MTLFX_PRIVATE_DEF_STR( type, symbol ) \ + _MTLFX_EXTERN type const MTLFX##symbol _MTLFX_PRIVATE_IMPORT; \ + type const MTLFX::symbol = ( nullptr != &MTLFX##symbol ) ? MTLFX##ssymbol : nullptr + +#define _MTLFX_PRIVATE_DEF_CONST( type, symbol ) \ + _MTLFX_EXTERN type const MTLFX##ssymbol _MTLFX_PRIVATE_IMPORT; \ + type const MTLFX::symbol = (nullptr != &MTLFX##ssymbol) ? MTLFX##ssymbol : nullptr + +#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol ) \ + _MTLFX_EXTERN type const MTLFX##ssymbol; \ + type const MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol ) + +#else + +#define _MTLFX_PRIVATE_DEF_STR( type, symbol ) \ + _MTLFX_EXTERN type const MTLFX##ssymbol; \ + type const MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol ) + +#define _MTLFX_PRIVATE_DEF_CONST( type, symbol ) \ + _MTLFX_EXTERN type const MTLFX##ssymbol; \ + type const MTLFX::symbol = Private::LoadSymbol< type >( "MTLFX" #symbol ) + +#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol ) _MTLFX_PRIVATE_DEF_CONST( type, symbol ) + +#endif + +#else + +#define _MTLFX_PRIVATE_DEF_CLS( symbol ) extern void* s_k##symbol +#define _MTLFX_PRIVATE_DEF_PRO( symbol ) extern void* s_k##symbol +#define _MTLFX_PRIVATE_DEF_SEL( accessor, symbol ) extern SEL s_k##accessor +#define _MTLFX_PRIVATE_DEF_STR( type, symbol ) extern type const MTLFX::symbol +#define _MTLFX_PRIVATE_DEF_CONST( type, symbol ) extern type const MTLFX::symbol +#define _MTLFX_PRIVATE_DEF_WEAK_CONST( type, symbol ) extern type const MTLFX::symbol + +#endif // MTLFX_PRIVATE_IMPLEMENTATION + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTLFX +{ + namespace Private + { + namespace Class + { + _MTLFX_PRIVATE_DEF_CLS( MTLFXSpatialScalerDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTLFXTemporalScalerDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTLFXFrameInterpolatorDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTLFXTemporalDenoisedScalerDescriptor ); + + _MTLFX_PRIVATE_DEF_CLS( MTL4FXSpatialScalerDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTL4FXTemporalScalerDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTL4FXFrameInterpolatorDescriptor ); + _MTLFX_PRIVATE_DEF_CLS( MTL4FXTemporalDenoisedScalerDescriptor ); + } // Class + } // Private +} // MTLFX + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTLFX +{ + namespace Private + { + namespace Protocol + { + _MTLFX_PRIVATE_DEF_PRO( MTLFXSpatialScaler ); + _MTLFX_PRIVATE_DEF_PRO( MTLFXTemporalScaler ); + } // Protocol + } // Private +} // MTLFX + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTLFX +{ + namespace Private + { + namespace Selector + { + _MTLFX_PRIVATE_DEF_SEL( aspectRatio, + "aspectRatio" ); + _MTLFX_PRIVATE_DEF_SEL( colorProcessingMode, + "colorProcessingMode" ); + _MTLFX_PRIVATE_DEF_SEL( colorTexture, + "colorTexture" ); + _MTLFX_PRIVATE_DEF_SEL( colorTextureFormat, + "colorTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( colorTextureUsage, + "colorTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( deltaTime, + "deltaTime" ); + _MTLFX_PRIVATE_DEF_SEL( denoiseStrengthMaskTexture, + "denoiseStrengthMaskTexture" ); + _MTLFX_PRIVATE_DEF_SEL( denoiseStrengthMaskTextureFormat, + "denoiseStrengthMaskTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( denoiseStrengthMaskTextureUsage, + "denoiseStrengthMaskTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( depthTexture, + "depthTexture" ); + _MTLFX_PRIVATE_DEF_SEL( depthTextureFormat, + "depthTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( depthTextureUsage, + "depthTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( diffuseAlbedoTexture, + "diffuseAlbedoTexture" ); + _MTLFX_PRIVATE_DEF_SEL( diffuseAlbedoTextureFormat, + "diffuseAlbedoTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( diffuseAlbedoTextureUsage, + "diffuseAlbedoTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( encodeToCommandBuffer_, + "encodeToCommandBuffer:" ); + _MTLFX_PRIVATE_DEF_SEL( exposureTexture, + "exposureTexture" ); + _MTLFX_PRIVATE_DEF_SEL( farPlane, + "farPlane" ); + _MTLFX_PRIVATE_DEF_SEL( fence, + "fence" ); + _MTLFX_PRIVATE_DEF_SEL( fieldOfView, + "fieldOfView" ); + _MTLFX_PRIVATE_DEF_SEL( height, + "height" ); + _MTLFX_PRIVATE_DEF_SEL( inputContentHeight, + "inputContentHeight" ); + _MTLFX_PRIVATE_DEF_SEL( inputContentMaxScale, + "inputContentMaxScale" ); + _MTLFX_PRIVATE_DEF_SEL( inputContentMinScale, + "inputContentMinScale" ); + _MTLFX_PRIVATE_DEF_SEL( inputContentWidth, + "inputContentWidth" ); + _MTLFX_PRIVATE_DEF_SEL( inputHeight, + "inputHeight" ); + _MTLFX_PRIVATE_DEF_SEL( inputWidth, + "inputWidth" ); + _MTLFX_PRIVATE_DEF_SEL( isAutoExposureEnabled, + "isAutoExposureEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isDenoiseStrengthMaskTextureEnabled, + "isDenoiseStrengthMaskTextureEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isDepthReversed, + "isDepthReversed" ); + _MTLFX_PRIVATE_DEF_SEL( isInputContentPropertiesEnabled, + "isInputContentPropertiesEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isTransparencyOverlayTextureEnabled, + "isTransparencyOverlayTextureEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isReactiveMaskTextureEnabled, + "isReactiveMaskTextureEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isSpecularHitDistanceTextureEnabled, + "isSpecularHitDistanceTextureEnabled" ); + _MTLFX_PRIVATE_DEF_SEL( isUITextureComposited, + "isUITextureComposited" ); + _MTLFX_PRIVATE_DEF_SEL( jitterOffsetX, + "jitterOffsetX" ); + _MTLFX_PRIVATE_DEF_SEL( jitterOffsetY, + "jitterOffsetY" ); + _MTLFX_PRIVATE_DEF_SEL( maskTexture, + "maskTexture" ); + _MTLFX_PRIVATE_DEF_SEL( maskTextureFormat, + "maskTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( maskTextureUsage, + "maskTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( motionTexture, + "motionTexture" ); + _MTLFX_PRIVATE_DEF_SEL( motionTextureFormat, + "motionTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( motionTextureUsage, + "motionTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( motionVectorScaleX, + "motionVectorScaleX" ); + _MTLFX_PRIVATE_DEF_SEL( motionVectorScaleY, + "motionVectorScaleY" ); + _MTLFX_PRIVATE_DEF_SEL( nearPlane, + "nearPlane" ); + _MTLFX_PRIVATE_DEF_SEL( newFrameInterpolatorWithDevice_, + "newFrameInterpolatorWithDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( newFrameInterpolatorWithDevice_compiler_, + "newFrameInterpolatorWithDevice:compiler:" ); + _MTLFX_PRIVATE_DEF_SEL( newTemporalDenoisedScalerWithDevice_, + "newTemporalDenoisedScalerWithDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( newTemporalDenoisedScalerWithDevice_compiler_, + "newTemporalDenoisedScalerWithDevice:compiler:" ); + _MTLFX_PRIVATE_DEF_SEL( newSpatialScalerWithDevice_, + "newSpatialScalerWithDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( newSpatialScalerWithDevice_compiler_, + "newSpatialScalerWithDevice:compiler:" ); + _MTLFX_PRIVATE_DEF_SEL( newTemporalScalerWithDevice_, + "newTemporalScalerWithDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( newTemporalScalerWithDevice_compiler_, + "newTemporalScalerWithDevice:compiler:" ); + _MTLFX_PRIVATE_DEF_SEL( normalTexture, + "normalTexture" ); + _MTLFX_PRIVATE_DEF_SEL( normalTextureFormat, + "normalTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( normalTextureUsage, + "normalTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( outputHeight, + "outputHeight" ); + _MTLFX_PRIVATE_DEF_SEL( outputTexture, + "outputTexture" ); + _MTLFX_PRIVATE_DEF_SEL( outputTextureFormat, + "outputTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( outputTextureUsage, + "outputTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( outputWidth, + "outputWidth" ); + _MTLFX_PRIVATE_DEF_SEL( preExposure, + "preExposure" ); + _MTLFX_PRIVATE_DEF_SEL( transparencyOverlayTextureFormat, + "transparencyOverlayTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( transparencyOverlayTextureUsage, + "transparencyOverlayTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( prevColorTexture, + "prevColorTexture" ); + _MTLFX_PRIVATE_DEF_SEL( reactiveMaskTextureFormat, + "reactiveMaskTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( reactiveTextureUsage, + "reactiveTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( reactiveMaskTexture, + "reactiveMaskTexture" ); + _MTLFX_PRIVATE_DEF_SEL( reset, + "reset" ); + _MTLFX_PRIVATE_DEF_SEL( requiresSynchronousInitialization, + "requiresSynchronousInitialization" ); + _MTLFX_PRIVATE_DEF_SEL( roughnessTextureFormat, + "roughnessTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( roughnessTextureUsage, + "roughnessTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( scaler, + "scaler" ); + _MTLFX_PRIVATE_DEF_SEL( scaler4, + "scaler4" ); + _MTLFX_PRIVATE_DEF_SEL( setAspectRatio_, + "setAspectRatio:" ); + _MTLFX_PRIVATE_DEF_SEL( setAutoExposureEnabled_, + "setAutoExposureEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setColorProcessingMode_, + "setColorProcessingMode:" ); + _MTLFX_PRIVATE_DEF_SEL( setColorTexture_, + "setColorTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setColorTextureFormat_, + "setColorTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setDeltaTime_, + "setDeltaTime:" ); + _MTLFX_PRIVATE_DEF_SEL( setDenoiseStrengthMaskTexture_, + "setDenoiseStrengthMaskTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setDenoiseStrengthMaskTextureEnabled_, + "setDenoiseStrengthMaskTextureEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setDenoiseStrengthMaskTextureFormat_, + "setDenoiseStrengthMaskTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setDepthInverted_, + "setDepthInverted:" ); + _MTLFX_PRIVATE_DEF_SEL( setDepthReversed_, + "setDepthReversed:" ); + _MTLFX_PRIVATE_DEF_SEL( setDepthTexture_, + "setDepthTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setDepthTextureFormat_, + "setDepthTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setDiffuseAlbedoTexture_, + "setDiffuseAlbedoTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setDiffuseAlbedoTextureFormat_, + "setDiffuseAlbedoTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setExposureTexture_, + "setExposureTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setFarPlane_, + "setFarPlane:" ); + _MTLFX_PRIVATE_DEF_SEL( setFence_, + "setFence:" ); + _MTLFX_PRIVATE_DEF_SEL( setFieldOfView_, + "setFieldOfView:" ); + _MTLFX_PRIVATE_DEF_SEL( setHeight_, + "setHeight:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputContentHeight_, + "setInputContentHeight:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputContentMaxScale_, + "setInputContentMaxScale:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputContentMinScale_, + "setInputContentMinScale:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputContentPropertiesEnabled_, + "setInputContentPropertiesEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputContentWidth_, + "setInputContentWidth:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputHeight_, + "setInputHeight:" ); + _MTLFX_PRIVATE_DEF_SEL( setInputWidth_, + "setInputWidth:" ); + _MTLFX_PRIVATE_DEF_SEL( setIsUITextureComposited_, + "setIsUITextureComposited:" ); + _MTLFX_PRIVATE_DEF_SEL( setJitterOffsetX_, + "setJitterOffsetX:" ); + _MTLFX_PRIVATE_DEF_SEL( setJitterOffsetY_, + "setJitterOffsetY:" ); + _MTLFX_PRIVATE_DEF_SEL( setNearPlane_, + "setNearPlane:" ); + _MTLFX_PRIVATE_DEF_SEL( setMaskTexture_, + "setMaskTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setMaskTextureFormat_, + "setMaskTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setMotionTexture_, + "setMotionTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setMotionTextureFormat_, + "setMotionTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setMotionVectorScaleX_, + "setMotionVectorScaleX:" ); + _MTLFX_PRIVATE_DEF_SEL( setMotionVectorScaleY_, + "setMotionVectorScaleY:" ); + _MTLFX_PRIVATE_DEF_SEL( setNormalTexture_, + "setNormalTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setNormalTextureFormat_, + "setNormalTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setOutputHeight_, + "setOutputHeight:" ); + _MTLFX_PRIVATE_DEF_SEL( setOutputTexture_, + "setOutputTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setOutputTextureFormat_, + "setOutputTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setOutputWidth_, + "setOutputWidth:" ); + _MTLFX_PRIVATE_DEF_SEL( transparencyOverlayTexture, + "transparencyOverlayTexture" ); + _MTLFX_PRIVATE_DEF_SEL( setTransparencyOverlayTexture_, + "setTransparencyOverlayTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setTransparencyOverlayTextureEnabled_, + "setTransparencyOverlayTextureEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setPreExposure_, + "setPreExposure:" ); + _MTLFX_PRIVATE_DEF_SEL( setTransparencyOverlayTextureFormat_, + "setTransparencyOverlayTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setPrevColorTexture_, + "setPrevColorTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setReactiveMaskTexture_, + "setReactiveMaskTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setReactiveMaskTextureEnabled_, + "setReactiveMaskTextureEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setReactiveMaskTextureFormat_, + "setReactiveMaskTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setRequiresSynchronousInitialization_, + "setRequiresSynchronousInitialization:" ); + _MTLFX_PRIVATE_DEF_SEL( setReset_, + "setReset:" ); + _MTLFX_PRIVATE_DEF_SEL( roughnessTexture, + "roughnessTexture" ); + _MTLFX_PRIVATE_DEF_SEL( setRoughnessTexture_, + "setRoughnessTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setRoughnessTextureFormat_, + "setRoughnessTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setScaler_, + "setScaler:" ); + _MTLFX_PRIVATE_DEF_SEL( setShouldResetHistory_, + "setShouldResetHistory:" ); + _MTLFX_PRIVATE_DEF_SEL( specularHitDistanceTexture, + "specularHitDistanceTexture" ); + _MTLFX_PRIVATE_DEF_SEL( setSpecularHitDistanceTexture_, + "setSpecularHitDistanceTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setSpecularHitDistanceTextureEnabled_, + "setSpecularHitDistanceTextureEnabled:" ); + _MTLFX_PRIVATE_DEF_SEL( setSpecularAlbedoTexture_, + "setSpecularAlbedoTexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setSpecularAlbedoTextureFormat_, + "setSpecularAlbedoTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setSpecularHitDistanceTextureFormat_, + "setSpecularHitDistanceTextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setUITexture_, + "setUITexture:" ); + _MTLFX_PRIVATE_DEF_SEL( setUITextureFormat_, + "setUITextureFormat:" ); + _MTLFX_PRIVATE_DEF_SEL( setViewToClipMatrix_, + "setViewToClipMatrix:" ); + _MTLFX_PRIVATE_DEF_SEL( setWidth_, + "setWidth:" ); + _MTLFX_PRIVATE_DEF_SEL( setWorldToViewMatrix_, + "setWorldToViewMatrix:" ); + _MTLFX_PRIVATE_DEF_SEL( shouldResetHistory, + "shouldResetHistory" ); + _MTLFX_PRIVATE_DEF_SEL( specularAlbedoTexture, + "specularAlbedoTexture" ); + _MTLFX_PRIVATE_DEF_SEL( specularAlbedoTextureFormat, + "specularAlbedoTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( specularAlbedoTextureUsage, + "specularAlbedoTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( specularHitDistanceTextureFormat, + "specularHitDistanceTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( specularHitDistanceTextureUsage, + "specularHitDistanceTextureUsage" ); + _MTLFX_PRIVATE_DEF_SEL( supportedInputContentMaxScaleForDevice_, + "supportedInputContentMaxScaleForDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( supportedInputContentMinScaleForDevice_, + "supportedInputContentMinScaleForDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( supportsDevice_, + "supportsDevice:" ); + _MTLFX_PRIVATE_DEF_SEL( supportsMetal4FX_, + "supportsMetal4FX:" ); + _MTLFX_PRIVATE_DEF_SEL( uiTexture, + "uiTexture" ); + _MTLFX_PRIVATE_DEF_SEL( uiTextureFormat, + "uiTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( uiTextureUsage, + "uiTextureFormat" ); + _MTLFX_PRIVATE_DEF_SEL( viewToClipMatrix, + "viewToClipMatrix" ); + _MTLFX_PRIVATE_DEF_SEL( width, + "width" ); + _MTLFX_PRIVATE_DEF_SEL( worldToViewMatrix, + "worldToViewMatrix" ); + } // Selector + } // Private +} // MTLFX + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXSpatialScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXSpatialScaler.hpp new file mode 100644 index 0000000000..cb1186ed89 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXSpatialScaler.hpp @@ -0,0 +1,397 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXSpatialScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class SpatialScaler; +} + +namespace MTLFX +{ + _MTLFX_ENUM( NS::Integer, SpatialScalerColorProcessingMode ) + { + SpatialScalerColorProcessingModePerceptual = 0, + SpatialScalerColorProcessingModeLinear = 1, + SpatialScalerColorProcessingModeHDR = 2 + }; + + class SpatialScalerDescriptor : public NS::Copying< SpatialScalerDescriptor > + { + public: + static class SpatialScalerDescriptor* alloc(); + class SpatialScalerDescriptor* init(); + + MTL::PixelFormat colorTextureFormat() const; + void setColorTextureFormat( MTL::PixelFormat format ); + + MTL::PixelFormat outputTextureFormat() const; + void setOutputTextureFormat( MTL::PixelFormat format ); + + NS::UInteger inputWidth() const; + void setInputWidth( NS::UInteger width ); + + NS::UInteger inputHeight() const; + void setInputHeight( NS::UInteger height ); + + NS::UInteger outputWidth() const; + void setOutputWidth( NS::UInteger width ); + + NS::UInteger outputHeight() const; + void setOutputHeight( NS::UInteger height ); + + SpatialScalerColorProcessingMode colorProcessingMode() const; + void setColorProcessingMode( SpatialScalerColorProcessingMode mode ); + + class SpatialScaler* newSpatialScaler( const MTL::Device* pDevice ) const; + MTL4FX::SpatialScaler* newSpatialScaler( const MTL::Device* pDevice, const MTL4::Compiler* pCompiler ) const; + + static bool supportsDevice( const MTL::Device* pDevice); + static bool supportsMetal4FX( const MTL::Device* pDevice ); + }; + + class SpatialScalerBase : public NS::Referencing< SpatialScaler > + { + public: + MTL::TextureUsage colorTextureUsage() const; + MTL::TextureUsage outputTextureUsage() const; + + NS::UInteger inputContentWidth() const; + void setInputContentWidth( NS::UInteger width ); + + NS::UInteger inputContentHeight() const; + void setInputContentHeight( NS::UInteger height ); + + MTL::Texture* colorTexture() const; + void setColorTexture( MTL::Texture* pTexture ); + + MTL::Texture* outputTexture() const; + void setOutputTexture( MTL::Texture* pTexture ); + + MTL::PixelFormat colorTextureFormat() const; + MTL::PixelFormat outputTextureFormat() const; + NS::UInteger inputWidth() const; + NS::UInteger inputHeight() const; + NS::UInteger outputWidth() const; + NS::UInteger outputHeight() const; + SpatialScalerColorProcessingMode colorProcessingMode() const; + + MTL::Fence* fence() const; + void setFence( MTL::Fence* pFence ); + }; + + class SpatialScaler : public NS::Referencing< SpatialScaler, SpatialScalerBase > + { + public: + void encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer ); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::SpatialScalerDescriptor* MTLFX::SpatialScalerDescriptor::alloc() +{ + return NS::Object::alloc< SpatialScalerDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXSpatialScalerDescriptor ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::SpatialScalerDescriptor* MTLFX::SpatialScalerDescriptor::init() +{ + return NS::Object::init< SpatialScalerDescriptor >(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerDescriptor::colorTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setColorTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerDescriptor::outputTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::inputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setInputWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::inputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setInputHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::outputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerDescriptor::outputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setOutputHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::SpatialScalerColorProcessingMode MTLFX::SpatialScalerDescriptor::colorProcessingMode() const +{ + return Object::sendMessage< SpatialScalerColorProcessingMode >( this, _MTLFX_PRIVATE_SEL( colorProcessingMode ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerDescriptor::setColorProcessingMode( SpatialScalerColorProcessingMode mode ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorProcessingMode_ ), mode ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::SpatialScaler* MTLFX::SpatialScalerDescriptor::newSpatialScaler( const MTL::Device* pDevice ) const +{ + return Object::sendMessage< SpatialScaler* >( this, _MTLFX_PRIVATE_SEL( newSpatialScalerWithDevice_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL4FX::SpatialScaler* MTLFX::SpatialScalerDescriptor::newSpatialScaler( const MTL::Device* pDevice, const MTL4::Compiler* pCompiler ) const +{ + return Object::sendMessage< MTL4FX::SpatialScaler* >( this, _MTLFX_PRIVATE_SEL( newSpatialScalerWithDevice_compiler_ ), pDevice, pCompiler ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::SpatialScalerDescriptor::supportsDevice( const MTL::Device* pDevice ) +{ + return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXSpatialScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsDevice_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::SpatialScalerDescriptor::supportsMetal4FX( const MTL::Device* pDevice ) +{ + return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXSpatialScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsMetal4FX_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::SpatialScalerBase::colorTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::SpatialScalerBase::outputTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::inputContentWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerBase::setInputContentWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::inputContentHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerBase::setInputContentHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::SpatialScalerBase::colorTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerBase::setColorTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::SpatialScalerBase::outputTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerBase::setOutputTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerBase::colorTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::SpatialScalerBase::outputTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::inputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::inputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::outputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::SpatialScalerBase::outputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::SpatialScalerColorProcessingMode MTLFX::SpatialScalerBase::colorProcessingMode() const +{ + return Object::sendMessage< SpatialScalerColorProcessingMode >( this, _MTLFX_PRIVATE_SEL( colorProcessingMode ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Fence* MTLFX::SpatialScalerBase::fence() const +{ + return Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScalerBase::setFence( MTL::Fence* pFence ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFence_ ), pFence ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::SpatialScaler::encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXTemporalDenoisedScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXTemporalDenoisedScaler.hpp new file mode 100644 index 0000000000..5863e078de --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXTemporalDenoisedScaler.hpp @@ -0,0 +1,1208 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXTemporalDenoisedScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" +#include "MTLFXTemporalScaler.hpp" + +#include "../Metal/Metal.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class TemporalDenoisedScaler; +} + +namespace MTLFX +{ + class TemporalDenoisedScalerDescriptor : public NS::Copying< TemporalDenoisedScalerDescriptor > + { + public: + static class TemporalDenoisedScalerDescriptor* alloc(); + class TemporalDenoisedScalerDescriptor* init(); + + MTL::PixelFormat colorTextureFormat() const; + void setColorTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat depthTextureFormat() const; + void setDepthTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat motionTextureFormat() const; + void setMotionTextureFormat( MTL::PixelFormat pixelFormal ); + + MTL::PixelFormat diffuseAlbedoTextureFormat() const; + void setDiffuseAlbedoTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat specularAlbedoTextureFormat() const; + void setSpecularAlbedoTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat normalTextureFormat() const; + void setNormalTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat roughnessTextureFormat() const; + void setRoughnessTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat specularHitDistanceTextureFormat() const; + void setSpecularHitDistanceTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat denoiseStrengthMaskTextureFormat() const; + void setDenoiseStrengthMaskTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat transparencyOverlayTextureFormat() const; + void setTransparencyOverlayTextureFormat( MTL::PixelFormat pixelFormat ); + + MTL::PixelFormat outputTextureFormat() const; + void setOutputTextureFormat( MTL::PixelFormat pixelFormat ); + + NS::UInteger inputWidth() const; + void setInputWidth( NS::UInteger inputWidth ); + + NS::UInteger inputHeight() const; + void setInputHeight( NS::UInteger inputHeight ); + + NS::UInteger outputWidth() const; + void setOutputWidth( NS::UInteger outputWidth ); + + NS::UInteger outputHeight() const; + void setOutputHeight( NS::UInteger outputHeight ); + + bool requiresSynchronousInitialization() const; + void setRequiresSynchronousInitialization( bool requiresSynchronousInitialization ); + + bool isAutoExposureEnabled() const; + void setAutoExposureEnabled( bool enabled ); + + bool isInputContentPropertiesEnabled() const; + void setInputContentPropertiesEnabled( bool enabled ); + + float inputContentMinScale() const; + void setInputContentMinScale( float inputContentMinScale ); + + float inputContentMaxScale() const; + void setInputContentMaxScale( float inputContentMaxScale ); + + bool isReactiveMaskTextureEnabled() const; + void setReactiveMaskTextureEnabled( bool enabled ); + + MTL::PixelFormat reactiveMaskTextureFormat() const; + void setReactiveMaskTextureFormat( MTL::PixelFormat pixelFormat ); + + bool isSpecularHitDistanceTextureEnabled() const; + void setSpecularHitDistanceTextureEnabled( bool enabled ); + + bool isDenoiseStrengthMaskTextureEnabled() const; + void setDenoiseStrengthMaskTextureEnabled( bool enabled ); + + bool isTransparencyOverlayTextureEnabled() const; + void setTransparencyOverlayTextureEnabled( bool enabled ); + + class TemporalDenoisedScaler* newTemporalDenoisedScaler( const MTL::Device* device ) const; + MTL4FX::TemporalDenoisedScaler* newTemporalDenoisedScaler( const MTL::Device* device, const MTL4::Compiler* compiler) const; + + static float supportedInputContentMinScale(MTL::Device* device); + static float supportedInputContentMaxScale(MTL::Device* device); + + static bool supportsMetal4FX( MTL::Device* device); + static bool supportsDevice( MTL::Device* device); + }; + + class TemporalDenoisedScalerBase : public NS::Referencing< TemporalDenoisedScalerBase, FrameInterpolatableScaler > + { + public: + MTL::TextureUsage colorTextureUsage() const; + MTL::TextureUsage depthTextureUsage() const; + MTL::TextureUsage motionTextureUsage() const; + MTL::TextureUsage reactiveTextureUsage() const; + MTL::TextureUsage diffuseAlbedoTextureUsage() const; + MTL::TextureUsage specularAlbedoTextureUsage() const; + MTL::TextureUsage normalTextureUsage() const; + MTL::TextureUsage roughnessTextureUsage() const; + MTL::TextureUsage specularHitDistanceTextureUsage() const; + MTL::TextureUsage denoiseStrengthMaskTextureUsage() const; + MTL::TextureUsage transparencyOverlayTextureUsage() const; + MTL::TextureUsage outputTextureUsage() const; + + MTL::Texture* colorTexture() const; + void setColorTexture( MTL::Texture* colorTexture ); + + MTL::Texture* depthTexture() const; + void setDepthTexture( MTL::Texture* depthTexture ); + + MTL::Texture* motionTexture() const; + void setMotionTexture( MTL::Texture* motionTexture ); + + MTL::Texture* diffuseAlbedoTexture() const; + void setDiffuseAlbedoTexture( MTL::Texture* diffuseAlbedoTexture ); + + MTL::Texture* specularAlbedoTexture() const; + void setSpecularAlbedoTexture( MTL::Texture* specularAlbedoTexture ); + + MTL::Texture* normalTexture() const; + void setNormalTexture( MTL::Texture* normalTexture ); + + MTL::Texture* roughnessTexture() const; + void setRoughnessTexture( MTL::Texture* roughnessTexture ); + + MTL::Texture* specularHitDistanceTexture() const; + void setSpecularHitDistanceTexture( MTL::Texture* specularHitDistanceTexture ); + + MTL::Texture* denoiseStrengthMaskTexture() const; + void setDenoiseStrengthMaskTexture( MTL::Texture* denoiseStrengthMaskTexture ); + + MTL::Texture* transparencyOverlayTexture() const; + void setTransparencyOverlayTexture( MTL::Texture* transparencyOverlayTexture ); + + MTL::Texture* outputTexture() const; + void setOutputTexture( MTL::Texture* outputTexture ); + + MTL::Texture* exposureTexture() const; + void setExposureTexture( MTL::Texture* exposureTexture ); + + float preExposure() const; + void setPreExposure( float preExposure ); + + MTL::Texture* reactiveMaskTexture() const; + void setReactiveMaskTexture( MTL::Texture* reactiveMaskTexture ); + + float jitterOffsetX() const; + void setJitterOffsetX( float jitterOffsetX ); + + float jitterOffsetY() const; + void setJitterOffsetY( float jitterOffsetY ); + + float motionVectorScaleX() const; + void setMotionVectorScaleX( float motionVectorScaleX ); + + float motionVectorScaleY() const; + void setMotionVectorScaleY( float motionVectorScaleY ); + + bool shouldResetHistory() const; + void setShouldResetHistory( bool shouldResetHistory ); + + bool isDepthReversed() const; + void setDepthReversed( bool depthReversed ); + + MTL::PixelFormat colorTextureFormat() const; + MTL::PixelFormat depthTextureFormat() const; + MTL::PixelFormat motionTextureFormat() const; + MTL::PixelFormat diffuseAlbedoTextureFormat() const; + MTL::PixelFormat specularAlbedoTextureFormat() const; + MTL::PixelFormat normalTextureFormat() const; + MTL::PixelFormat roughnessTextureFormat() const; + MTL::PixelFormat specularHitDistanceTextureFormat() const; + MTL::PixelFormat denoiseStrengthMaskTextureFormat() const; + MTL::PixelFormat transparencyOverlayTextureFormat() const; + MTL::PixelFormat reactiveMaskTextureFormat() const; + MTL::PixelFormat outputTextureFormat() const; + + NS::UInteger inputWidth() const; + NS::UInteger inputHeight() const; + NS::UInteger outputWidth() const; + NS::UInteger outputHeight() const; + float inputContentMinScale() const; + float inputContentMaxScale() const; + + simd::float4x4 worldToViewMatrix() const; + void setWorldToViewMatrix( simd::float4x4 worldToViewMatrix ); + + simd::float4x4 viewToClipMatrix() const; + void setViewToClipMatrix( simd::float4x4 viewToClipMatrix ); + + MTL::Fence* fence() const; + void setFence( MTL::Fence* fence ); + }; + + class TemporalDenoisedScaler : public NS::Referencing< TemporalDenoisedScaler, TemporalDenoisedScalerBase > + { + public: + + void encodeToCommandBuffer(MTL::CommandBuffer* commandBuffer); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalDenoisedScalerDescriptor* MTLFX::TemporalDenoisedScalerDescriptor::alloc() +{ + return NS::Object::alloc< TemporalDenoisedScalerDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXTemporalDenoisedScalerDescriptor ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalDenoisedScalerDescriptor* MTLFX::TemporalDenoisedScalerDescriptor::init() +{ + return NS::Object::init< TemporalDenoisedScalerDescriptor >(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::colorTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setColorTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::depthTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setDepthTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::motionTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setMotionTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::diffuseAlbedoTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( diffuseAlbedoTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setDiffuseAlbedoTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDiffuseAlbedoTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::specularAlbedoTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( specularAlbedoTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setSpecularAlbedoTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setSpecularAlbedoTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::normalTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( normalTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setNormalTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setNormalTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::roughnessTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( roughnessTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setRoughnessTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setRoughnessTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::specularHitDistanceTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( specularHitDistanceTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setSpecularHitDistanceTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setSpecularHitDistanceTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::denoiseStrengthMaskTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( denoiseStrengthMaskTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setDenoiseStrengthMaskTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDenoiseStrengthMaskTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::transparencyOverlayTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( transparencyOverlayTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setTransparencyOverlayTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setTransparencyOverlayTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::outputTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setOutputTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerDescriptor::inputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setInputWidth( NS::UInteger inputWidth ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputWidth_ ), inputWidth ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerDescriptor::inputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setInputHeight( NS::UInteger inputHeight ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputHeight_ ), inputHeight ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerDescriptor::outputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setOutputWidth( NS::UInteger outputWidth ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputWidth_ ), outputWidth ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerDescriptor::outputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setOutputHeight( NS::UInteger outputHeight ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputHeight_ ), outputHeight ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::requiresSynchronousInitialization() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( requiresSynchronousInitialization ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setRequiresSynchronousInitialization( bool requiresSynchronousInitialization ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setRequiresSynchronousInitialization_ ), requiresSynchronousInitialization ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isAutoExposureEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isAutoExposureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setAutoExposureEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setAutoExposureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isInputContentPropertiesEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isInputContentPropertiesEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setInputContentPropertiesEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentPropertiesEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerDescriptor::inputContentMinScale() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setInputContentMinScale( float inputContentMinScale ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentMinScale_ ), inputContentMinScale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerDescriptor::inputContentMaxScale() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setInputContentMaxScale( float inputContentMaxScale ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentMaxScale_ ), inputContentMaxScale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isReactiveMaskTextureEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isReactiveMaskTextureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setReactiveMaskTextureEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTextureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerDescriptor::reactiveMaskTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( reactiveMaskTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setReactiveMaskTextureFormat( MTL::PixelFormat pixelFormat ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isSpecularHitDistanceTextureEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isSpecularHitDistanceTextureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setSpecularHitDistanceTextureEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setSpecularHitDistanceTextureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isDenoiseStrengthMaskTextureEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isDenoiseStrengthMaskTextureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setDenoiseStrengthMaskTextureEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDenoiseStrengthMaskTextureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::isTransparencyOverlayTextureEnabled() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isTransparencyOverlayTextureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerDescriptor::setTransparencyOverlayTextureEnabled( bool enabled ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setTransparencyOverlayTextureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalDenoisedScaler* MTLFX::TemporalDenoisedScalerDescriptor::newTemporalDenoisedScaler( const MTL::Device* device ) const +{ + return NS::Object::sendMessage< TemporalDenoisedScaler* >( this, _MTLFX_PRIVATE_SEL( newTemporalDenoisedScalerWithDevice_ ), device ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL4FX::TemporalDenoisedScaler* MTLFX::TemporalDenoisedScalerDescriptor::newTemporalDenoisedScaler( const MTL::Device* device, const MTL4::Compiler* compiler ) const +{ + return NS::Object::sendMessage< MTL4FX::TemporalDenoisedScaler* >( this, _MTLFX_PRIVATE_SEL( newTemporalDenoisedScalerWithDevice_compiler_ ), device, compiler ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerDescriptor::supportedInputContentMinScale( MTL::Device* pDevice ) +{ + float scale = 1.0f; + + if ( nullptr != methodSignatureForSelector( _MTLFX_PRIVATE_CLS( MTLFXTemporalDenoisedScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMinScaleForDevice_ ) ) ) + { + scale = sendMessage< float >( _NS_PRIVATE_CLS( MTLFXTemporalDenoisedScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMinScaleForDevice_ ), pDevice ); + } + + return scale; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerDescriptor::supportedInputContentMaxScale( MTL::Device* pDevice ) +{ + float scale = 1.0f; + + if ( nullptr != methodSignatureForSelector( _MTLFX_PRIVATE_CLS( MTLFXTemporalDenoisedScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMaxScaleForDevice_ ) ) ) + { + scale = sendMessage< float >( _MTLFX_PRIVATE_CLS( MTLFXTemporalDenoisedScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMaxScaleForDevice_ ), pDevice ); + } + else if ( supportsDevice( pDevice ) ) + { + scale = 2.0f; + } + + return scale; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::supportsMetal4FX( MTL::Device* device ) +{ + return NS::Object::sendMessageSafe< bool >( _MTLFX_PRIVATE_CLS(MTLFXTemporalDenoisedScalerDescriptor), _MTLFX_PRIVATE_SEL( supportsMetal4FX_ ), device ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerDescriptor::supportsDevice( MTL::Device* device ) +{ + return NS::Object::sendMessageSafe< bool >( _MTLFX_PRIVATE_CLS(MTLFXTemporalDenoisedScalerDescriptor), _MTLFX_PRIVATE_SEL( supportsDevice_ ), device ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::colorTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::depthTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( depthTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::motionTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( motionTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::reactiveTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( reactiveTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::diffuseAlbedoTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( diffuseAlbedoTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::specularAlbedoTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( specularAlbedoTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::normalTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( normalTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::roughnessTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( roughnessTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::specularHitDistanceTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( specularHitDistanceTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::denoiseStrengthMaskTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( denoiseStrengthMaskTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::transparencyOverlayTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( transparencyOverlayTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalDenoisedScalerBase::outputTextureUsage() const +{ + return NS::Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::colorTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setColorTexture( MTL::Texture* colorTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTexture_ ), colorTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::depthTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( depthTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setDepthTexture( MTL::Texture* depthTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTexture_ ), depthTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::motionTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( motionTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setMotionTexture( MTL::Texture* motionTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTexture_ ), motionTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::diffuseAlbedoTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( diffuseAlbedoTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setDiffuseAlbedoTexture( MTL::Texture* diffuseAlbedoTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDiffuseAlbedoTexture_ ), diffuseAlbedoTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::specularAlbedoTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( specularAlbedoTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setSpecularAlbedoTexture( MTL::Texture* specularAlbedoTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setSpecularAlbedoTexture_ ), specularAlbedoTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::normalTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( normalTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setNormalTexture( MTL::Texture* normalTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setNormalTexture_ ), normalTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::roughnessTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( roughnessTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setRoughnessTexture( MTL::Texture* roughnessTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setRoughnessTexture_ ), roughnessTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::specularHitDistanceTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( specularHitDistanceTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setSpecularHitDistanceTexture( MTL::Texture* specularHitDistanceTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setSpecularHitDistanceTexture_ ), specularHitDistanceTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::denoiseStrengthMaskTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( denoiseStrengthMaskTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setDenoiseStrengthMaskTexture( MTL::Texture* denoiseStrengthMaskTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDenoiseStrengthMaskTexture_ ), denoiseStrengthMaskTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::transparencyOverlayTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( transparencyOverlayTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setTransparencyOverlayTexture( MTL::Texture* transparencyOverlayTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setTransparencyOverlayTexture_ ), transparencyOverlayTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::outputTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setOutputTexture( MTL::Texture* outputTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTexture_ ), outputTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::exposureTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( exposureTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setExposureTexture( MTL::Texture* exposureTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setExposureTexture_ ), exposureTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::preExposure() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( preExposure ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setPreExposure( float preExposure ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setPreExposure_ ), preExposure ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalDenoisedScalerBase::reactiveMaskTexture() const +{ + return NS::Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( reactiveMaskTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setReactiveMaskTexture( MTL::Texture* reactiveMaskTexture ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTexture_ ), reactiveMaskTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::jitterOffsetX() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setJitterOffsetX( float jitterOffsetX ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetX_ ), jitterOffsetX ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::jitterOffsetY() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setJitterOffsetY( float jitterOffsetY ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetY_ ), jitterOffsetY ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::motionVectorScaleX() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setMotionVectorScaleX( float motionVectorScaleX ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleX_ ), motionVectorScaleX ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::motionVectorScaleY() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setMotionVectorScaleY( float motionVectorScaleY ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleY_ ), motionVectorScaleY ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerBase::shouldResetHistory() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( shouldResetHistory ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setShouldResetHistory( bool shouldResetHistory ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setShouldResetHistory_ ), shouldResetHistory ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalDenoisedScalerBase::isDepthReversed() const +{ + return NS::Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isDepthReversed ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setDepthReversed( bool depthReversed ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthReversed_ ), depthReversed ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::colorTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::depthTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::motionTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::diffuseAlbedoTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( diffuseAlbedoTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::specularAlbedoTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( specularAlbedoTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::normalTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( normalTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::roughnessTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( roughnessTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::specularHitDistanceTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( specularHitDistanceTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::denoiseStrengthMaskTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( denoiseStrengthMaskTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::transparencyOverlayTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( transparencyOverlayTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::reactiveMaskTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( reactiveMaskTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalDenoisedScalerBase::outputTextureFormat() const +{ + return NS::Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerBase::inputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerBase::inputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerBase::outputWidth() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalDenoisedScalerBase::outputHeight() const +{ + return NS::Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::inputContentMinScale() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalDenoisedScalerBase::inputContentMaxScale() const +{ + return NS::Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE simd::float4x4 MTLFX::TemporalDenoisedScalerBase::worldToViewMatrix() const +{ + return NS::Object::sendMessage< simd::float4x4 >( this, _MTLFX_PRIVATE_SEL( worldToViewMatrix ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setWorldToViewMatrix( simd::float4x4 worldToViewMatrix ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setWorldToViewMatrix_ ), worldToViewMatrix ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE simd::float4x4 MTLFX::TemporalDenoisedScalerBase::viewToClipMatrix() const +{ + return NS::Object::sendMessage< simd::float4x4 >( this, _MTLFX_PRIVATE_SEL( viewToClipMatrix ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setViewToClipMatrix( simd::float4x4 viewToClipMatrix ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setViewToClipMatrix_ ), viewToClipMatrix ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Fence* MTLFX::TemporalDenoisedScalerBase::fence() const +{ + return NS::Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScalerBase::setFence( MTL::Fence* fence ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFence_ ), fence ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalDenoisedScaler::encodeToCommandBuffer( MTL::CommandBuffer* commandBuffer ) +{ + return NS::Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), commandBuffer ); +} diff --git a/thirdparty/metal-cpp/MetalFX/MTLFXTemporalScaler.hpp b/thirdparty/metal-cpp/MetalFX/MTLFXTemporalScaler.hpp new file mode 100644 index 0000000000..c13d4242ab --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MTLFXTemporalScaler.hpp @@ -0,0 +1,803 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MTLFXTemporalScaler.hpp +// +// Copyright 2020-2025 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXDefines.hpp" +#include "MTLFXPrivate.hpp" + +#include "../Metal/Metal.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace MTL4FX +{ + class TemporalScaler; +} + +namespace MTLFX +{ + class TemporalScalerDescriptor : public NS::Copying< TemporalScalerDescriptor > + { + public: + static class TemporalScalerDescriptor* alloc(); + class TemporalScalerDescriptor* init(); + + MTL::PixelFormat colorTextureFormat() const; + void setColorTextureFormat( MTL::PixelFormat format ); + + MTL::PixelFormat depthTextureFormat() const; + void setDepthTextureFormat( MTL::PixelFormat format ); + + MTL::PixelFormat motionTextureFormat() const; + void setMotionTextureFormat( MTL::PixelFormat format ); + + MTL::PixelFormat outputTextureFormat() const; + void setOutputTextureFormat( MTL::PixelFormat format ); + + NS::UInteger inputWidth() const; + void setInputWidth( NS::UInteger width ); + + NS::UInteger inputHeight() const; + void setInputHeight( NS::UInteger height ); + + NS::UInteger outputWidth() const; + void setOutputWidth( NS::UInteger width ); + + NS::UInteger outputHeight() const; + void setOutputHeight( NS::UInteger height ); + + bool isAutoExposureEnabled() const; + void setAutoExposureEnabled( bool enabled ); + + bool isInputContentPropertiesEnabled() const; + void setInputContentPropertiesEnabled( bool enabled ); + + bool requiresSynchronousInitialization() const; + void setRequiresSynchronousInitialization(bool requiresSynchronousInitialization); + + bool isReactiveMaskTextureEnabled() const; + void setReactiveMaskTextureEnabled( bool enabled ); + + MTL::PixelFormat reactiveMaskTextureFormat() const; + void setReactiveMaskTextureFormat( MTL::PixelFormat pixelFormat ); + + float inputContentMinScale() const; + void setInputContentMinScale( float scale ); + + float inputContentMaxScale() const; + void setInputContentMaxScale( float scale ); + + class TemporalScaler* newTemporalScaler( const MTL::Device* pDevice ) const; + MTL4FX::TemporalScaler* newTemporalScaler( const MTL::Device* pDevice, const MTL4::Compiler* pCompiler) const; + + static float supportedInputContentMinScale( const MTL::Device* pDevice ); + static float supportedInputContentMaxScale( const MTL::Device* pDevice ); + + static bool supportsDevice( const MTL::Device* pDevice ); + static bool supportsMetal4FX( const MTL::Device* pDevice ); + }; + + class FrameInterpolatableScaler : public NS::Copying< FrameInterpolatableScaler > + { + }; + + class TemporalScalerBase : public NS::Referencing< TemporalScaler, FrameInterpolatableScaler > + { + public: + MTL::TextureUsage colorTextureUsage() const; + MTL::TextureUsage depthTextureUsage() const; + MTL::TextureUsage motionTextureUsage() const; + MTL::TextureUsage outputTextureUsage() const; + + NS::UInteger inputContentWidth() const; + void setInputContentWidth( NS::UInteger width ); + + NS::UInteger inputContentHeight() const; + void setInputContentHeight( NS::UInteger height ); + + MTL::Texture* colorTexture() const; + void setColorTexture( MTL::Texture* pTexture ); + + MTL::Texture* depthTexture() const; + void setDepthTexture( MTL::Texture* pTexture ); + + MTL::Texture* motionTexture() const; + void setMotionTexture( MTL::Texture* pTexture ); + + MTL::Texture* outputTexture() const; + void setOutputTexture( MTL::Texture* pTexture ); + + MTL::Texture* exposureTexture() const; + void setExposureTexture( MTL::Texture* pTexture ); + + float preExposure() const; + void setPreExposure( float preExposure ); + + float jitterOffsetX() const; + void setJitterOffsetX( float offset ); + + float jitterOffsetY() const; + void setJitterOffsetY( float offset ); + + float motionVectorScaleX() const; + void setMotionVectorScaleX( float scale ); + + float motionVectorScaleY() const; + void setMotionVectorScaleY( float scale ); + + MTL::Texture* reactiveMaskTexture() const; + void setReactiveMaskTexture( MTL::Texture* reactiveMaskTexture ); + + MTL::TextureUsage reactiveTextureUsage() const; + + bool reset() const; + void setReset( bool reset ); + + bool isDepthReversed() const; + void setDepthReversed( bool depthReversed ); + + MTL::PixelFormat colorTextureFormat() const; + MTL::PixelFormat depthTextureFormat() const; + MTL::PixelFormat motionTextureFormat() const; + MTL::PixelFormat reactiveTextureFormat() const; + MTL::PixelFormat outputTextureFormat() const; + NS::UInteger inputWidth() const; + NS::UInteger inputHeight() const; + NS::UInteger outputWidth() const; + NS::UInteger outputHeight() const; + float inputContentMinScale() const; + float inputContentMaxScale() const; + + MTL::Fence* fence() const; + void setFence( MTL::Fence* pFence ); + }; + + class TemporalScaler : public NS::Referencing< TemporalScaler, TemporalScalerBase > + { + public: + void encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer ); + }; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalScalerDescriptor* MTLFX::TemporalScalerDescriptor::alloc() +{ + return NS::Object::alloc< TemporalScalerDescriptor >( _MTLFX_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalScalerDescriptor* MTLFX::TemporalScalerDescriptor::init() +{ + return NS::Object::init< TemporalScalerDescriptor >(); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::colorTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setColorTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::depthTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setDepthTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::motionTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setMotionTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::outputTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputTextureFormat( MTL::PixelFormat format ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTextureFormat_ ), format ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::inputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::inputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::outputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerDescriptor::outputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setOutputHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::isAutoExposureEnabled() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isAutoExposureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setAutoExposureEnabled( bool enabled ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setAutoExposureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::isInputContentPropertiesEnabled() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isInputContentPropertiesEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentPropertiesEnabled( bool enabled ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentPropertiesEnabled_ ), enabled ); +} + + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::requiresSynchronousInitialization() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( requiresSynchronousInitialization ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setRequiresSynchronousInitialization(bool requiresSynchronousInitialization) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setRequiresSynchronousInitialization_ ), requiresSynchronousInitialization ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::isReactiveMaskTextureEnabled() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isReactiveMaskTextureEnabled ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setReactiveMaskTextureEnabled( bool enabled ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTextureEnabled_ ), enabled ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerDescriptor::reactiveMaskTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( reactiveMaskTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setReactiveMaskTextureFormat( MTL::PixelFormat pixelFormat ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTextureFormat_ ), pixelFormat ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::inputContentMinScale() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentMinScale( float scale ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentMinScale_ ), scale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::inputContentMaxScale() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerDescriptor::setInputContentMaxScale( float scale ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentMaxScale_ ), scale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTLFX::TemporalScaler* MTLFX::TemporalScalerDescriptor::newTemporalScaler( const MTL::Device* pDevice ) const +{ + return Object::sendMessage< TemporalScaler* >( this, _MTLFX_PRIVATE_SEL( newTemporalScalerWithDevice_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL4FX::TemporalScaler* MTLFX::TemporalScalerDescriptor::newTemporalScaler( const MTL::Device* pDevice, const MTL4::Compiler* pCompiler ) const +{ + return Object::sendMessage< MTL4FX::TemporalScaler* >( this, _MTLFX_PRIVATE_SEL( newTemporalScalerWithDevice_compiler_ ), pDevice, pCompiler ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::supportedInputContentMinScale( const MTL::Device* pDevice ) +{ + float scale = 1.0f; + + if ( nullptr != methodSignatureForSelector( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMinScaleForDevice_ ) ) ) + { + scale = sendMessage< float >( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMinScaleForDevice_ ), pDevice ); + } + + return scale; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerDescriptor::supportedInputContentMaxScale( const MTL::Device* pDevice ) +{ + float scale = 1.0f; + + if ( nullptr != methodSignatureForSelector( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMaxScaleForDevice_ ) ) ) + { + scale = sendMessage< float >( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportedInputContentMaxScaleForDevice_ ), pDevice ); + } + else if ( supportsDevice( pDevice ) ) + { + scale = 2.0f; + } + + return scale; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::supportsDevice( const MTL::Device* pDevice ) +{ + return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsDevice_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerDescriptor::supportsMetal4FX( const MTL::Device* pDevice ) +{ + return Object::sendMessageSafe< bool >( _NS_PRIVATE_CLS( MTLFXTemporalScalerDescriptor ), _MTLFX_PRIVATE_SEL( supportsMetal4FX_ ), pDevice ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScalerBase::colorTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( colorTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScalerBase::depthTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( depthTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScalerBase::motionTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( motionTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScalerBase::outputTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( outputTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::inputContentWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setInputContentWidth( NS::UInteger width ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentWidth_ ), width ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::inputContentHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputContentHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setInputContentHeight( NS::UInteger height ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setInputContentHeight_ ), height ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::colorTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( colorTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setColorTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setColorTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::depthTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( depthTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setDepthTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::motionTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( motionTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setMotionTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::outputTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( outputTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setOutputTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setOutputTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::exposureTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( exposureTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setExposureTexture( MTL::Texture* pTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setExposureTexture_ ), pTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::preExposure() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( preExposure ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setPreExposure( float preExposure ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setPreExposure_ ), preExposure ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::jitterOffsetX() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setJitterOffsetX( float offset ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetX_ ), offset ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::jitterOffsetY() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( jitterOffsetY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setJitterOffsetY( float offset ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setJitterOffsetY_ ), offset ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::motionVectorScaleX() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleX ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setMotionVectorScaleX( float scale ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleX_ ), scale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::motionVectorScaleY() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( motionVectorScaleY ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setMotionVectorScaleY( float scale ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setMotionVectorScaleY_ ), scale ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Texture* MTLFX::TemporalScalerBase::reactiveMaskTexture() const +{ + return Object::sendMessage< MTL::Texture* >( this, _MTLFX_PRIVATE_SEL( reactiveMaskTexture ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setReactiveMaskTexture( MTL::Texture* reactiveMaskTexture ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReactiveMaskTexture_ ), reactiveMaskTexture ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::TextureUsage MTLFX::TemporalScalerBase::reactiveTextureUsage() const +{ + return Object::sendMessage< MTL::TextureUsage >( this, _MTLFX_PRIVATE_SEL( reactiveTextureUsage ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerBase::reset() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( reset ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setReset( bool reset ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setReset_ ), reset ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE bool MTLFX::TemporalScalerBase::isDepthReversed() const +{ + return Object::sendMessage< bool >( this, _MTLFX_PRIVATE_SEL( isDepthReversed ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setDepthReversed( bool depthReversed ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setDepthReversed_ ), depthReversed ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerBase::colorTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( colorTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerBase::depthTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( depthTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerBase::motionTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( motionTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::PixelFormat MTLFX::TemporalScalerBase::outputTextureFormat() const +{ + return Object::sendMessage< MTL::PixelFormat >( this, _MTLFX_PRIVATE_SEL( outputTextureFormat ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::inputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::inputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( inputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::outputWidth() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputWidth ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE NS::UInteger MTLFX::TemporalScalerBase::outputHeight() const +{ + return Object::sendMessage< NS::UInteger >( this, _MTLFX_PRIVATE_SEL( outputHeight ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::inputContentMinScale() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMinScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE float MTLFX::TemporalScalerBase::inputContentMaxScale() const +{ + return Object::sendMessage< float >( this, _MTLFX_PRIVATE_SEL( inputContentMaxScale ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE MTL::Fence* MTLFX::TemporalScalerBase::fence() const +{ + return Object::sendMessage< MTL::Fence* >( this, _MTLFX_PRIVATE_SEL( fence ) ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScalerBase::setFence( MTL::Fence* pFence ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( setFence_ ), pFence ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_MTLFX_INLINE void MTLFX::TemporalScaler::encodeToCommandBuffer( MTL::CommandBuffer* pCommandBuffer ) +{ + Object::sendMessage< void >( this, _MTLFX_PRIVATE_SEL( encodeToCommandBuffer_ ), pCommandBuffer ); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/MetalFX/MetalFX.hpp b/thirdparty/metal-cpp/MetalFX/MetalFX.hpp new file mode 100644 index 0000000000..20e647e840 --- /dev/null +++ b/thirdparty/metal-cpp/MetalFX/MetalFX.hpp @@ -0,0 +1,35 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// MetalFX/MetalFX.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "MTLFXSpatialScaler.hpp" +#include "MTLFXTemporalScaler.hpp" +#include "MTLFXTemporalDenoisedScaler.hpp" +#include "MTLFXFrameInterpolator.hpp" + +#include "MTL4FXSpatialScaler.hpp" +#include "MTL4FXTemporalScaler.hpp" +#include "MTL4FXTemporalDenoisedScaler.hpp" +#include "MTL4FXFrameInterpolator.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/QuartzCore/CADefines.hpp b/thirdparty/metal-cpp/QuartzCore/CADefines.hpp new file mode 100644 index 0000000000..b0641de054 --- /dev/null +++ b/thirdparty/metal-cpp/QuartzCore/CADefines.hpp @@ -0,0 +1,41 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// QuartzCore/CADefines.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "../Foundation/NSDefines.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _CA_EXPORT _NS_EXPORT +#define _CA_EXTERN _NS_EXTERN +#define _CA_INLINE _NS_INLINE +#define _CA_PACKED _NS_PACKED + +#define _CA_CONST(type, name) _NS_CONST(type, name) +#define _CA_ENUM(type, name) _NS_ENUM(type, name) +#define _CA_OPTIONS(type, name) _NS_OPTIONS(type, name) + +#define _CA_VALIDATE_SIZE(ns, name) _NS_VALIDATE_SIZE(ns, name) +#define _CA_VALIDATE_ENUM(ns, name) _NS_VALIDATE_ENUM(ns, name) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/QuartzCore/CAMetalDrawable.hpp b/thirdparty/metal-cpp/QuartzCore/CAMetalDrawable.hpp new file mode 100644 index 0000000000..0057773a20 --- /dev/null +++ b/thirdparty/metal-cpp/QuartzCore/CAMetalDrawable.hpp @@ -0,0 +1,57 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// QuartzCore/CAMetalDrawable.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "../Metal/MTLDrawable.hpp" +#include "../Metal/MTLTexture.hpp" + +#include "CADefines.hpp" +#include "CAPrivate.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace CA +{ +class MetalDrawable : public NS::Referencing +{ +public: + class MetalLayer* layer() const; + MTL::Texture* texture() const; +}; +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE CA::MetalLayer* CA::MetalDrawable::layer() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(layer)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE MTL::Texture* CA::MetalDrawable::texture() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(texture)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/QuartzCore/CAMetalLayer.hpp b/thirdparty/metal-cpp/QuartzCore/CAMetalLayer.hpp new file mode 100644 index 0000000000..53f6857d2a --- /dev/null +++ b/thirdparty/metal-cpp/QuartzCore/CAMetalLayer.hpp @@ -0,0 +1,216 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// QuartzCore/CAMetalDrawable.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "../Metal/MTLPixelFormat.hpp" +#include "../Metal/MTLTexture.hpp" +#include "../Metal/MTLResidencySet.hpp" +#include "../Foundation/NSTypes.hpp" +#include +#include + +#include "CADefines.hpp" +#include "CAMetalDrawable.hpp" +#include "CAPrivate.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace CA +{ + +class MetalLayer : public NS::Referencing +{ +public: + static class MetalLayer* layer(); + + MTL::Device* device() const; + void setDevice(MTL::Device* device); + + MTL::PixelFormat pixelFormat() const; + void setPixelFormat(MTL::PixelFormat pixelFormat); + + bool framebufferOnly() const; + void setFramebufferOnly(bool framebufferOnly); + + CGSize drawableSize() const; + void setDrawableSize(CGSize drawableSize); + + class MetalDrawable* nextDrawable(); + + NS::UInteger maximumDrawableCount() const; + void setMaximumDrawableCount(NS::UInteger maximumDrawableCount); + + bool displaySyncEnabled() const; + void setDisplaySyncEnabled(bool displaySyncEnabled); + + CGColorSpaceRef colorspace() const; + void setColorspace(CGColorSpaceRef colorspace); + + bool allowsNextDrawableTimeout() const; + void setAllowsNextDrawableTimeout(bool allowsNextDrawableTimeout); + + MTL::ResidencySet* residencySet() const; +}; +} // namespace CA + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +_CA_INLINE CA::MetalLayer* CA::MetalLayer::layer() +{ + return Object::sendMessage(_CA_PRIVATE_CLS(CAMetalLayer), _CA_PRIVATE_SEL(layer)); +} +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE MTL::Device* CA::MetalLayer::device() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(device)); +} +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setDevice(MTL::Device* device) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setDevice_), device); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE MTL::PixelFormat CA::MetalLayer::pixelFormat() const +{ + return Object::sendMessage(this, + _CA_PRIVATE_SEL(pixelFormat)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setPixelFormat(MTL::PixelFormat pixelFormat) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setPixelFormat_), + pixelFormat); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE bool CA::MetalLayer::framebufferOnly() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(framebufferOnly)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setFramebufferOnly(bool framebufferOnly) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setFramebufferOnly_), + framebufferOnly); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE CGSize CA::MetalLayer::drawableSize() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(drawableSize)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setDrawableSize(CGSize drawableSize) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setDrawableSize_), + drawableSize); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE CA::MetalDrawable* CA::MetalLayer::nextDrawable() +{ + return Object::sendMessage(this, + _CA_PRIVATE_SEL(nextDrawable)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE NS::UInteger CA::MetalLayer::maximumDrawableCount() const +{ + return Object::sendMessage(this, + _CA_PRIVATE_SEL(maximumDrawableCount)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setMaximumDrawableCount(NS::UInteger maximumDrawableCount) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setMaximumDrawableCount_), + maximumDrawableCount); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE bool CA::MetalLayer::displaySyncEnabled() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(displaySyncEnabled)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setDisplaySyncEnabled(bool displaySyncEnabled) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setDisplaySyncEnabled_), + displaySyncEnabled); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE CGColorSpaceRef CA::MetalLayer::colorspace() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(colorspace)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setColorspace(CGColorSpaceRef colorspace) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setColorspace_), + colorspace); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE bool CA::MetalLayer::allowsNextDrawableTimeout() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(allowsNextDrawableTimeout)); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE void CA::MetalLayer::setAllowsNextDrawableTimeout(bool allowsNextDrawableTimeout) +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(setAllowsNextDrawableTimeout_), + allowsNextDrawableTimeout); +} + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +_CA_INLINE MTL::ResidencySet* CA::MetalLayer::residencySet() const +{ + return Object::sendMessage(this, _CA_PRIVATE_SEL(residencySet) ); +} diff --git a/thirdparty/metal-cpp/QuartzCore/CAPrivate.hpp b/thirdparty/metal-cpp/QuartzCore/CAPrivate.hpp new file mode 100644 index 0000000000..0b7486a751 --- /dev/null +++ b/thirdparty/metal-cpp/QuartzCore/CAPrivate.hpp @@ -0,0 +1,150 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// QuartzCore/CAPrivate.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "CADefines.hpp" + +#include + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#define _CA_PRIVATE_CLS(symbol) (Private::Class::s_k##symbol) +#define _CA_PRIVATE_SEL(accessor) (Private::Selector::s_k##accessor) + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#if defined(CA_PRIVATE_IMPLEMENTATION) + +#ifdef METALCPP_SYMBOL_VISIBILITY_HIDDEN +#define _CA_PRIVATE_VISIBILITY __attribute__((visibility("hidden"))) +#else +#define _CA_PRIVATE_VISIBILITY __attribute__((visibility("default"))) +#endif // METALCPP_SYMBOL_VISIBILITY_HIDDEN + +#define _CA_PRIVATE_IMPORT __attribute__((weak_import)) + +#ifdef __OBJC__ +#define _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol) ((__bridge void*)objc_lookUpClass(#symbol)) +#define _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol) ((__bridge void*)objc_getProtocol(#symbol)) +#else +#define _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol) objc_lookUpClass(#symbol) +#define _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol) objc_getProtocol(#symbol) +#endif // __OBJC__ + +#define _CA_PRIVATE_DEF_CLS(symbol) void* s_k##symbol _CA_PRIVATE_VISIBILITY = _CA_PRIVATE_OBJC_LOOKUP_CLASS(symbol) +#define _CA_PRIVATE_DEF_PRO(symbol) void* s_k##symbol _CA_PRIVATE_VISIBILITY = _CA_PRIVATE_OBJC_GET_PROTOCOL(symbol) +#define _CA_PRIVATE_DEF_SEL(accessor, symbol) SEL s_k##accessor _CA_PRIVATE_VISIBILITY = sel_registerName(symbol) +#define _CA_PRIVATE_DEF_STR(type, symbol) \ + _CA_EXTERN type const CA##symbol _CA_PRIVATE_IMPORT; \ + type const CA::symbol = (nullptr != &CA##symbol) ? CA##symbol : nullptr + +#else + +#define _CA_PRIVATE_DEF_CLS(symbol) extern void* s_k##symbol +#define _CA_PRIVATE_DEF_PRO(symbol) extern void* s_k##symbol +#define _CA_PRIVATE_DEF_SEL(accessor, symbol) extern SEL s_k##accessor +#define _CA_PRIVATE_DEF_STR(type, symbol) extern type const CA::symbol + +#endif // CA_PRIVATE_IMPLEMENTATION + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace CA +{ +namespace Private +{ + namespace Class + { + _CA_PRIVATE_DEF_CLS(CAMetalLayer); + } // Class +} // Private +} // CA + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace CA +{ +namespace Private +{ + namespace Protocol + { + + _CA_PRIVATE_DEF_PRO(CAMetalDrawable); + + } // Protocol +} // Private +} // CA + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +namespace CA +{ +namespace Private +{ + namespace Selector + { + _CA_PRIVATE_DEF_SEL(allowsNextDrawableTimeout, + "allowsNextDrawableTimeout"); + _CA_PRIVATE_DEF_SEL(colorspace, + "colorspace"); + _CA_PRIVATE_DEF_SEL(device, + "device"); + _CA_PRIVATE_DEF_SEL(displaySyncEnabled, + "displaySyncEnabled"); + _CA_PRIVATE_DEF_SEL(drawableSize, + "drawableSize"); + _CA_PRIVATE_DEF_SEL(framebufferOnly, + "framebufferOnly"); + _CA_PRIVATE_DEF_SEL(layer, + "layer"); + _CA_PRIVATE_DEF_SEL(maximumDrawableCount, + "maximumDrawableCount"); + _CA_PRIVATE_DEF_SEL(nextDrawable, + "nextDrawable"); + _CA_PRIVATE_DEF_SEL(pixelFormat, + "pixelFormat"); + _CA_PRIVATE_DEF_SEL(residencySet, + "residencySet"); + _CA_PRIVATE_DEF_SEL(setAllowsNextDrawableTimeout_, + "setAllowsNextDrawableTimeout:"); + _CA_PRIVATE_DEF_SEL(setColorspace_, + "setColorspace:"); + _CA_PRIVATE_DEF_SEL(setDevice_, + "setDevice:"); + _CA_PRIVATE_DEF_SEL(setDisplaySyncEnabled_, + "setDisplaySyncEnabled:"); + _CA_PRIVATE_DEF_SEL(setDrawableSize_, + "setDrawableSize:"); + _CA_PRIVATE_DEF_SEL(setFramebufferOnly_, + "setFramebufferOnly:"); + _CA_PRIVATE_DEF_SEL(setMaximumDrawableCount_, + "setMaximumDrawableCount:"); + _CA_PRIVATE_DEF_SEL(setPixelFormat_, + "setPixelFormat:"); + _CA_PRIVATE_DEF_SEL(texture, + "texture"); + } // Class +} // Private +} // CA + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/QuartzCore/QuartzCore.hpp b/thirdparty/metal-cpp/QuartzCore/QuartzCore.hpp new file mode 100644 index 0000000000..681003ad60 --- /dev/null +++ b/thirdparty/metal-cpp/QuartzCore/QuartzCore.hpp @@ -0,0 +1,28 @@ +//------------------------------------------------------------------------------------------------------------------------------------------------------------- +// +// QuartzCore/QuartzCore.hpp +// +// Copyright 2020-2024 Apple Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#pragma once + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- + +#include "CAMetalDrawable.hpp" +#include "CAMetalLayer.hpp" + +//------------------------------------------------------------------------------------------------------------------------------------------------------------- diff --git a/thirdparty/metal-cpp/metal_cpp.cpp b/thirdparty/metal-cpp/metal_cpp.cpp new file mode 100644 index 0000000000..7d20dc7cce --- /dev/null +++ b/thirdparty/metal-cpp/metal_cpp.cpp @@ -0,0 +1,39 @@ +/**************************************************************************/ +/* metal_cpp.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#define NS_PRIVATE_IMPLEMENTATION +#define CA_PRIVATE_IMPLEMENTATION +#define MTL_PRIVATE_IMPLEMENTATION +#define MTLFX_PRIVATE_IMPLEMENTATION + +#include "Foundation/Foundation.hpp" +#include "Metal/Metal.hpp" +#include "MetalFX/MetalFX.hpp" +#include "QuartzCore/QuartzCore.hpp" diff --git a/thirdparty/metal-cpp/patches/0001-add-missing-apis.patch b/thirdparty/metal-cpp/patches/0001-add-missing-apis.patch new file mode 100644 index 0000000000..0afcbaed09 --- /dev/null +++ b/thirdparty/metal-cpp/patches/0001-add-missing-apis.patch @@ -0,0 +1,76 @@ + thirdparty/metal-cpp/Foundation/NSData.hpp | 6 ++++++ + thirdparty/metal-cpp/Foundation/NSPrivate.hpp | 4 ++++ + thirdparty/metal-cpp/Foundation/NSString.hpp | 7 +++++++ + 3 files changed, 17 insertions(+) + +diff --git a/thirdparty/metal-cpp/Foundation/NSData.hpp b/thirdparty/metal-cpp/Foundation/NSData.hpp +index 3ad360609f..fbf3f20343 100644 +--- a/thirdparty/metal-cpp/Foundation/NSData.hpp ++++ b/thirdparty/metal-cpp/Foundation/NSData.hpp +@@ -33,6 +33,7 @@ class Data : public Copying + { + public: + void* mutableBytes() const; ++ void* bytes() const; + UInteger length() const; + }; + } +@@ -44,6 +45,11 @@ _NS_INLINE void* NS::Data::mutableBytes() const + return Object::sendMessage(this, _NS_PRIVATE_SEL(mutableBytes)); + } + ++_NS_INLINE void* NS::Data::bytes() const ++{ ++ return Object::sendMessage(this, _NS_PRIVATE_SEL(bytes)); ++} ++ + //------------------------------------------------------------------------------------------------------------------------------------------------------------- + + _NS_INLINE NS::UInteger NS::Data::length() const +diff --git a/thirdparty/metal-cpp/Foundation/NSPrivate.hpp b/thirdparty/metal-cpp/Foundation/NSPrivate.hpp +index f8d87004f3..17909fbd2a 100644 +--- a/thirdparty/metal-cpp/Foundation/NSPrivate.hpp ++++ b/thirdparty/metal-cpp/Foundation/NSPrivate.hpp +@@ -272,6 +272,8 @@ namespace Private + "initWithBytes:objCType:"); + _NS_PRIVATE_DEF_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_, + "initWithBytesNoCopy:length:encoding:freeWhenDone:"); ++ _NS_PRIVATE_DEF_SEL(initWithBytes_length_encoding_, ++ "initWithBytes:length:encoding:"); + _NS_PRIVATE_DEF_SEL(initWithChar_, + "initWithChar:"); + _NS_PRIVATE_DEF_SEL(initWithCoder_, +@@ -372,6 +374,8 @@ namespace Private + "methodSignatureForSelector:"); + _NS_PRIVATE_DEF_SEL(mutableBytes, + "mutableBytes"); ++ _NS_PRIVATE_DEF_SEL(bytes, ++ "bytes"); + _NS_PRIVATE_DEF_SEL(name, + "name"); + _NS_PRIVATE_DEF_SEL(nextObject, +diff --git a/thirdparty/metal-cpp/Foundation/NSString.hpp b/thirdparty/metal-cpp/Foundation/NSString.hpp +index 07ba3f8d39..d4d0c52ec2 100644 +--- a/thirdparty/metal-cpp/Foundation/NSString.hpp ++++ b/thirdparty/metal-cpp/Foundation/NSString.hpp +@@ -87,6 +87,7 @@ public: + String* init(); + String* init(const String* pString); + String* init(const char* pString, StringEncoding encoding); ++ String* init(void* pBytes, UInteger len, StringEncoding encoding); + String* init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer); + + unichar character(UInteger index) const; +@@ -168,6 +169,12 @@ _NS_INLINE NS::String* NS::String::init(const char* pString, StringEncoding enco + + //------------------------------------------------------------------------------------------------------------------------------------------------------------- + ++_NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding) ++{ ++ return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBytes_length_encoding_), pBytes, len, encoding); ++} ++//------------------------------------------------------------------------------------------------------------------------------------------------------------- ++ + _NS_INLINE NS::String* NS::String::init(void* pBytes, UInteger len, StringEncoding encoding, bool freeBuffer) + { + return Object::sendMessage(this, _NS_PRIVATE_SEL(initWithBytesNoCopy_length_encoding_freeWhenDone_), pBytes, len, encoding, freeBuffer); diff --git a/thirdparty/metal-cpp/update-metal-cpp.sh b/thirdparty/metal-cpp/update-metal-cpp.sh new file mode 100755 index 0000000000..ba3453052c --- /dev/null +++ b/thirdparty/metal-cpp/update-metal-cpp.sh @@ -0,0 +1,96 @@ +#!/bin/bash -e + +# metal-cpp update script for Godot +# +# metal-cpp source: https://developer.apple.com/metal/cpp/ +# This version includes Metal 4 APIs (macOS 26 / iOS 26). + +VERSION="macOS26-iOS26" + +SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)" +REPO_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)" + +# If a zip is provided as argument, extract it +if [ -n "$1" ]; then + echo "Updating metal-cpp from: $1" + + rm -rf \ + "$SCRIPT_DIR/Foundation" \ + "$SCRIPT_DIR/Metal" \ + "$SCRIPT_DIR/MetalFX" \ + "$SCRIPT_DIR/QuartzCore" \ + "$SCRIPT_DIR/SingleHeader" + + unzip -q "$1" -d "$SCRIPT_DIR" + + echo "Extracted metal-cpp $VERSION" +else + echo "Applying patches only..." +fi + +# ============================================================================= +# Apply Godot-specific patches +# ============================================================================= + +echo "Applying Godot compatibility patches..." + +# Apply patch files (idempotent) +PATCH_DIR="$SCRIPT_DIR/patches" +if [ -d "$PATCH_DIR" ]; then + for PATCH in "$PATCH_DIR"/*.patch; do + if [ ! -e "$PATCH" ]; then + echo " No patches found in $PATCH_DIR" + break + fi + + PATCH_NAME="$(basename "$PATCH")" + if git -C "$REPO_ROOT" apply --check "$PATCH" > /dev/null 2>&1; then + git -C "$REPO_ROOT" apply "$PATCH" + echo " $PATCH_NAME: applied" + elif git -C "$REPO_ROOT" apply --reverse --check "$PATCH" > /dev/null 2>&1; then + echo " $PATCH_NAME: already applied" + else + echo " $PATCH_NAME: failed to apply" + exit 1 + fi + done +else + echo " Warning: $PATCH_DIR not found" +fi + +# Patch 1: Add forward declarations to NSDefines.hpp to avoid conflicts with +# Godot's global types (String, Object, Error). +# +# Without this patch, metal-cpp's "class String*" forward declarations conflict +# with Godot's ::String, ::Object, and ::Error types. + +NSDEFINES="$SCRIPT_DIR/Foundation/NSDefines.hpp" + +if [ -f "$NSDEFINES" ]; then + # Check if patch already applied + if grep -q "Forward declarations to avoid conflicts with Godot" "$NSDEFINES"; then + echo " NSDefines.hpp: already patched" + else + # Find the line with #pragma once and insert after the next separator + sed -i '' '/^#pragma once$/,/^\/\/---/{ + /^\/\/---/ { + a\ +\ +// Forward declarations to avoid conflicts with Godot types (String, Object, Error)\ +namespace NS {\ +class Array;\ +class Dictionary;\ +class Error;\ +class Object;\ +class String;\ +class URL;\ +} // namespace NS + } + }' "$NSDEFINES" + echo " NSDefines.hpp: patched" + fi +else + echo " Warning: $NSDEFINES not found" +fi + +echo "Done."