/**************************************************************************/ /* rendering_device_driver_metal.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 "rendering_device_driver_metal.h" #import "pixel_formats.h" #import "rendering_context_driver_metal.h" #import "core/io/compression.h" #import "core/io/marshalls.h" #import "core/string/ustring.h" #import "core/templates/hash_map.h" #import #import #import #import #import #import #pragma mark - Logging os_log_t LOG_DRIVER; // Used for dynamic tracing. os_log_t LOG_INTERVALS; __attribute__((constructor)) static void InitializeLogging(void) { LOG_DRIVER = os_log_create("org.godotengine.godot.metal", OS_LOG_CATEGORY_POINTS_OF_INTEREST); LOG_INTERVALS = os_log_create("org.godotengine.godot.metal", "events"); } /*****************/ /**** GENERIC ****/ /*****************/ // 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 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; } _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; } _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; } /*****************/ /**** BUFFERS ****/ /*****************/ RDD::BufferID RenderingDeviceDriverMetal::buffer_create(uint64_t p_size, BitField p_usage, MemoryAllocationType p_allocation_type) { MTLResourceOptions options = MTLResourceHazardTrackingModeTracked; switch (p_allocation_type) { case MEMORY_ALLOCATION_TYPE_CPU: options |= MTLResourceStorageModeShared; break; case MEMORY_ALLOCATION_TYPE_GPU: options |= MTLResourceStorageModePrivate; break; } id obj = [device newBufferWithLength:p_size options:options]; ERR_FAIL_NULL_V_MSG(obj, BufferID(), "Can't create buffer of size: " + itos(p_size)); return rid::make(obj); } bool RenderingDeviceDriverMetal::buffer_set_texel_format(BufferID p_buffer, DataFormat p_format) { // Nothing to do. return true; } void RenderingDeviceDriverMetal::buffer_free(BufferID p_buffer) { rid::release(p_buffer); } uint64_t RenderingDeviceDriverMetal::buffer_get_allocation_size(BufferID p_buffer) { id obj = rid::get(p_buffer); return obj.allocatedSize; } uint8_t *RenderingDeviceDriverMetal::buffer_map(BufferID p_buffer) { id obj = rid::get(p_buffer); ERR_FAIL_COND_V_MSG(obj.storageMode != MTLStorageModeShared, nullptr, "Unable to map private buffers"); return (uint8_t *)obj.contents; } void RenderingDeviceDriverMetal::buffer_unmap(BufferID p_buffer) { // Nothing to do. } #pragma mark - Texture #pragma mark - Format Conversions static const MTLTextureType TEXTURE_TYPE[RD::TEXTURE_TYPE_MAX] = { MTLTextureType1D, MTLTextureType2D, MTLTextureType3D, MTLTextureTypeCube, MTLTextureType1DArray, MTLTextureType2DArray, MTLTextureTypeCubeArray, }; RenderingDeviceDriverMetal::Result RenderingDeviceDriverMetal::is_valid_linear(TextureFormat const &p_format) const { if (!flags::any(p_format.usage_bits, TEXTURE_USAGE_CPU_READ_BIT)) { return false; } PixelFormats &pf = *pixel_formats; MTLFormatType ft = pf.getFormatType(p_format.format); // Requesting a linear format, which has further restrictions, similar to Vulkan // when specifying VK_IMAGE_TILING_LINEAR. ERR_FAIL_COND_V_MSG(p_format.texture_type != TEXTURE_TYPE_2D, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must be 2D"); ERR_FAIL_COND_V_MSG(ft != MTLFormatType::DepthStencil, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must not be a depth/stencil format"); ERR_FAIL_COND_V_MSG(ft != MTLFormatType::Compressed, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must not be a compressed format"); ERR_FAIL_COND_V_MSG(p_format.mipmaps != 1, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must have 1 mipmap level"); ERR_FAIL_COND_V_MSG(p_format.array_layers != 1, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must have 1 array layer"); ERR_FAIL_COND_V_MSG(p_format.samples != TEXTURE_SAMPLES_1, ERR_CANT_CREATE, "Linear (TEXTURE_USAGE_CPU_READ_BIT) textures must have 1 sample"); return true; } 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]; PixelFormats &formats = *pixel_formats; desc.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; if (p_format.texture_type == TEXTURE_TYPE_1D_ARRAY || p_format.texture_type == TEXTURE_TYPE_2D_ARRAY) { desc.arrayLength = p_format.array_layers; } else if (p_format.texture_type == TEXTURE_TYPE_CUBE_ARRAY) { desc.arrayLength = 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; if (p_format.samples > TEXTURE_SAMPLES_1) { SampleCount supported = (*metal_device_properties).find_nearest_supported_sample_count(p_format.samples); if (supported > SampleCount1) { bool ok = p_format.texture_type == TEXTURE_TYPE_2D || p_format.texture_type == TEXTURE_TYPE_2D_ARRAY; if (ok) { switch (p_format.texture_type) { case TEXTURE_TYPE_2D: desc.textureType = MTLTextureType2DMultisample; break; case TEXTURE_TYPE_2D_ARRAY: desc.textureType = MTLTextureType2DMultisampleArray; break; default: break; } desc.sampleCount = (NSUInteger)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; } } else { WARN_PRINT("Unsupported multi-sample texture type; disabling multi-sample"); } } } static const MTLTextureSwizzle COMPONENT_SWIZZLE[TEXTURE_SWIZZLE_MAX] = { static_cast(255), // IDENTITY MTLTextureSwizzleZero, MTLTextureSwizzleOne, MTLTextureSwizzleRed, MTLTextureSwizzleGreen, MTLTextureSwizzleBlue, MTLTextureSwizzleAlpha, }; 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); // Represents a swizzle operation that is a no-op. static MTLTextureSwizzleChannels IDENTITY_SWIZZLE = { .red = MTLTextureSwizzleRed, .green = MTLTextureSwizzleGreen, .blue = MTLTextureSwizzleBlue, .alpha = MTLTextureSwizzleAlpha, }; bool no_swizzle = memcmp(&IDENTITY_SWIZZLE, &swizzle, sizeof(MTLTextureSwizzleChannels)) == 0; if (!no_swizzle) { desc.swizzle = swizzle; } // Usage. MTLResourceOptions options = MTLResourceCPUCacheModeDefaultCache | MTLResourceHazardTrackingModeTracked; if (p_format.usage_bits & TEXTURE_USAGE_CPU_READ_BIT) { options |= MTLResourceStorageModeShared; } else { options |= MTLResourceStorageModePrivate; } desc.resourceOptions = options; if (p_format.usage_bits & TEXTURE_USAGE_SAMPLING_BIT) { desc.usage |= MTLTextureUsageShaderRead; } if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_BIT) { desc.usage |= MTLTextureUsageShaderWrite; } if (p_format.usage_bits & TEXTURE_USAGE_STORAGE_ATOMIC_BIT) { desc.usage |= MTLTextureUsageShaderWrite; } 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; } if (p_format.usage_bits & TEXTURE_USAGE_INPUT_ATTACHMENT_BIT) { desc.usage |= MTLTextureUsageShaderRead; } if (p_format.usage_bits & TEXTURE_USAGE_VRS_ATTACHMENT_BIT) { ERR_FAIL_V_MSG(RDD::TextureID(), "unsupported: TEXTURE_USAGE_VRS_ATTACHMENT_BIT"); } 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; } if (p_format.usage_bits & TEXTURE_USAGE_CAN_COPY_FROM_BIT) { // Covered by blits. } // Create texture views with a different component layout. if (!p_format.shareable_formats.is_empty()) { desc.usage |= MTLTextureUsagePixelFormatView; } // Allocate memory. bool is_linear; { Result is_linear_or_err = is_valid_linear(p_format); ERR_FAIL_COND_V(std::holds_alternative(is_linear_or_err), TextureID()); is_linear = std::get(is_linear_or_err); } // Check if it is a linear format for atomic operations and therefore needs a buffer, // as generally Metal does not support atomic operations on textures. bool needs_buffer = is_linear || (p_format.array_layers == 1 && p_format.mipmaps == 1 && p_format.texture_type == TEXTURE_TYPE_2D && flags::any(p_format.usage_bits, TEXTURE_USAGE_STORAGE_BIT) && (p_format.format == DATA_FORMAT_R32_UINT || p_format.format == DATA_FORMAT_R32_SINT)); id obj = nil; if (needs_buffer) { // Linear textures are restricted to 2D textures, a single mipmap level and a single array layer. MTLPixelFormat 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]; } else { obj = [device newTextureWithDescriptor:desc]; } ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create texture."); return rid::make(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) { ERR_FAIL_V_MSG(RDD::TextureID(), "not implemented"); } RDD::TextureID RenderingDeviceDriverMetal::texture_create_shared(TextureID p_original_texture, const TextureView &p_view) { id src_texture = rid::get(p_original_texture); #if DEV_ENABLED 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); static const MTLTextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { static_cast(255), // IDENTITY MTLTextureSwizzleZero, MTLTextureSwizzleOne, MTLTextureSwizzleRed, MTLTextureSwizzleGreen, MTLTextureSwizzleBlue, MTLTextureSwizzleAlpha, }; #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)); #undef SWIZZLE id obj = [src_texture newTextureViewWithPixelFormat:format textureType:src_texture.textureType levels:NSMakeRange(0, src_texture.mipmapLevelCount) slices:NSMakeRange(0, src_texture.arrayLength) swizzle:swizzle]; ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create shared texture"); return rid::make(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); static const MTLTextureType VIEW_TYPES[] = { MTLTextureType1D, // MTLTextureType1D MTLTextureType1D, // MTLTextureType1DArray MTLTextureType2D, // MTLTextureType2D MTLTextureType2D, // MTLTextureType2DArray MTLTextureType2D, // MTLTextureType2DMultisample MTLTextureType2D, // MTLTextureTypeCube MTLTextureType2D, // MTLTextureTypeCubeArray MTLTextureType2D, // MTLTextureType3D MTLTextureType2D, // MTLTextureType2DMultisampleArray }; MTLTextureType textureType = VIEW_TYPES[src_texture.textureType]; switch (p_slice_type) { case TEXTURE_SLICE_2D: { textureType = MTLTextureType2D; } break; case TEXTURE_SLICE_3D: { textureType = MTLTextureType3D; } break; case TEXTURE_SLICE_CUBEMAP: { textureType = MTLTextureTypeCube; } break; case TEXTURE_SLICE_2D_ARRAY: { textureType = MTLTextureType2DArray; } break; case TEXTURE_SLICE_MAX: { ERR_FAIL_V_MSG(TextureID(), "Invalid texture slice type"); } break; } MTLPixelFormat format = pixel_formats->getMTLPixelFormat(p_view.format); static const MTLTextureSwizzle component_swizzle[TEXTURE_SWIZZLE_MAX] = { static_cast(255), // IDENTITY MTLTextureSwizzleZero, MTLTextureSwizzleOne, MTLTextureSwizzleRed, MTLTextureSwizzleGreen, MTLTextureSwizzleBlue, MTLTextureSwizzleAlpha, }; #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)); #undef SWIZZLE id obj = [src_texture newTextureViewWithPixelFormat:format textureType:textureType levels:NSMakeRange(p_mipmap, p_mipmaps) slices:NSMakeRange(p_layer, p_layers) swizzle:swizzle]; ERR_FAIL_NULL_V_MSG(obj, TextureID(), "Unable to create shared texture"); return rid::make(obj); } void RenderingDeviceDriverMetal::texture_free(TextureID p_texture) { rid::release(p_texture); } uint64_t RenderingDeviceDriverMetal::texture_get_allocation_size(TextureID p_texture) { id obj = rid::get(p_texture); return obj.allocatedSize; } void RenderingDeviceDriverMetal::_get_sub_resource(TextureID p_texture, const TextureSubresource &p_subresource, TextureCopyableLayout *r_layout) const { id obj = rid::get(p_texture); *r_layout = {}; PixelFormats &pf = *pixel_formats; size_t row_alignment = get_texel_buffer_alignment_for_format(obj.pixelFormat); size_t offset = 0; size_t array_layers = obj.arrayLength; MTLSize size = MTLSizeMake(obj.width, obj.height, obj.depth); MTLPixelFormat pixel_format = obj.pixelFormat; // First skip over the mipmap levels. for (uint32_t mipLvl = 0; mipLvl < p_subresource.mipmap; mipLvl++) { MTLSize mip_size = mipmapLevelSizeFromSize(size, mipLvl); size_t bytes_per_row = pf.getBytesPerRow(pixel_format, mip_size.width); bytes_per_row = round_up_to_alignment(bytes_per_row, row_alignment); size_t bytes_per_layer = pf.getBytesPerLayer(pixel_format, bytes_per_row, mip_size.height); offset += bytes_per_layer * mip_size.depth * array_layers; } // Get current mipmap. MTLSize mip_size = mipmapLevelSizeFromSize(size, p_subresource.mipmap); size_t bytes_per_row = pf.getBytesPerRow(pixel_format, mip_size.width); bytes_per_row = round_up_to_alignment(bytes_per_row, row_alignment); size_t bytes_per_layer = pf.getBytesPerLayer(pixel_format, bytes_per_row, mip_size.height); r_layout->size = bytes_per_layer * mip_size.depth; r_layout->offset = offset + (r_layout->size * p_subresource.layer - 1); r_layout->depth_pitch = bytes_per_layer; r_layout->row_pitch = bytes_per_row; r_layout->layer_pitch = r_layout->size * array_layers; } void RenderingDeviceDriverMetal::texture_get_copyable_layout(TextureID p_texture, const TextureSubresource &p_subresource, TextureCopyableLayout *r_layout) { id obj = rid::get(p_texture); *r_layout = {}; if ((obj.resourceOptions & MTLResourceStorageModePrivate) != 0) { MTLSize sz = MTLSizeMake(obj.width, obj.height, obj.depth); PixelFormats &pf = *pixel_formats; DataFormat format = pf.getDataFormat(obj.pixelFormat); if (p_subresource.mipmap > 0) { r_layout->offset = get_image_format_required_size(format, sz.width, sz.height, sz.depth, p_subresource.mipmap); } sz = mipmapLevelSizeFromSize(sz, p_subresource.mipmap); uint32_t bw = 0, bh = 0; get_compressed_image_format_block_dimensions(format, bw, bh); uint32_t sbw = 0, sbh = 0; r_layout->size = get_image_format_required_size(format, sz.width, sz.height, sz.depth, 1, &sbw, &sbh); r_layout->row_pitch = r_layout->size / ((sbh / bh) * sz.depth); r_layout->depth_pitch = r_layout->size / sz.depth; r_layout->layer_pitch = r_layout->size / obj.arrayLength; } else { CRASH_NOW_MSG("need to calculate layout for shared texture"); } } uint8_t *RenderingDeviceDriverMetal::texture_map(TextureID p_texture, const TextureSubresource &p_subresource) { id obj = rid::get(p_texture); ERR_FAIL_NULL_V_MSG(obj.buffer, nullptr, "texture is not created from a buffer"); TextureCopyableLayout layout; _get_sub_resource(p_texture, p_subresource, &layout); return (uint8_t *)(obj.buffer.contents) + layout.offset; PixelFormats &pf = *pixel_formats; size_t row_alignment = get_texel_buffer_alignment_for_format(obj.pixelFormat); size_t offset = 0; size_t array_layers = obj.arrayLength; MTLSize size = MTLSizeMake(obj.width, obj.height, obj.depth); MTLPixelFormat pixel_format = obj.pixelFormat; // First skip over the mipmap levels. for (uint32_t mipLvl = 0; mipLvl < p_subresource.mipmap; mipLvl++) { MTLSize mipExtent = mipmapLevelSizeFromSize(size, mipLvl); size_t bytes_per_row = pf.getBytesPerRow(pixel_format, mipExtent.width); bytes_per_row = round_up_to_alignment(bytes_per_row, row_alignment); size_t bytes_per_layer = pf.getBytesPerLayer(pixel_format, bytes_per_row, mipExtent.height); offset += bytes_per_layer * mipExtent.depth * array_layers; } if (p_subresource.layer > 1) { // Calculate offset to desired layer. MTLSize mipExtent = mipmapLevelSizeFromSize(size, p_subresource.mipmap); size_t bytes_per_row = pf.getBytesPerRow(pixel_format, mipExtent.width); bytes_per_row = round_up_to_alignment(bytes_per_row, row_alignment); size_t bytes_per_layer = pf.getBytesPerLayer(pixel_format, bytes_per_row, mipExtent.height); offset += bytes_per_layer * mipExtent.depth * (p_subresource.layer - 1); } // TODO: Confirm with rendering team that there is no other way Godot may attempt to map a texture with multiple mipmaps or array layers. // NOTE: It is not possible to create a buffer-backed texture with mipmaps or array layers, // as noted in the is_valid_linear function, so the offset calculation SHOULD always be zero. // Given that, this code should be simplified. return (uint8_t *)(obj.buffer.contents) + offset; } void RenderingDeviceDriverMetal::texture_unmap(TextureID p_texture) { // Nothing to do. } 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) { return 0; } MTLFmtCaps caps = pf.getCapabilities(p_format); // Everything supported by default makes an all-or-nothing check easier for the caller. BitField supported = INT64_MAX; supported.clear_flag(TEXTURE_USAGE_VRS_ATTACHMENT_BIT); // No VRS support for Metal. if (!flags::any(caps, kMTLFmtCapsColorAtt)) { supported.clear_flag(TEXTURE_USAGE_COLOR_ATTACHMENT_BIT); } if (!flags::any(caps, kMTLFmtCapsDSAtt)) { supported.clear_flag(TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT); } if (!flags::any(caps, kMTLFmtCapsRead)) { supported.clear_flag(TEXTURE_USAGE_SAMPLING_BIT); } if (!flags::any(caps, kMTLFmtCapsAtomic)) { supported.clear_flag(TEXTURE_USAGE_STORAGE_ATOMIC_BIT); } return supported; } bool RenderingDeviceDriverMetal::texture_can_make_shared_with_format(TextureID p_texture, DataFormat p_format, bool &r_raw_reinterpretation) { r_raw_reinterpretation = false; return true; } #pragma mark - Sampler static const MTLCompareFunction COMPARE_OPERATORS[RD::COMPARE_OP_MAX] = { MTLCompareFunctionNever, MTLCompareFunctionLess, MTLCompareFunctionEqual, MTLCompareFunctionLessEqual, MTLCompareFunctionGreater, MTLCompareFunctionNotEqual, MTLCompareFunctionGreaterEqual, MTLCompareFunctionAlways, }; static const MTLStencilOperation STENCIL_OPERATIONS[RD::STENCIL_OP_MAX] = { MTLStencilOperationKeep, MTLStencilOperationZero, MTLStencilOperationReplace, MTLStencilOperationIncrementClamp, MTLStencilOperationDecrementClamp, MTLStencilOperationInvert, MTLStencilOperationIncrementWrap, MTLStencilOperationDecrementWrap, }; 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 MTLBlendOperation BLEND_OPERATIONS[RD::BLEND_OP_MAX] = { MTLBlendOperationAdd, MTLBlendOperationSubtract, MTLBlendOperationReverseSubtract, MTLBlendOperationMin, MTLBlendOperationMax, }; static const API_AVAILABLE(macos(11.0), ios(14.0)) MTLSamplerAddressMode ADDRESS_MODES[RD::SAMPLER_REPEAT_MODE_MAX] = { MTLSamplerAddressModeRepeat, MTLSamplerAddressModeMirrorRepeat, MTLSamplerAddressModeClampToEdge, MTLSamplerAddressModeClampToBorderColor, MTLSamplerAddressModeMirrorClampToEdge, }; static const API_AVAILABLE(macos(11.0), ios(14.0)) MTLSamplerBorderColor SAMPLER_BORDER_COLORS[RD::SAMPLER_BORDER_COLOR_MAX] = { MTLSamplerBorderColorTransparentBlack, MTLSamplerBorderColorTransparentBlack, MTLSamplerBorderColorOpaqueBlack, MTLSamplerBorderColorOpaqueBlack, MTLSamplerBorderColorOpaqueWhite, MTLSamplerBorderColorOpaqueWhite, }; RDD::SamplerID RenderingDeviceDriverMetal::sampler_create(const SamplerState &p_state) { MTLSamplerDescriptor *desc = [MTLSamplerDescriptor new]; desc.supportArgumentBuffers = YES; 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.sAddressMode = ADDRESS_MODES[p_state.repeat_u]; desc.tAddressMode = ADDRESS_MODES[p_state.repeat_v]; desc.rAddressMode = ADDRESS_MODES[p_state.repeat_w]; if (p_state.use_anisotropy) { desc.maxAnisotropy = p_state.anisotropy_max; } desc.compareFunction = COMPARE_OPERATORS[p_state.compare_op]; desc.lodMinClamp = p_state.min_lod; desc.lodMaxClamp = p_state.max_lod; desc.borderColor = SAMPLER_BORDER_COLORS[p_state.border_color]; desc.normalizedCoordinates = !p_state.unnormalized_uvw; if (p_state.lod_bias != 0.0) { WARN_VERBOSE("Metal does not support LOD bias for samplers."); } id obj = [device newSamplerStateWithDescriptor:desc]; ERR_FAIL_NULL_V_MSG(obj, SamplerID(), "newSamplerStateWithDescriptor failed"); return rid::make(obj); } void RenderingDeviceDriverMetal::sampler_free(SamplerID p_sampler) { rid::release(p_sampler); } bool RenderingDeviceDriverMetal::sampler_is_format_supported_for_filter(DataFormat p_format, SamplerFilter p_filter) { switch (p_filter) { case SAMPLER_FILTER_NEAREST: return true; case SAMPLER_FILTER_LINEAR: { MTLFmtCaps caps = pixel_formats->getCapabilities(p_format); return flags::any(caps, kMTLFmtCapsFilter); } } } #pragma mark - Vertex Array RDD::VertexFormatID RenderingDeviceDriverMetal::vertex_format_create(VectorView p_vertex_attribs) { MTLVertexDescriptor *desc = MTLVertexDescriptor.vertexDescriptor; for (uint32_t i = 0; i < p_vertex_attribs.size(); i++) { VertexAttribute const &vf = p_vertex_attribs[i]; ERR_FAIL_COND_V_MSG(get_format_vertex_size(vf.format) == 0, VertexFormatID(), "Data format for attachment (" + itos(i) + "), '" + FORMAT_NAMES[vf.format] + "', is not valid for a vertex array."); desc.attributes[vf.location].format = pixel_formats->getMTLVertexFormat(vf.format); desc.attributes[vf.location].offset = vf.offset; uint32_t idx = get_metal_buffer_index_for_vertex_attribute_binding(i); desc.attributes[vf.location].bufferIndex = idx; if (vf.stride == 0) { desc.layouts[idx].stepFunction = MTLVertexStepFunctionConstant; desc.layouts[idx].stepRate = 0; desc.layouts[idx].stride = pixel_formats->getBytesPerBlock(vf.format); } else { desc.layouts[idx].stepFunction = vf.frequency == VERTEX_FREQUENCY_VERTEX ? MTLVertexStepFunctionPerVertex : MTLVertexStepFunctionPerInstance; desc.layouts[idx].stepRate = 1; desc.layouts[idx].stride = vf.stride; } } return rid::make(desc); } void RenderingDeviceDriverMetal::vertex_format_free(VertexFormatID p_vertex_format) { rid::release(p_vertex_format); } #pragma mark - Barriers void RenderingDeviceDriverMetal::command_pipeline_barrier( CommandBufferID p_cmd_buffer, BitField p_src_stages, BitField p_dst_stages, VectorView p_memory_barriers, VectorView p_buffer_barriers, VectorView p_texture_barriers) { WARN_PRINT_ONCE("not implemented"); } #pragma mark - Fences RDD::FenceID RenderingDeviceDriverMetal::fence_create() { Fence *fence = memnew(Fence); return FenceID(fence); } Error RenderingDeviceDriverMetal::fence_wait(FenceID p_fence) { Fence *fence = (Fence *)(p_fence.id); // Wait forever, so this function is infallible. dispatch_semaphore_wait(fence->semaphore, DISPATCH_TIME_FOREVER); return OK; } 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) { } #pragma mark - Queues RDD::CommandQueueFamilyID RenderingDeviceDriverMetal::command_queue_family_get(BitField p_cmd_queue_family_bits, RenderingContextDriver::SurfaceID p_surface) { if (p_cmd_queue_family_bits.has_flag(COMMAND_QUEUE_FAMILY_GRAPHICS_BIT) || (p_surface != 0)) { return CommandQueueFamilyID(COMMAND_QUEUE_FAMILY_GRAPHICS_BIT); } else if (p_cmd_queue_family_bits.has_flag(COMMAND_QUEUE_FAMILY_COMPUTE_BIT)) { return CommandQueueFamilyID(COMMAND_QUEUE_FAMILY_COMPUTE_BIT); } else if (p_cmd_queue_family_bits.has_flag(COMMAND_QUEUE_FAMILY_TRANSFER_BIT)) { return CommandQueueFamilyID(COMMAND_QUEUE_FAMILY_TRANSFER_BIT); } else { return CommandQueueFamilyID(); } } 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->get_command_buffer() addCompletedHandler:^(id buffer) { dispatch_semaphore_signal(fence->semaphore); }]; } 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); } 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); obj->begin(); return true; } bool RenderingDeviceDriverMetal::command_buffer_begin_secondary(CommandBufferID p_cmd_buffer, RenderPassID p_render_pass, uint32_t p_subpass, FramebufferID p_framebuffer) { ERR_FAIL_V_MSG(false, "not implemented"); } void RenderingDeviceDriverMetal::command_buffer_end(CommandBufferID p_cmd_buffer) { MDCommandBuffer *obj = (MDCommandBuffer *)(p_cmd_buffer.id); obj->end(); } void RenderingDeviceDriverMetal::command_buffer_execute_secondary(CommandBufferID p_cmd_buffer, VectorView p_secondary_cmd_buffers) { ERR_FAIL_MSG("not implemented"); } #pragma mark - Swap Chain void RenderingDeviceDriverMetal::_swap_chain_release(SwapChain *p_swap_chain) { _swap_chain_release_buffers(p_swap_chain); } void RenderingDeviceDriverMetal::_swap_chain_release_buffers(SwapChain *p_swap_chain) { } RDD::SwapChainID RenderingDeviceDriverMetal::swap_chain_create(RenderingContextDriver::SurfaceID p_surface) { RenderingContextDriverMetal::Surface const *surface = (RenderingContextDriverMetal::Surface *)(p_surface); // Create the render pass that will be used to draw to the swap chain's framebuffers. RDD::Attachment attachment; attachment.format = pixel_formats->getDataFormat(surface->get_pixel_format()); attachment.samples = RDD::TEXTURE_SAMPLES_1; attachment.load_op = RDD::ATTACHMENT_LOAD_OP_CLEAR; attachment.store_op = RDD::ATTACHMENT_STORE_OP_STORE; RDD::Subpass subpass; RDD::AttachmentReference color_ref; color_ref.attachment = 0; color_ref.aspect.set_flag(RDD::TEXTURE_ASPECT_COLOR_BIT); subpass.color_references.push_back(color_ref); RenderPassID render_pass = render_pass_create(attachment, subpass, {}, 1); ERR_FAIL_COND_V(!render_pass, SwapChainID()); // Create the empty swap chain until it is resized. SwapChain *swap_chain = memnew(SwapChain); swap_chain->surface = p_surface; swap_chain->data_format = attachment.format; swap_chain->render_pass = render_pass; return SwapChainID(swap_chain); } Error RenderingDeviceDriverMetal::swap_chain_resize(CommandQueueID p_cmd_queue, SwapChainID p_swap_chain, uint32_t p_desired_framebuffer_count) { DEV_ASSERT(p_cmd_queue.id != 0); DEV_ASSERT(p_swap_chain.id != 0); SwapChain *swap_chain = (SwapChain *)(p_swap_chain.id); RenderingContextDriverMetal::Surface *surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); surface->resize(p_desired_framebuffer_count); // Once everything's been created correctly, indicate the surface no longer needs to be resized. context_driver->surface_set_needs_resize(swap_chain->surface, false); return OK; } RDD::FramebufferID RenderingDeviceDriverMetal::swap_chain_acquire_framebuffer(CommandQueueID p_cmd_queue, SwapChainID p_swap_chain, bool &r_resize_required) { DEV_ASSERT(p_cmd_queue.id != 0); DEV_ASSERT(p_swap_chain.id != 0); SwapChain *swap_chain = (SwapChain *)(p_swap_chain.id); if (context_driver->surface_get_needs_resize(swap_chain->surface)) { r_resize_required = true; return FramebufferID(); } RenderingContextDriverMetal::Surface *metal_surface = (RenderingContextDriverMetal::Surface *)(swap_chain->surface); return metal_surface->acquire_next_frame_buffer(); } RDD::RenderPassID RenderingDeviceDriverMetal::swap_chain_get_render_pass(SwapChainID p_swap_chain) { const SwapChain *swap_chain = (const SwapChain *)(p_swap_chain.id); return swap_chain->render_pass; } RDD::DataFormat RenderingDeviceDriverMetal::swap_chain_get_format(SwapChainID p_swap_chain) { const SwapChain *swap_chain = (const SwapChain *)(p_swap_chain.id); return swap_chain->data_format; } void RenderingDeviceDriverMetal::swap_chain_free(SwapChainID p_swap_chain) { SwapChain *swap_chain = (SwapChain *)(p_swap_chain.id); _swap_chain_release(swap_chain); render_pass_free(swap_chain->render_pass); memdelete(swap_chain); } #pragma mark - Frame buffer 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; 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) { #if DEV_ENABLED WARN_PRINT("Invalid texture for attachment " + itos(i)); #endif } if (a.samples > 1) { 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)); #endif } } textures.write[i] = tex; } MDFrameBuffer *fb = new 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; } #pragma mark - Shader const uint32_t SHADER_BINARY_VERSION = 1; // region Serialization class BufWriter; template concept Serializable = requires(T t, BufWriter &p_writer) { { t.serialize_size() } -> std::same_as; { t.serialize(p_writer) } -> std::same_as; }; class BufWriter { uint8_t *data = nullptr; uint64_t length = 0; // Length of data. uint64_t pos = 0; public: BufWriter(uint8_t *p_data, uint64_t p_length) : data(p_data), length(p_length) {} template void write(T const &p_value) { p_value.serialize(*this); } _FORCE_INLINE_ void write(uint32_t p_value) { DEV_ASSERT(pos + sizeof(uint32_t) <= length); pos += encode_uint32(p_value, data + pos); } _FORCE_INLINE_ void write(RD::ShaderStage p_value) { write((uint32_t)p_value); } _FORCE_INLINE_ void write(bool p_value) { DEV_ASSERT(pos + sizeof(uint8_t) <= length); *(data + pos) = p_value ? 1 : 0; pos += 1; } _FORCE_INLINE_ void write(int p_value) { write((uint32_t)p_value); } _FORCE_INLINE_ void write(uint64_t p_value) { DEV_ASSERT(pos + sizeof(uint64_t) <= length); pos += encode_uint64(p_value, data + pos); } _FORCE_INLINE_ void write(float p_value) { DEV_ASSERT(pos + sizeof(float) <= length); pos += encode_float(p_value, data + pos); } _FORCE_INLINE_ void write(double p_value) { DEV_ASSERT(pos + sizeof(double) <= length); pos += encode_double(p_value, data + pos); } void write_compressed(CharString const &p_string) { write(p_string.length()); // Uncompressed size. DEV_ASSERT(pos + sizeof(uint32_t) + Compression::get_max_compressed_buffer_size(p_string.length(), Compression::MODE_ZSTD) <= length); // Save pointer for compressed size. uint8_t *dst_size_ptr = data + pos; // Compressed size. pos += sizeof(uint32_t); int dst_size = Compression::compress(data + pos, reinterpret_cast(p_string.ptr()), p_string.length(), Compression::MODE_ZSTD); encode_uint32(dst_size, dst_size_ptr); pos += dst_size; } void write(CharString const &p_string) { write_buffer(reinterpret_cast(p_string.ptr()), p_string.length()); } template void write(VectorView p_vector) { write(p_vector.size()); for (uint32_t i = 0; i < p_vector.size(); i++) { T const &e = p_vector[i]; write(e); } } void write(VectorView p_vector) { write_buffer(p_vector.ptr(), p_vector.size()); } template void write(HashMap const &p_map) { write(p_map.size()); for (KeyValue const &e : p_map) { write(e.key); write(e.value); } } uint64_t get_pos() const { return pos; } uint64_t get_length() const { return length; } private: void write_buffer(uint8_t const *p_buffer, uint32_t p_length) { write(p_length); DEV_ASSERT(pos + p_length <= length); memcpy(data + pos, p_buffer, p_length); pos += p_length; } }; class BufReader; template concept Deserializable = requires(T t, BufReader &p_reader) { { t.serialize_size() } -> std::same_as; { t.deserialize(p_reader) } -> std::same_as; }; class BufReader { uint8_t const *data = nullptr; uint64_t length = 0; uint64_t pos = 0; bool check_length(size_t p_size) { if (status != Status::OK) return false; if (pos + p_size > length) { status = Status::SHORT_BUFFER; return false; } return true; } #define CHECK(p_size) \ if (!check_length(p_size)) \ return public: enum class Status { OK, SHORT_BUFFER, BAD_COMPRESSION, }; Status status = Status::OK; BufReader(uint8_t const *p_data, uint64_t p_length) : data(p_data), length(p_length) {} template void read(T &p_value) { p_value.deserialize(*this); } _FORCE_INLINE_ void read(uint32_t &p_val) { CHECK(sizeof(uint32_t)); p_val = decode_uint32(data + pos); pos += sizeof(uint32_t); } _FORCE_INLINE_ void read(RD::ShaderStage &p_val) { uint32_t val; read(val); p_val = (RD::ShaderStage)val; } _FORCE_INLINE_ void read(bool &p_val) { CHECK(sizeof(uint8_t)); p_val = *(data + pos) > 0; pos += 1; } _FORCE_INLINE_ void read(uint64_t &p_val) { CHECK(sizeof(uint64_t)); p_val = decode_uint64(data + pos); pos += sizeof(uint64_t); } _FORCE_INLINE_ void read(float &p_val) { CHECK(sizeof(float)); p_val = decode_float(data + pos); pos += sizeof(float); } _FORCE_INLINE_ void read(double &p_val) { CHECK(sizeof(double)); p_val = decode_double(data + pos); pos += sizeof(double); } void read(CharString &p_val) { uint32_t len; read(len); CHECK(len); p_val.resize(len + 1 /* NUL */); memcpy(p_val.ptrw(), data + pos, len); p_val.set(len, 0); pos += len; } void read_compressed(CharString &p_val) { uint32_t len; read(len); uint32_t comp_size; read(comp_size); CHECK(comp_size); p_val.resize(len + 1 /* NUL */); uint32_t bytes = (uint32_t)Compression::decompress(reinterpret_cast(p_val.ptrw()), len, data + pos, comp_size, Compression::MODE_ZSTD); if (bytes != len) { status = Status::BAD_COMPRESSION; return; } p_val.set(len, 0); pos += comp_size; } void read(LocalVector &p_val) { uint32_t len; read(len); CHECK(len); p_val.resize(len); memcpy(p_val.ptr(), data + pos, len); pos += len; } template void read(LocalVector &p_val) { uint32_t len; read(len); CHECK(len); p_val.resize(len); for (uint32_t i = 0; i < len; i++) { read(p_val[i]); } } template void read(HashMap &p_map) { uint32_t len; read(len); CHECK(len); p_map.reserve(len); for (uint32_t i = 0; i < len; i++) { K key; read(key); V value; read(value); p_map[key] = value; } } #undef CHECK }; const uint32_t R32UI_ALIGNMENT_CONSTANT_ID = 65535; struct ComputeSize { uint32_t x = 0; uint32_t y = 0; uint32_t z = 0; size_t serialize_size() const { return sizeof(uint32_t) * 3; } void serialize(BufWriter &p_writer) const { p_writer.write(x); p_writer.write(y); p_writer.write(z); } void deserialize(BufReader &p_reader) { p_reader.read(x); p_reader.read(y); p_reader.read(z); } }; struct ShaderStageData { RD::ShaderStage stage = RD::ShaderStage::SHADER_STAGE_MAX; CharString entry_point_name; CharString source; size_t serialize_size() const { int comp_size = Compression::get_max_compressed_buffer_size(source.length(), Compression::MODE_ZSTD); return sizeof(uint32_t) // Stage. + sizeof(uint32_t) /* entry_point_name.utf8().length */ + entry_point_name.length() + sizeof(uint32_t) /* uncompressed size */ + sizeof(uint32_t) /* compressed size */ + comp_size; } void serialize(BufWriter &p_writer) const { p_writer.write((uint32_t)stage); p_writer.write(entry_point_name); p_writer.write_compressed(source); } void deserialize(BufReader &p_reader) { p_reader.read((uint32_t &)stage); p_reader.read(entry_point_name); p_reader.read_compressed(source); } }; struct SpecializationConstantData { uint32_t constant_id = UINT32_MAX; RD::PipelineSpecializationConstantType type = RD::PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT; ShaderStageUsage stages = ShaderStageUsage::None; // Specifies the stages the constant is used by Metal. ShaderStageUsage used_stages = ShaderStageUsage::None; uint32_t int_value = UINT32_MAX; size_t serialize_size() const { return sizeof(constant_id) + sizeof(uint32_t) // type + sizeof(stages) + sizeof(used_stages) // used_stages + sizeof(int_value); // int_value } void serialize(BufWriter &p_writer) const { p_writer.write(constant_id); p_writer.write((uint32_t)type); p_writer.write(stages); p_writer.write(used_stages); p_writer.write(int_value); } void deserialize(BufReader &p_reader) { p_reader.read(constant_id); p_reader.read((uint32_t &)type); p_reader.read((uint32_t &)stages); p_reader.read((uint32_t &)used_stages); p_reader.read(int_value); } }; struct API_AVAILABLE(macos(11.0), ios(14.0)) UniformData { RD::UniformType type = RD::UniformType::UNIFORM_TYPE_MAX; uint32_t binding = UINT32_MAX; bool writable = false; uint32_t length = UINT32_MAX; ShaderStageUsage stages = ShaderStageUsage::None; // Specifies the stages the uniform data is // used by the Metal shader. ShaderStageUsage active_stages = ShaderStageUsage::None; BindingInfoMap bindings; BindingInfoMap bindings_secondary; size_t serialize_size() const { size_t size = 0; size += sizeof(uint32_t); // type size += sizeof(uint32_t); // binding size += sizeof(uint32_t); // writable size += sizeof(uint32_t); // length size += sizeof(uint32_t); // stages size += sizeof(uint32_t); // active_stages size += sizeof(uint32_t); // bindings.size() size += sizeof(uint32_t) * bindings.size(); // Total size of keys. for (KeyValue const &e : bindings) { size += e.value.serialize_size(); } size += sizeof(uint32_t); // bindings_secondary.size() size += sizeof(uint32_t) * bindings_secondary.size(); // Total size of keys. for (KeyValue const &e : bindings_secondary) { size += e.value.serialize_size(); } return size; } void serialize(BufWriter &p_writer) const { p_writer.write((uint32_t)type); p_writer.write(binding); p_writer.write(writable); p_writer.write(length); p_writer.write(stages); p_writer.write(active_stages); p_writer.write(bindings); p_writer.write(bindings_secondary); } void deserialize(BufReader &p_reader) { p_reader.read((uint32_t &)type); p_reader.read(binding); p_reader.read(writable); p_reader.read(length); p_reader.read((uint32_t &)stages); p_reader.read((uint32_t &)active_stages); p_reader.read(bindings); p_reader.read(bindings_secondary); } }; struct API_AVAILABLE(macos(11.0), ios(14.0)) UniformSetData { uint32_t index = UINT32_MAX; LocalVector uniforms; size_t serialize_size() const { size_t size = 0; size += sizeof(uint32_t); // index size += sizeof(uint32_t); // uniforms.size() for (UniformData const &e : uniforms) { size += e.serialize_size(); } return size; } void serialize(BufWriter &p_writer) const { p_writer.write(index); p_writer.write(VectorView(uniforms)); } void deserialize(BufReader &p_reader) { p_reader.read(index); p_reader.read(uniforms); } }; struct PushConstantData { uint32_t size = UINT32_MAX; ShaderStageUsage stages = ShaderStageUsage::None; ShaderStageUsage used_stages = ShaderStageUsage::None; HashMap msl_binding; size_t serialize_size() const { return sizeof(uint32_t) // size + sizeof(uint32_t) // stages + sizeof(uint32_t) // used_stages + sizeof(uint32_t) // msl_binding.size() + sizeof(uint32_t) * msl_binding.size() // keys + sizeof(uint32_t) * msl_binding.size(); // values } void serialize(BufWriter &p_writer) const { p_writer.write(size); p_writer.write((uint32_t)stages); p_writer.write((uint32_t)used_stages); p_writer.write(msl_binding); } void deserialize(BufReader &p_reader) { p_reader.read(size); p_reader.read((uint32_t &)stages); p_reader.read((uint32_t &)used_stages); p_reader.read(msl_binding); } }; struct API_AVAILABLE(macos(11.0), ios(14.0)) ShaderBinaryData { CharString shader_name; // The Metal language version specified when compiling SPIR-V to MSL. // Format is major * 10000 + minor * 100 + patch. uint32_t msl_version = UINT32_MAX; uint32_t vertex_input_mask = UINT32_MAX; uint32_t fragment_output_mask = UINT32_MAX; uint32_t spirv_specialization_constants_ids_mask = UINT32_MAX; uint32_t is_compute = UINT32_MAX; ComputeSize compute_local_size; PushConstantData push_constant; LocalVector stages; LocalVector constants; LocalVector uniforms; MTLLanguageVersion get_msl_version() const { uint32_t major = msl_version / 10000; uint32_t minor = (msl_version / 100) % 100; return MTLLanguageVersion((major << 0x10) + minor); } size_t serialize_size() const { size_t size = 0; size += sizeof(uint32_t) + shader_name.length(); // shader_name size += sizeof(uint32_t); // msl_version size += sizeof(uint32_t); // vertex_input_mask size += sizeof(uint32_t); // fragment_output_mask size += sizeof(uint32_t); // spirv_specialization_constants_ids_mask size += sizeof(uint32_t); // is_compute size += compute_local_size.serialize_size(); // compute_local_size size += push_constant.serialize_size(); // push_constant size += sizeof(uint32_t); // stages.size() for (ShaderStageData const &e : stages) { size += e.serialize_size(); } size += sizeof(uint32_t); // constants.size() for (SpecializationConstantData const &e : constants) { size += e.serialize_size(); } size += sizeof(uint32_t); // uniforms.size() for (UniformSetData const &e : uniforms) { size += e.serialize_size(); } return size; } void serialize(BufWriter &p_writer) const { p_writer.write(shader_name); p_writer.write(msl_version); p_writer.write(vertex_input_mask); p_writer.write(fragment_output_mask); p_writer.write(spirv_specialization_constants_ids_mask); p_writer.write(is_compute); p_writer.write(compute_local_size); p_writer.write(push_constant); p_writer.write(VectorView(stages)); p_writer.write(VectorView(constants)); p_writer.write(VectorView(uniforms)); } void deserialize(BufReader &p_reader) { p_reader.read(shader_name); p_reader.read(msl_version); p_reader.read(vertex_input_mask); p_reader.read(fragment_output_mask); p_reader.read(spirv_specialization_constants_ids_mask); p_reader.read(is_compute); p_reader.read(compute_local_size); p_reader.read(push_constant); p_reader.read(stages); p_reader.read(constants); p_reader.read(uniforms); } }; // endregion String RenderingDeviceDriverMetal::shader_get_binary_cache_key() { return "Metal-SV" + uitos(SHADER_BINARY_VERSION); } Error RenderingDeviceDriverMetal::_reflect_spirv16(VectorView p_spirv, ShaderReflection &r_reflection) { using namespace spirv_cross; using spirv_cross::Resource; r_reflection = {}; for (uint32_t i = 0; i < p_spirv.size(); i++) { ShaderStageSPIRVData const &v = p_spirv[i]; ShaderStage stage = v.shader_stage; uint32_t const *const ir = reinterpret_cast(v.spirv.ptr()); size_t word_count = v.spirv.size() / sizeof(uint32_t); Parser parser(ir, word_count); try { parser.parse(); } catch (CompilerError &e) { ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Failed to parse IR at stage " + String(SHADER_STAGE_NAMES[stage]) + ": " + e.what()); } ShaderStage stage_flag = (ShaderStage)(1 << p_spirv[i].shader_stage); if (p_spirv[i].shader_stage == SHADER_STAGE_COMPUTE) { r_reflection.is_compute = true; ERR_FAIL_COND_V_MSG(p_spirv.size() != 1, FAILED, "Compute shaders can only receive one stage, dedicated to compute."); } ERR_FAIL_COND_V_MSG(r_reflection.stages.has_flag(stage_flag), FAILED, "Stage " + String(SHADER_STAGE_NAMES[p_spirv[i].shader_stage]) + " submitted more than once."); ParsedIR &pir = parser.get_parsed_ir(); using BT = SPIRType::BaseType; Compiler compiler(std::move(pir)); if (r_reflection.is_compute) { r_reflection.compute_local_size[0] = compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 0); r_reflection.compute_local_size[1] = compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 1); r_reflection.compute_local_size[2] = compiler.get_execution_mode_argument(spv::ExecutionModeLocalSize, 2); } // Parse bindings. auto get_decoration = [&compiler](spirv_cross::ID id, spv::Decoration decoration) { uint32_t res = -1; if (compiler.has_decoration(id, decoration)) { res = compiler.get_decoration(id, decoration); } return res; }; // Always clearer than a boolean. enum class Writable { No, Maybe, }; // clang-format off enum { SPIRV_WORD_SIZE = sizeof(uint32_t), SPIRV_DATA_ALIGNMENT = 4 * SPIRV_WORD_SIZE, }; // clang-format on auto process_uniforms = [&r_reflection, &compiler, &get_decoration, stage, stage_flag](SmallVector &resources, Writable writable, std::function uniform_type) { for (Resource const &res : resources) { ShaderUniform uniform; std::string const &name = compiler.get_name(res.id); uint32_t set = get_decoration(res.id, spv::DecorationDescriptorSet); ERR_FAIL_COND_V_MSG(set == (uint32_t)-1, FAILED, "No descriptor set found"); ERR_FAIL_COND_V_MSG(set >= MAX_UNIFORM_SETS, FAILED, "On shader stage '" + String(SHADER_STAGE_NAMES[stage]) + "', uniform '" + name.c_str() + "' uses a set (" + itos(set) + ") index larger than what is supported (" + itos(MAX_UNIFORM_SETS) + ")."); uniform.binding = get_decoration(res.id, spv::DecorationBinding); ERR_FAIL_COND_V_MSG(uniform.binding == (uint32_t)-1, FAILED, "No binding found"); SPIRType const &a_type = compiler.get_type(res.type_id); uniform.type = uniform_type(a_type); // Update length. switch (a_type.basetype) { case BT::Struct: { if (uniform.type == UNIFORM_TYPE_STORAGE_BUFFER) { // Consistent with spirv_reflect. uniform.length = 0; } else { uniform.length = round_up_to_alignment(compiler.get_declared_struct_size(a_type), SPIRV_DATA_ALIGNMENT); } } break; case BT::Image: case BT::Sampler: case BT::SampledImage: { uniform.length = 1; for (uint32_t const &a : a_type.array) { uniform.length *= a; } } break; default: break; } // Update writable. if (writable == Writable::Maybe) { if (a_type.basetype == BT::Struct) { Bitset flags = compiler.get_buffer_block_flags(res.id); uniform.writable = !compiler.has_decoration(res.id, spv::DecorationNonWritable) && !flags.get(spv::DecorationNonWritable); } else if (a_type.basetype == BT::Image) { if (a_type.image.access == spv::AccessQualifierMax) { uniform.writable = !compiler.has_decoration(res.id, spv::DecorationNonWritable); } else { uniform.writable = a_type.image.access != spv::AccessQualifierReadOnly; } } } if (set < (uint32_t)r_reflection.uniform_sets.size()) { // Check if this already exists. bool exists = false; for (uint32_t k = 0; k < r_reflection.uniform_sets[set].size(); k++) { if (r_reflection.uniform_sets[set][k].binding == uniform.binding) { // Already exists, verify that it's the same type. ERR_FAIL_COND_V_MSG(r_reflection.uniform_sets[set][k].type != uniform.type, FAILED, "On shader stage '" + String(SHADER_STAGE_NAMES[stage]) + "', uniform '" + name.c_str() + "' trying to reuse location for set=" + itos(set) + ", binding=" + itos(uniform.binding) + " with different uniform type."); // Also, verify that it's the same size. ERR_FAIL_COND_V_MSG(r_reflection.uniform_sets[set][k].length != uniform.length, FAILED, "On shader stage '" + String(SHADER_STAGE_NAMES[stage]) + "', uniform '" + name.c_str() + "' trying to reuse location for set=" + itos(set) + ", binding=" + itos(uniform.binding) + " with different uniform size."); // Also, verify that it has the same writability. ERR_FAIL_COND_V_MSG(r_reflection.uniform_sets[set][k].writable != uniform.writable, FAILED, "On shader stage '" + String(SHADER_STAGE_NAMES[stage]) + "', uniform '" + name.c_str() + "' trying to reuse location for set=" + itos(set) + ", binding=" + itos(uniform.binding) + " with different writability."); // Just append stage mask and continue. r_reflection.uniform_sets.write[set].write[k].stages.set_flag(stage_flag); exists = true; break; } } if (exists) { continue; // Merged. } } uniform.stages.set_flag(stage_flag); if (set >= (uint32_t)r_reflection.uniform_sets.size()) { r_reflection.uniform_sets.resize(set + 1); } r_reflection.uniform_sets.write[set].push_back(uniform); } return OK; }; ShaderResources resources = compiler.get_shader_resources(); process_uniforms(resources.uniform_buffers, Writable::No, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Struct); return UNIFORM_TYPE_UNIFORM_BUFFER; }); process_uniforms(resources.storage_buffers, Writable::Maybe, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Struct); return UNIFORM_TYPE_STORAGE_BUFFER; }); process_uniforms(resources.storage_images, Writable::Maybe, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Image); if (a_type.image.dim == spv::DimBuffer) { return UNIFORM_TYPE_IMAGE_BUFFER; } else { return UNIFORM_TYPE_IMAGE; } }); process_uniforms(resources.sampled_images, Writable::No, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::SampledImage); return UNIFORM_TYPE_SAMPLER_WITH_TEXTURE; }); process_uniforms(resources.separate_images, Writable::No, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Image); if (a_type.image.dim == spv::DimBuffer) { return UNIFORM_TYPE_TEXTURE_BUFFER; } else { return UNIFORM_TYPE_TEXTURE; } }); process_uniforms(resources.separate_samplers, Writable::No, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Sampler); return UNIFORM_TYPE_SAMPLER; }); process_uniforms(resources.subpass_inputs, Writable::No, [](SPIRType const &a_type) { DEV_ASSERT(a_type.basetype == BT::Image && a_type.image.dim == spv::DimSubpassData); return UNIFORM_TYPE_INPUT_ATTACHMENT; }); if (!resources.push_constant_buffers.empty()) { // There can be only one push constant block. Resource const &res = resources.push_constant_buffers.front(); size_t push_constant_size = round_up_to_alignment(compiler.get_declared_struct_size(compiler.get_type(res.base_type_id)), SPIRV_DATA_ALIGNMENT); ERR_FAIL_COND_V_MSG(r_reflection.push_constant_size && r_reflection.push_constant_size != push_constant_size, FAILED, "Reflection of SPIR-V shader stage '" + String(SHADER_STAGE_NAMES[p_spirv[i].shader_stage]) + "': Push constant block must be the same across shader stages."); r_reflection.push_constant_size = push_constant_size; r_reflection.push_constant_stages.set_flag(stage_flag); } ERR_FAIL_COND_V_MSG(!resources.atomic_counters.empty(), FAILED, "Atomic counters not supported"); ERR_FAIL_COND_V_MSG(!resources.acceleration_structures.empty(), FAILED, "Acceleration structures not supported"); ERR_FAIL_COND_V_MSG(!resources.shader_record_buffers.empty(), FAILED, "Shader record buffers not supported"); if (stage == SHADER_STAGE_VERTEX && !resources.stage_inputs.empty()) { for (Resource const &res : resources.stage_inputs) { SPIRType a_type = compiler.get_type(res.base_type_id); uint32_t loc = get_decoration(res.id, spv::DecorationLocation); if (loc != (uint32_t)-1) { r_reflection.vertex_input_mask |= 1 << loc; } } } if (stage == SHADER_STAGE_FRAGMENT && !resources.stage_outputs.empty()) { for (Resource const &res : resources.stage_outputs) { SPIRType a_type = compiler.get_type(res.base_type_id); uint32_t loc = get_decoration(res.id, spv::DecorationLocation); uint32_t built_in = spv::BuiltIn(get_decoration(res.id, spv::DecorationBuiltIn)); if (loc != (uint32_t)-1 && built_in != spv::BuiltInFragDepth) { r_reflection.fragment_output_mask |= 1 << loc; } } } // Specialization constants. for (SpecializationConstant const &constant : compiler.get_specialization_constants()) { int32_t existing = -1; ShaderSpecializationConstant sconst; SPIRConstant &spc = compiler.get_constant(constant.id); SPIRType const &spct = compiler.get_type(spc.constant_type); sconst.constant_id = constant.constant_id; sconst.int_value = 0; switch (spct.basetype) { case BT::Boolean: { sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_BOOL; sconst.bool_value = spc.scalar() != 0; } break; case BT::Int: case BT::UInt: { sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_INT; sconst.int_value = spc.scalar(); } break; case BT::Float: { sconst.type = PIPELINE_SPECIALIZATION_CONSTANT_TYPE_FLOAT; sconst.float_value = spc.scalar_f32(); } break; default: ERR_FAIL_V_MSG(FAILED, "Unsupported specialization constant type"); } sconst.stages.set_flag(stage_flag); for (uint32_t k = 0; k < r_reflection.specialization_constants.size(); k++) { if (r_reflection.specialization_constants[k].constant_id == sconst.constant_id) { ERR_FAIL_COND_V_MSG(r_reflection.specialization_constants[k].type != sconst.type, FAILED, "More than one specialization constant used for id (" + itos(sconst.constant_id) + "), but their types differ."); ERR_FAIL_COND_V_MSG(r_reflection.specialization_constants[k].int_value != sconst.int_value, FAILED, "More than one specialization constant used for id (" + itos(sconst.constant_id) + "), but their default values differ."); existing = k; break; } } if (existing > 0) { r_reflection.specialization_constants.write[existing].stages.set_flag(stage_flag); } else { r_reflection.specialization_constants.push_back(sconst); } } r_reflection.stages.set_flag(stage_flag); } // Sort all uniform_sets. for (uint32_t i = 0; i < r_reflection.uniform_sets.size(); i++) { r_reflection.uniform_sets.write[i].sort(); } return OK; } Vector RenderingDeviceDriverMetal::shader_compile_binary_from_spirv(VectorView p_spirv, const String &p_shader_name) { using Result = ::Vector; using namespace spirv_cross; using spirv_cross::CompilerMSL; using spirv_cross::Resource; ShaderReflection spirv_data; ERR_FAIL_COND_V(_reflect_spirv16(p_spirv, spirv_data), Result()); ShaderBinaryData bin_data{}; if (!p_shader_name.is_empty()) { bin_data.shader_name = p_shader_name.utf8(); } else { bin_data.shader_name = "unnamed"; } bin_data.vertex_input_mask = spirv_data.vertex_input_mask; bin_data.fragment_output_mask = spirv_data.fragment_output_mask; bin_data.compute_local_size = ComputeSize{ .x = spirv_data.compute_local_size[0], .y = spirv_data.compute_local_size[1], .z = spirv_data.compute_local_size[2], }; bin_data.is_compute = spirv_data.is_compute; bin_data.push_constant.size = spirv_data.push_constant_size; bin_data.push_constant.stages = (ShaderStageUsage)(uint8_t)spirv_data.push_constant_stages; for (uint32_t i = 0; i < spirv_data.uniform_sets.size(); i++) { const ::Vector &spirv_set = spirv_data.uniform_sets[i]; UniformSetData set{ .index = i }; for (const ShaderUniform &spirv_uniform : spirv_set) { UniformData binding{}; binding.type = spirv_uniform.type; binding.binding = spirv_uniform.binding; binding.writable = spirv_uniform.writable; binding.stages = (ShaderStageUsage)(uint8_t)spirv_uniform.stages; binding.length = spirv_uniform.length; set.uniforms.push_back(binding); } bin_data.uniforms.push_back(set); } for (const ShaderSpecializationConstant &spirv_sc : spirv_data.specialization_constants) { SpecializationConstantData spec_constant{}; spec_constant.type = spirv_sc.type; spec_constant.constant_id = spirv_sc.constant_id; spec_constant.int_value = spirv_sc.int_value; spec_constant.stages = (ShaderStageUsage)(uint8_t)spirv_sc.stages; bin_data.constants.push_back(spec_constant); bin_data.spirv_specialization_constants_ids_mask |= (1 << spirv_sc.constant_id); } // Reflection using SPIRV-Cross: // https://github.com/KhronosGroup/SPIRV-Cross/wiki/Reflection-API-user-guide CompilerMSL::Options msl_options{}; msl_options.set_msl_version(version_major, version_minor); if (version_major == 3 && version_minor >= 1) { // TODO(sgc): Restrict to Metal 3.0 for now, until bugs in SPIRV-cross image atomics are resolved. msl_options.set_msl_version(3, 0); } bin_data.msl_version = msl_options.msl_version; #if TARGET_OS_OSX msl_options.platform = CompilerMSL::Options::macOS; #else msl_options.platform = CompilerMSL::Options::iOS; #endif #if TARGET_OS_IOS msl_options.ios_use_simdgroup_functions = (*metal_device_properties).features.simdPermute; #endif msl_options.argument_buffers = true; msl_options.force_active_argument_buffer_resources = true; // Same as MoltenVK when using argument buffers. // msl_options.pad_argument_buffer_resources = true; // Same as MoltenVK when using argument buffers. msl_options.texture_buffer_native = true; // Enable texture buffer support. msl_options.use_framebuffer_fetch_subpasses = false; msl_options.pad_fragment_output_components = true; msl_options.r32ui_alignment_constant_id = R32UI_ALIGNMENT_CONSTANT_ID; msl_options.agx_manual_cube_grad_fixup = true; CompilerGLSL::Options options{}; options.vertex.flip_vert_y = true; #if DEV_ENABLED options.emit_line_directives = true; #endif for (uint32_t i = 0; i < p_spirv.size(); i++) { ShaderStageSPIRVData const &v = p_spirv[i]; ShaderStage stage = v.shader_stage; char const *stage_name = SHADER_STAGE_NAMES[stage]; uint32_t const *const ir = reinterpret_cast(v.spirv.ptr()); size_t word_count = v.spirv.size() / sizeof(uint32_t); Parser parser(ir, word_count); try { parser.parse(); } catch (CompilerError &e) { ERR_FAIL_V_MSG(Result(), "Failed to parse IR at stage " + String(SHADER_STAGE_NAMES[stage]) + ": " + e.what()); } CompilerMSL compiler(std::move(parser.get_parsed_ir())); compiler.set_msl_options(msl_options); compiler.set_common_options(options); std::unordered_set active = compiler.get_active_interface_variables(); ShaderResources resources = compiler.get_shader_resources(); std::string source = compiler.compile(); ERR_FAIL_COND_V_MSG(compiler.get_entry_points_and_stages().size() != 1, Result(), "Expected a single entry point and stage."); EntryPoint &entry_point_stage = compiler.get_entry_points_and_stages().front(); SPIREntryPoint &entry_point = compiler.get_entry_point(entry_point_stage.name, entry_point_stage.execution_model); // Process specialization constants. if (!compiler.get_specialization_constants().empty()) { for (SpecializationConstant const &constant : compiler.get_specialization_constants()) { LocalVector::Iterator res = bin_data.constants.begin(); while (res != bin_data.constants.end()) { if (res->constant_id == constant.constant_id) { res->used_stages |= 1 << stage; break; } ++res; } if (res == bin_data.constants.end()) { WARN_PRINT(String(stage_name) + ": unable to find constant_id: " + itos(constant.constant_id)); } } } // Process bindings. LocalVector &uniform_sets = bin_data.uniforms; using BT = SPIRType::BaseType; // Always clearer than a boolean. enum class Writable { No, Maybe, }; // Returns a std::optional containing the value of the // decoration, if it exists. auto get_decoration = [&compiler](spirv_cross::ID id, spv::Decoration decoration) { uint32_t res = -1; if (compiler.has_decoration(id, decoration)) { res = compiler.get_decoration(id, decoration); } return res; }; auto descriptor_bindings = [&compiler, &active, &uniform_sets, stage, &get_decoration](SmallVector &resources, Writable writable) { for (Resource const &res : resources) { uint32_t dset = get_decoration(res.id, spv::DecorationDescriptorSet); uint32_t dbin = get_decoration(res.id, spv::DecorationBinding); UniformData *found = nullptr; if (dset != (uint32_t)-1 && dbin != (uint32_t)-1 && dset < uniform_sets.size()) { UniformSetData &set = uniform_sets[dset]; LocalVector::Iterator pos = set.uniforms.begin(); while (pos != set.uniforms.end()) { if (dbin == pos->binding) { found = &(*pos); break; } ++pos; } } ERR_FAIL_NULL_V_MSG(found, ERR_CANT_CREATE, "UniformData not found"); bool is_active = active.find(res.id) != active.end(); if (is_active) { found->active_stages |= 1 << stage; } BindingInfo primary{}; SPIRType const &a_type = compiler.get_type(res.type_id); BT basetype = a_type.basetype; switch (basetype) { case BT::Struct: { primary.dataType = MTLDataTypePointer; } break; case BT::Image: case BT::SampledImage: { primary.dataType = MTLDataTypeTexture; } break; case BT::Sampler: { primary.dataType = MTLDataTypeSampler; } break; default: { ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Unexpected BaseType"); } break; } // Find array length. if (basetype == BT::Image || basetype == BT::SampledImage) { primary.arrayLength = 1; for (uint32_t const &a : a_type.array) { primary.arrayLength *= a; } primary.isMultisampled = a_type.image.ms; SPIRType::ImageType const &image = a_type.image; primary.imageFormat = image.format; switch (image.dim) { case spv::Dim1D: { if (image.arrayed) { primary.textureType = MTLTextureType1DArray; } else { primary.textureType = MTLTextureType1D; } } break; case spv::DimSubpassData: { DISPATCH_FALLTHROUGH; } case spv::Dim2D: { if (image.arrayed && image.ms) { primary.textureType = MTLTextureType2DMultisampleArray; } else if (image.arrayed) { primary.textureType = MTLTextureType2DArray; } else if (image.ms) { primary.textureType = MTLTextureType2DMultisample; } else { primary.textureType = MTLTextureType2D; } } break; case spv::Dim3D: { primary.textureType = MTLTextureType3D; } break; case spv::DimCube: { if (image.arrayed) { primary.textureType = MTLTextureTypeCube; } } break; case spv::DimRect: { } break; case spv::DimBuffer: { // VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER primary.textureType = MTLTextureTypeTextureBuffer; } break; case spv::DimMax: { // Add all enumerations to silence the compiler warning // and generate future warnings, should a new one be added. } break; } } // Update writable. if (writable == Writable::Maybe) { if (basetype == BT::Struct) { Bitset flags = compiler.get_buffer_block_flags(res.id); if (!flags.get(spv::DecorationNonWritable)) { if (flags.get(spv::DecorationNonReadable)) { primary.access = MTLBindingAccessWriteOnly; } else { primary.access = MTLBindingAccessReadWrite; } } } else if (basetype == BT::Image) { switch (a_type.image.access) { case spv::AccessQualifierWriteOnly: primary.access = MTLBindingAccessWriteOnly; break; case spv::AccessQualifierReadWrite: primary.access = MTLBindingAccessReadWrite; break; case spv::AccessQualifierReadOnly: break; case spv::AccessQualifierMax: DISPATCH_FALLTHROUGH; default: if (!compiler.has_decoration(res.id, spv::DecorationNonWritable)) { if (compiler.has_decoration(res.id, spv::DecorationNonReadable)) { primary.access = MTLBindingAccessWriteOnly; } else { primary.access = MTLBindingAccessReadWrite; } } break; } } } switch (primary.access) { case MTLBindingAccessReadOnly: primary.usage = MTLResourceUsageRead; break; case MTLBindingAccessWriteOnly: primary.usage = MTLResourceUsageWrite; break; case MTLBindingAccessReadWrite: primary.usage = MTLResourceUsageRead | MTLResourceUsageWrite; break; } primary.index = compiler.get_automatic_msl_resource_binding(res.id); found->bindings[stage] = primary; // A sampled image contains two bindings, the primary // is to the image, and the secondary is to the associated sampler. if (basetype == BT::SampledImage) { uint32_t binding = compiler.get_automatic_msl_resource_binding_secondary(res.id); if (binding != (uint32_t)-1) { found->bindings_secondary[stage] = BindingInfo{ .dataType = MTLDataTypeSampler, .index = binding, .access = MTLBindingAccessReadOnly, }; } } // An image may have a secondary binding if it is used // for atomic operations. if (basetype == BT::Image) { uint32_t binding = compiler.get_automatic_msl_resource_binding_secondary(res.id); if (binding != (uint32_t)-1) { found->bindings_secondary[stage] = BindingInfo{ .dataType = MTLDataTypePointer, .index = binding, .access = MTLBindingAccessReadWrite, }; } } } return Error::OK; }; if (!resources.uniform_buffers.empty()) { Error err = descriptor_bindings(resources.uniform_buffers, Writable::No); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.storage_buffers.empty()) { Error err = descriptor_bindings(resources.storage_buffers, Writable::Maybe); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.storage_images.empty()) { Error err = descriptor_bindings(resources.storage_images, Writable::Maybe); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.sampled_images.empty()) { Error err = descriptor_bindings(resources.sampled_images, Writable::No); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.separate_images.empty()) { Error err = descriptor_bindings(resources.separate_images, Writable::No); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.separate_samplers.empty()) { Error err = descriptor_bindings(resources.separate_samplers, Writable::No); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.subpass_inputs.empty()) { Error err = descriptor_bindings(resources.subpass_inputs, Writable::No); ERR_FAIL_COND_V(err != OK, Result()); } if (!resources.push_constant_buffers.empty()) { for (Resource const &res : resources.push_constant_buffers) { uint32_t binding = compiler.get_automatic_msl_resource_binding(res.id); if (binding != (uint32_t)-1) { bin_data.push_constant.used_stages |= 1 << stage; bin_data.push_constant.msl_binding[stage] = binding; } } } ERR_FAIL_COND_V_MSG(!resources.atomic_counters.empty(), Result(), "Atomic counters not supported"); ERR_FAIL_COND_V_MSG(!resources.acceleration_structures.empty(), Result(), "Acceleration structures not supported"); ERR_FAIL_COND_V_MSG(!resources.shader_record_buffers.empty(), Result(), "Shader record buffers not supported"); if (!resources.stage_inputs.empty()) { for (Resource const &res : resources.stage_inputs) { uint32_t binding = compiler.get_automatic_msl_resource_binding(res.id); if (binding != (uint32_t)-1) { bin_data.vertex_input_mask |= 1 << binding; } } } ShaderStageData stage_data; stage_data.stage = v.shader_stage; stage_data.entry_point_name = entry_point.name.c_str(); stage_data.source = source.c_str(); bin_data.stages.push_back(stage_data); } size_t vec_size = bin_data.serialize_size() + 8; ::Vector ret; ret.resize(vec_size); BufWriter writer(ret.ptrw(), vec_size); const uint8_t HEADER[4] = { 'G', 'M', 'S', 'L' }; writer.write(*(uint32_t *)HEADER); writer.write(SHADER_BINARY_VERSION); bin_data.serialize(writer); ret.resize(writer.get_pos()); return ret; } 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; memdelete(entry); } } RDD::ShaderID RenderingDeviceDriverMetal::shader_create_from_bytecode(const Vector &p_shader_binary, ShaderDescription &r_shader_desc, String &r_name) { r_shader_desc = {}; // Driver-agnostic. const uint8_t *binptr = p_shader_binary.ptr(); uint32_t binsize = p_shader_binary.size(); BufReader reader(binptr, binsize); uint8_t header[4]; reader.read((uint32_t &)header); ERR_FAIL_COND_V_MSG(memcmp(header, "GMSL", 4) != 0, ShaderID(), "Invalid header"); uint32_t version = 0; reader.read(version); ERR_FAIL_COND_V_MSG(version != SHADER_BINARY_VERSION, ShaderID(), "Invalid shader binary version"); ShaderBinaryData binary_data; binary_data.deserialize(reader); switch (reader.status) { case BufReader::Status::OK: break; case BufReader::Status::BAD_COMPRESSION: ERR_FAIL_V_MSG(ShaderID(), "Invalid compressed data"); case BufReader::Status::SHORT_BUFFER: ERR_FAIL_V_MSG(ShaderID(), "Unexpected end of buffer"); } MTLCompileOptions *options = [MTLCompileOptions new]; options.languageVersion = binary_data.get_msl_version(); HashMap libraries; for (ShaderStageData &shader_data : binary_data.stages) { SHA256Digest key = SHA256Digest(shader_data.source.ptr(), shader_data.source.length()); if (ShaderCacheEntry **p = _shader_cache.getptr(key); p != nullptr) { libraries[shader_data.stage] = (*p)->library; continue; } NSString *source = [[NSString alloc] initWithBytes:(void *)shader_data.source.ptr() length:shader_data.source.length() encoding:NSUTF8StringEncoding]; ShaderCacheEntry *cd = memnew(ShaderCacheEntry(*this, key)); cd->name = binary_data.shader_name; cd->stage = shader_data.stage; MDLibrary *library = [MDLibrary newLibraryWithCacheEntry:cd device:device source:source options:options strategy:_shader_load_strategy]; _shader_cache[key] = cd; libraries[shader_data.stage] = library; } Vector uniform_sets; uniform_sets.resize(binary_data.uniforms.size()); r_shader_desc.uniform_sets.resize(binary_data.uniforms.size()); // Create sets. for (UniformSetData &uniform_set : binary_data.uniforms) { UniformSet &set = uniform_sets.write[uniform_set.index]; set.uniforms.resize(uniform_set.uniforms.size()); Vector &uset = r_shader_desc.uniform_sets.write[uniform_set.index]; uset.resize(uniform_set.uniforms.size()); for (uint32_t i = 0; i < uniform_set.uniforms.size(); i++) { UniformData &uniform = uniform_set.uniforms[i]; ShaderUniform su; su.type = uniform.type; su.writable = uniform.writable; su.length = uniform.length; su.binding = uniform.binding; su.stages = uniform.stages; uset.write[i] = su; UniformInfo ui; ui.binding = uniform.binding; ui.active_stages = uniform.active_stages; for (KeyValue &kv : uniform.bindings) { ui.bindings.insert(kv.key, kv.value); } for (KeyValue &kv : uniform.bindings_secondary) { ui.bindings_secondary.insert(kv.key, kv.value); } set.uniforms[i] = ui; } } for (UniformSetData &uniform_set : binary_data.uniforms) { UniformSet &set = uniform_sets.write[uniform_set.index]; // Make encoders. for (ShaderStageData const &stage_data : binary_data.stages) { ShaderStage stage = stage_data.stage; NSMutableArray *descriptors = [NSMutableArray new]; for (UniformInfo const &uniform : set.uniforms) { BindingInfo const *binding_info = uniform.bindings.getptr(stage); if (binding_info == nullptr) continue; [descriptors addObject:binding_info->new_argument_descriptor()]; BindingInfo const *secondary_binding_info = uniform.bindings_secondary.getptr(stage); if (secondary_binding_info != nullptr) { [descriptors addObject:secondary_binding_info->new_argument_descriptor()]; } } if (descriptors.count == 0) { // No bindings. continue; } // Sort by index. [descriptors sortUsingComparator:^NSComparisonResult(MTLArgumentDescriptor *a, MTLArgumentDescriptor *b) { if (a.index < b.index) { return NSOrderedAscending; } else if (a.index > b.index) { return NSOrderedDescending; } else { return NSOrderedSame; } }]; id enc = [device newArgumentEncoderWithArguments:descriptors]; set.encoders[stage] = enc; set.offsets[stage] = set.buffer_size; set.buffer_size += enc.encodedLength; } } r_shader_desc.specialization_constants.resize(binary_data.constants.size()); for (uint32_t i = 0; i < binary_data.constants.size(); i++) { SpecializationConstantData &c = binary_data.constants[i]; ShaderSpecializationConstant sc; sc.type = c.type; sc.constant_id = c.constant_id; sc.int_value = c.int_value; sc.stages = c.stages; r_shader_desc.specialization_constants.write[i] = sc; } MDShader *shader = nullptr; if (binary_data.is_compute) { MDComputeShader *cs = new MDComputeShader(binary_data.shader_name, uniform_sets, libraries[ShaderStage::SHADER_STAGE_COMPUTE]); uint32_t *binding = binary_data.push_constant.msl_binding.getptr(SHADER_STAGE_COMPUTE); if (binding) { cs->push_constants.size = binary_data.push_constant.size; cs->push_constants.binding = *binding; } cs->local = MTLSizeMake(binary_data.compute_local_size.x, binary_data.compute_local_size.y, binary_data.compute_local_size.z); #if DEV_ENABLED cs->kernel_source = binary_data.stages[0].source; #endif shader = cs; } else { MDRenderShader *rs = new MDRenderShader(binary_data.shader_name, uniform_sets, libraries[ShaderStage::SHADER_STAGE_VERTEX], libraries[ShaderStage::SHADER_STAGE_FRAGMENT]); uint32_t *vert_binding = binary_data.push_constant.msl_binding.getptr(SHADER_STAGE_VERTEX); if (vert_binding) { rs->push_constants.vert.size = binary_data.push_constant.size; rs->push_constants.vert.binding = *vert_binding; } uint32_t *frag_binding = binary_data.push_constant.msl_binding.getptr(SHADER_STAGE_FRAGMENT); if (frag_binding) { rs->push_constants.frag.size = binary_data.push_constant.size; rs->push_constants.frag.binding = *frag_binding; } #if DEV_ENABLED for (ShaderStageData &stage_data : binary_data.stages) { if (stage_data.stage == ShaderStage::SHADER_STAGE_VERTEX) { rs->vert_source = stage_data.source; } else if (stage_data.stage == ShaderStage::SHADER_STAGE_FRAGMENT) { rs->frag_source = stage_data.source; } } #endif shader = rs; } r_shader_desc.vertex_input_mask = binary_data.vertex_input_mask; r_shader_desc.fragment_output_mask = binary_data.fragment_output_mask; r_shader_desc.is_compute = binary_data.is_compute; r_shader_desc.compute_local_size[0] = binary_data.compute_local_size.x; r_shader_desc.compute_local_size[1] = binary_data.compute_local_size.y; r_shader_desc.compute_local_size[2] = binary_data.compute_local_size.z; r_shader_desc.push_constant_size = binary_data.push_constant.size; return ShaderID(shader); } void RenderingDeviceDriverMetal::shader_free(ShaderID p_shader) { MDShader *obj = (MDShader *)p_shader.id; delete obj; } void RenderingDeviceDriverMetal::shader_destroy_modules(ShaderID p_shader) { // TODO. } /*********************/ /**** UNIFORM SET ****/ /*********************/ RDD::UniformSetID RenderingDeviceDriverMetal::uniform_set_create(VectorView p_uniforms, ShaderID p_shader, uint32_t p_set_index) { MDUniformSet *set = new MDUniformSet(); Vector bound_uniforms; bound_uniforms.resize(p_uniforms.size()); for (uint32_t i = 0; i < p_uniforms.size(); i += 1) { bound_uniforms.write[i] = p_uniforms[i]; } set->uniforms = 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; delete obj; } void RenderingDeviceDriverMetal::command_uniform_set_prepare_for_use(CommandBufferID p_cmd_buffer, UniformSetID p_uniform_set, ShaderID p_shader, uint32_t p_set_index) { } #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); id buffer = rid::get(p_buffer); id blit = cmd->blit_command_encoder(); [blit fillBuffer:buffer range:NSMakeRange(p_offset, p_size) value:0]; } 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); id src = rid::get(p_src_buffer); id dst = rid::get(p_dst_buffer); id blit = cmd->blit_command_encoder(); for (uint32_t i = 0; i < p_regions.size(); i++) { BufferCopyRegion region = p_regions[i]; [blit copyFromBuffer:src sourceOffset:region.src_offset toBuffer:dst destinationOffset:region.dst_offset size:region.size]; } } MTLSize MTLSizeFromVector3i(Vector3i p_size) { return MTLSizeMake(p_size.x, p_size.y, p_size.z); } 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; } 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); id src = rid::get(p_src_texture); id dst = rid::get(p_dst_texture); id blit = cmd->blit_command_encoder(); PixelFormats &pf = *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++) { 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) { [blit 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)) { [blit 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) { [blit 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); [blit 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 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); 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; cb->encodeRenderCommandEncoderWithDescriptor(mtlRPD, @"Resolve Image"); } 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); 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 = *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(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 = (*metal_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; cb->encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); } else { for (uint32_t layer = layerStart; layer < layerEnd; layer++) { if (is3D) { caDesc.depthPlane = layer; } else { caDesc.slice = layer; } cb->encodeRenderCommandEncoderWithDescriptor(desc, @"Clear Image"); } } } } } API_AVAILABLE(macos(11.0), ios(14.0)) bool isArrayTexture(MTLTextureType p_type) { return (p_type == MTLTextureType3D || p_type == MTLTextureType2DArray || p_type == MTLTextureType2DMultisampleArray || p_type == MTLTextureType1DArray); } void RenderingDeviceDriverMetal::_copy_texture_buffer(CommandBufferID p_cmd_buffer, CopySource p_source, TextureID p_texture, BufferID p_buffer, VectorView p_regions) { MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); id buffer = rid::get(p_buffer); id texture = rid::get(p_texture); id enc = cmd->blit_command_encoder(); PixelFormats &pf = *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++) { BufferTextureCopyRegion region = p_regions[i]; uint32_t mip_level = region.texture_subresources.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)) { bool want_depth = flags::all(region.texture_subresources.aspect, TEXTURE_ASPECT_DEPTH_BIT); bool want_stencil = flags::all(region.texture_subresources.aspect, TEXTURE_ASPECT_STENCIL_BIT); // The stencil component is always 1 byte per pixel. // Don't reduce depths of 32-bit depth/stencil formats. if (want_depth && !want_stencil) { if (pf.getBytesPerTexel(mtlPixFmt) != 4) { bytesPerRow -= buffImgWd; bytesPerImg -= buffImgWd * buffImgHt; } blit_options |= MTLBlitOptionDepthFromDepthStencil; } else if (want_stencil && !want_depth) { bytesPerRow = buffImgWd; bytesPerImg = buffImgWd * buffImgHt; blit_options |= MTLBlitOptionStencilFromDepthStencil; } } if (!isArrayTexture(texture.textureType)) { bytesPerImg = 0; } if (p_source == CopySource::Buffer) { for (uint32_t lyrIdx = 0; lyrIdx < region.texture_subresources.layer_count; lyrIdx++) { [enc copyFromBuffer:buffer sourceOffset:region.buffer_offset + (bytesPerImg * lyrIdx) sourceBytesPerRow:bytesPerRow sourceBytesPerImage:bytesPerImg sourceSize:txt_size toTexture:texture destinationSlice:region.texture_subresources.base_layer + lyrIdx destinationLevel:mip_level destinationOrigin:txt_origin options:blit_options]; } } else { for (uint32_t lyrIdx = 0; lyrIdx < region.texture_subresources.layer_count; lyrIdx++) { [enc copyFromTexture:texture sourceSlice:region.texture_subresources.base_layer + lyrIdx sourceLevel:mip_level sourceOrigin:txt_origin sourceSize:txt_size toBuffer:buffer destinationOffset:region.buffer_offset + (bytesPerImg * lyrIdx) destinationBytesPerRow:bytesPerRow destinationBytesPerImage:bytesPerImg options:blit_options]; } } } } 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) { _copy_texture_buffer(p_cmd_buffer, CopySource::Buffer, p_dst_texture, p_src_buffer, 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) { _copy_texture_buffer(p_cmd_buffer, CopySource::Texture, p_src_texture, p_dst_buffer, p_regions); } #pragma mark - Pipeline void RenderingDeviceDriverMetal::pipeline_free(PipelineID p_pipeline_id) { MDPipeline *obj = (MDPipeline *)(p_pipeline_id.id); delete obj; } // ----- 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); MDShader *shader = (MDShader *)(p_shader.id); shader->encode_push_constant_data(p_data, cb); } // ----- CACHE ----- String RenderingDeviceDriverMetal::_pipeline_get_cache_path() const { String path = OS::get_singleton()->get_user_data_dir() + "/metal/pipelines"; path += "." + context_device.name.validate_filename().replace(" ", "_").to_lower(); if (Engine::get_singleton()->is_editor_hint()) { path += ".editor"; } path += ".cache"; return path; } 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; } void RenderingDeviceDriverMetal::pipeline_cache_free() { archive = nil; } size_t RenderingDeviceDriverMetal::pipeline_cache_query_size() { return archive_count * 1024; } Vector RenderingDeviceDriverMetal::pipeline_cache_serialize() { if (!archive) { 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(); } } #pragma mark - Rendering // ----- SUBPASS ----- RDD::RenderPassID RenderingDeviceDriverMetal::render_pass_create(VectorView p_attachments, VectorView p_subpasses, VectorView p_subpass_dependencies, uint32_t p_view_count) { PixelFormats &pf = *pixel_formats; size_t subpass_count = p_subpasses.size(); Vector subpasses; subpasses.resize(subpass_count); for (uint32_t i = 0; i < subpass_count; i++) { MDSubpass &subpass = subpasses.write[i]; subpass.subpass_index = i; subpass.input_references = p_subpasses[i].input_references; subpass.color_references = p_subpasses[i].color_references; subpass.depth_stencil_reference = p_subpasses[i].depth_stencil_reference; subpass.resolve_references = p_subpasses[i].resolve_references; } static const MTLLoadAction LOAD_ACTIONS[] = { [ATTACHMENT_LOAD_OP_LOAD] = MTLLoadActionLoad, [ATTACHMENT_LOAD_OP_CLEAR] = MTLLoadActionClear, [ATTACHMENT_LOAD_OP_DONT_CARE] = MTLLoadActionDontCare, }; static const MTLStoreAction STORE_ACTIONS[] = { [ATTACHMENT_STORE_OP_STORE] = MTLStoreActionStore, [ATTACHMENT_STORE_OP_DONT_CARE] = MTLStoreActionDontCare, }; Vector attachments; attachments.resize(p_attachments.size()); for (uint32_t i = 0; i < p_attachments.size(); i++) { Attachment const &a = p_attachments[i]; MDAttachment &mda = attachments.write[i]; MTLPixelFormat format = pf.getMTLPixelFormat(a.format); mda.format = format; if (a.samples > TEXTURE_SAMPLES_1) { mda.samples = (*metal_device_properties).find_nearest_supported_sample_count(a.samples); } mda.loadAction = LOAD_ACTIONS[a.load_op]; mda.storeAction = STORE_ACTIONS[a.store_op]; bool is_depth = pf.isDepthFormat(format); if (is_depth) { mda.type |= MDAttachmentType::Depth; } bool is_stencil = pf.isStencilFormat(format); if (is_stencil) { mda.type |= MDAttachmentType::Stencil; mda.stencilLoadAction = LOAD_ACTIONS[a.stencil_load_op]; mda.stencilStoreAction = STORE_ACTIONS[a.stencil_store_op]; } if (!is_depth && !is_stencil) { mda.type |= MDAttachmentType::Color; } } MDRenderPass *obj = new MDRenderPass(attachments, subpasses); return RenderPassID(obj); } void RenderingDeviceDriverMetal::render_pass_free(RenderPassID p_render_pass) { MDRenderPass *obj = (MDRenderPass *)(p_render_pass.id); delete obj; } // ----- COMMANDS ----- void RenderingDeviceDriverMetal::command_begin_render_pass(CommandBufferID p_cmd_buffer, RenderPassID p_render_pass, FramebufferID p_framebuffer, CommandBufferType p_cmd_buffer_type, const Rect2i &p_rect, VectorView p_clear_values) { MDCommandBuffer *cb = (MDCommandBuffer *)(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); 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); cb->render_next_subpass(); } void RenderingDeviceDriverMetal::command_render_set_viewport(CommandBufferID p_cmd_buffer, VectorView p_viewports) { MDCommandBuffer *cb = (MDCommandBuffer *)(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); 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); 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); cb->bind_pipeline(p_pipeline); } void RenderingDeviceDriverMetal::command_bind_render_uniform_set(CommandBufferID p_cmd_buffer, UniformSetID p_uniform_set, ShaderID p_shader, uint32_t p_set_index) { MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); cb->render_bind_uniform_set(p_uniform_set, p_shader, p_set_index); } 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); 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); 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); 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); 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); 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); 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) { MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); cb->render_bind_vertex_buffers(p_binding_count, p_buffers, p_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); 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); cb->render_set_blend_constants(p_constants); } void RenderingDeviceDriverMetal::command_render_set_line_width(CommandBufferID p_cmd_buffer, float p_width) { if (!Math::is_equal_approx(p_width, 1.0f)) { ERR_FAIL_MSG("Setting line widths other than 1.0 is not supported by the Metal rendering driver."); } } // ----- PIPELINE ----- RenderingDeviceDriverMetal::Result> RenderingDeviceDriverMetal::_create_function(MDLibrary *p_library, NSString *p_name, VectorView &p_specialization_constants) { id library = p_library.library; if (!library) { ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Failed to compile Metal library"); } id function = [library newFunctionWithName:p_name]; ERR_FAIL_NULL_V_MSG(function, ERR_CANT_CREATE, "No function named main0"); if (function.functionConstantsDictionary.count == 0) { return function; } NSArray *constants = function.functionConstantsDictionary.allValues; bool is_sorted = true; for (uint32_t i = 1; i < constants.count; i++) { if (constants[i - 1].index > constants[i].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; } }]; } // Initialize an array of integers representing the indexes of p_specialization_constants 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; uint32_t j = 0; while (i < constants.count && j < p_specialization_constants.size()) { MTLFunctionConstant *curr = 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]; } break; default: ERR_FAIL_V_MSG(function, "Invalid specialization constant type"); } i++; j++; } 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) { uint32_t alignment = 16; // TODO(sgc): is this always correct? [constantValues setConstantValue:&alignment type:curr.type atIndex: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); return 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::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::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::PipelineID RenderingDeviceDriverMetal::render_pipeline_create( ShaderID p_shader, VertexFormatID p_vertex_format, RenderPrimitive p_render_primitive, PipelineRasterizationState p_rasterization_state, PipelineMultisampleState p_multisample_state, PipelineDepthStencilState p_depth_stencil_state, PipelineColorBlendState p_blend_state, VectorView p_color_attachments, BitField p_dynamic_state, RenderPassID p_render_pass, uint32_t p_render_subpass, VectorView p_specialization_constants) { MDRenderShader *shader = (MDRenderShader *)(p_shader.id); MTLVertexDescriptor *vert_desc = rid::get(p_vertex_format); MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); os_signpost_id_t reflect_id = os_signpost_id_make_with_pointer(LOG_INTERVALS, shader); os_signpost_interval_begin(LOG_INTERVALS, reflect_id, "render_pipeline_create", "shader_name=%{public}s", shader->name.get_data()); DEFER([=]() { os_signpost_interval_end(LOG_INTERVALS, reflect_id, "render_pipeline_create"); }); os_signpost_event_emit(LOG_DRIVER, OS_SIGNPOST_ID_EXCLUSIVE, "create_pipeline"); MTLRenderPipelineDescriptor *desc = [MTLRenderPipelineDescriptor new]; { MDSubpass const &subpass = pass->subpasses[p_render_subpass]; for (uint32_t i = 0; i < subpass.color_references.size(); i++) { uint32_t attachment = subpass.color_references[i].attachment; if (attachment != AttachmentReference::UNUSED) { MDAttachment const &a = pass->attachments[attachment]; desc.colorAttachments[i].pixelFormat = a.format; } } if (subpass.depth_stencil_reference.attachment != AttachmentReference::UNUSED) { uint32_t attachment = subpass.depth_stencil_reference.attachment; MDAttachment const &a = pass->attachments[attachment]; if (a.type & MDAttachmentType::Depth) { desc.depthAttachmentPixelFormat = a.format; } if (a.type & MDAttachmentType::Stencil) { desc.stencilAttachmentPixelFormat = a.format; } } } desc.vertexDescriptor = vert_desc; desc.label = [NSString stringWithUTF8String:shader->name.get_data()]; // Input assembly & tessellation. MDRenderPipeline *pipeline = new MDRenderPipeline(); switch (p_render_primitive) { case RENDER_PRIMITIVE_POINTS: desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassPoint; break; case RENDER_PRIMITIVE_LINES: case RENDER_PRIMITIVE_LINES_WITH_ADJACENCY: case RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY: case RENDER_PRIMITIVE_LINESTRIPS: desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassLine; 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; break; case RENDER_PRIMITIVE_TESSELATION_PATCH: desc.maxTessellationFactor = p_rasterization_state.patch_control_points; desc.tessellationPartitionMode = MTLTessellationPartitionModeInteger; ERR_FAIL_V_MSG(PipelineID(), "tessellation not implemented"); break; case RENDER_PRIMITIVE_MAX: default: desc.inputPrimitiveTopology = MTLPrimitiveTopologyClassUnspecified; break; } switch (p_render_primitive) { case RENDER_PRIMITIVE_POINTS: pipeline->raster_state.render_primitive = MTLPrimitiveTypePoint; break; case RENDER_PRIMITIVE_LINES: case RENDER_PRIMITIVE_LINES_WITH_ADJACENCY: pipeline->raster_state.render_primitive = MTLPrimitiveTypeLine; break; case RENDER_PRIMITIVE_LINESTRIPS: case RENDER_PRIMITIVE_LINESTRIPS_WITH_ADJACENCY: pipeline->raster_state.render_primitive = MTLPrimitiveTypeLineStrip; break; case RENDER_PRIMITIVE_TRIANGLES: case RENDER_PRIMITIVE_TRIANGLES_WITH_ADJACENCY: pipeline->raster_state.render_primitive = MTLPrimitiveTypeTriangle; 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; 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; static const MTLCullMode CULL_MODE[3] = { MTLCullModeNone, MTLCullModeFront, MTLCullModeBack, }; 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.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; pipeline->raster_state.depth_bias.clamp = p_rasterization_state.depth_bias_clamp; // In Metal there is no line width. if (!Math::is_equal_approx(p_rasterization_state.line_width, 1.0f)) { WARN_PRINT("unsupported: line width"); } // Multisample. if (p_multisample_state.enable_sample_shading) { WARN_PRINT("unsupported: multi-sample shading"); } if (p_multisample_state.sample_count > TEXTURE_SAMPLES_1) { pipeline->sample_count = (*metal_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; // Depth stencil. if (p_depth_stencil_state.enable_depth_test && desc.depthAttachmentPixelFormat != MTLPixelFormatInvalid) { pipeline->raster_state.depth_test.enabled = true; MTLDepthStencilDescriptor *ds_desc = [MTLDepthStencilDescriptor new]; ds_desc.depthWriteEnabled = p_depth_stencil_state.enable_depth_write; ds_desc.depthCompareFunction = COMPARE_OPERATORS[p_depth_stencil_state.depth_compare_operator]; if (p_depth_stencil_state.enable_depth_range) { WARN_PRINT("unsupported: depth range"); } if (p_depth_stencil_state.enable_stencil) { pipeline->raster_state.stencil.front_reference = p_depth_stencil_state.front_op.reference; pipeline->raster_state.stencil.back_reference = p_depth_stencil_state.back_op.reference; { // 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; } { // 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; } } pipeline->depth_stencil = [device newDepthStencilStateWithDescriptor:ds_desc]; ERR_FAIL_NULL_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); } // Blend state. { for (uint32_t i = 0; i < p_color_attachments.size(); i++) { if (p_color_attachments[i] == ATTACHMENT_UNUSED) { continue; } const PipelineColorBlendState::Attachment &bs = p_blend_state.attachments[i]; MTLRenderPipelineColorAttachmentDescriptor *ca_desc = desc.colorAttachments[p_color_attachments[i]]; ca_desc.blendingEnabled = 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.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.writeMask = MTLColorWriteMaskNone; if (bs.write_r) { ca_desc.writeMask |= MTLColorWriteMaskRed; } if (bs.write_g) { ca_desc.writeMask |= MTLColorWriteMaskGreen; } if (bs.write_b) { ca_desc.writeMask |= MTLColorWriteMaskBlue; } if (bs.write_a) { ca_desc.writeMask |= MTLColorWriteMaskAlpha; } } pipeline->raster_state.blend.r = p_blend_state.blend_constant.r; pipeline->raster_state.blend.g = p_blend_state.blend_constant.g; pipeline->raster_state.blend.b = p_blend_state.blend_constant.b; pipeline->raster_state.blend.a = p_blend_state.blend_constant.a; } // Dynamic state. if (p_dynamic_state.has_flag(DYNAMIC_STATE_DEPTH_BIAS)) { pipeline->raster_state.depth_bias.enabled = true; } if (p_dynamic_state.has_flag(DYNAMIC_STATE_BLEND_CONSTANTS)) { pipeline->raster_state.blend.enabled = true; } if (p_dynamic_state.has_flag(DYNAMIC_STATE_DEPTH_BOUNDS)) { // TODO(sgc): ?? } if (p_dynamic_state.has_flag(DYNAMIC_STATE_STENCIL_COMPARE_MASK)) { // TODO(sgc): ?? } if (p_dynamic_state.has_flag(DYNAMIC_STATE_STENCIL_WRITE_MASK)) { // TODO(sgc): ?? } if (p_dynamic_state.has_flag(DYNAMIC_STATE_STENCIL_REFERENCE)) { pipeline->raster_state.stencil.enabled = true; } if (shader->vert != nil) { Result> function_or_err = _create_function(shader->vert, @"main0", p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); desc.vertexFunction = std::get>(function_or_err); } if (shader->frag != nil) { Result> function_or_err = _create_function(shader->frag, @"main0", p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); desc.fragmentFunction = std::get>(function_or_err); } if (archive) { desc.binaryArchives = @[ archive ]; } NSError *error = nil; pipeline->state = [device newRenderPipelineStateWithDescriptor:desc error:&error]; pipeline->shader = shader; ERR_FAIL_COND_V_MSG(error != nil, PipelineID(), ([NSString stringWithFormat:@"error creating pipeline: %@", error.localizedDescription].UTF8String)); if (archive) { if ([archive addRenderPipelineFunctionsWithDescriptor:desc error:&error]) { archive_count += 1; } else { print_error(error.localizedDescription.UTF8String); } } return PipelineID(pipeline); } #pragma mark - Compute // ----- COMMANDS ----- void RenderingDeviceDriverMetal::command_bind_compute_pipeline(CommandBufferID p_cmd_buffer, PipelineID p_pipeline) { MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); cb->bind_pipeline(p_pipeline); } void RenderingDeviceDriverMetal::command_bind_compute_uniform_set(CommandBufferID p_cmd_buffer, UniformSetID p_uniform_set, ShaderID p_shader, uint32_t p_set_index) { MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); cb->compute_bind_uniform_set(p_uniform_set, p_shader, p_set_index); } 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); 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); cb->compute_dispatch_indirect(p_indirect_buffer, p_offset); } // ----- PIPELINE ----- RDD::PipelineID RenderingDeviceDriverMetal::compute_pipeline_create(ShaderID p_shader, VectorView p_specialization_constants) { MDComputeShader *shader = (MDComputeShader *)(p_shader.id); os_signpost_id_t reflect_id = os_signpost_id_make_with_pointer(LOG_INTERVALS, shader); os_signpost_interval_begin(LOG_INTERVALS, reflect_id, "compute_pipeline_create", "shader_name=%{public}s", shader->name.get_data()); DEFER([=]() { os_signpost_interval_end(LOG_INTERVALS, reflect_id, "compute_pipeline_create"); }); os_signpost_event_emit(LOG_DRIVER, OS_SIGNPOST_ID_EXCLUSIVE, "create_pipeline"); Result> function_or_err = _create_function(shader->kernel, @"main0", p_specialization_constants); ERR_FAIL_COND_V(std::holds_alternative(function_or_err), PipelineID()); id function = std::get>(function_or_err); MTLComputePipelineDescriptor *desc = [MTLComputePipelineDescriptor new]; desc.computeFunction = function; if (archive) { desc.binaryArchives = @[ archive ]; } 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)); MDComputePipeline *pipeline = new MDComputePipeline(state); pipeline->compute_state.local = shader->local; pipeline->shader = shader; if (archive) { if ([archive addComputePipelineFunctionsWithDescriptor:desc error:&error]) { archive_count += 1; } else { print_error(error.localizedDescription.UTF8String); } } return PipelineID(pipeline); } #pragma mark - Queries // ----- TIMESTAMP ----- RDD::QueryPoolID RenderingDeviceDriverMetal::timestamp_query_pool_create(uint32_t p_query_count) { return QueryPoolID(1); } void RenderingDeviceDriverMetal::timestamp_query_pool_free(QueryPoolID p_pool_id) { } void RenderingDeviceDriverMetal::timestamp_query_pool_get_results(QueryPoolID p_pool_id, uint32_t p_query_count, uint64_t *r_results) { // Metal doesn't support timestamp queries, so we just clear the buffer. bzero(r_results, p_query_count * sizeof(uint64_t)); } uint64_t RenderingDeviceDriverMetal::timestamp_query_result_to_time(uint64_t p_result) { return p_result; } void RenderingDeviceDriverMetal::command_timestamp_query_pool_reset(CommandBufferID p_cmd_buffer, QueryPoolID p_pool_id, uint32_t p_query_count) { } void RenderingDeviceDriverMetal::command_timestamp_write(CommandBufferID p_cmd_buffer, QueryPoolID p_pool_id, uint32_t p_index) { } #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); NSString *s = [[NSString alloc] initWithBytesNoCopy:(void *)p_label_name length:strlen(p_label_name) encoding:NSUTF8StringEncoding freeWhenDone:NO]; [cb->get_command_buffer() pushDebugGroup:s]; } void RenderingDeviceDriverMetal::command_end_label(CommandBufferID p_cmd_buffer) { MDCommandBuffer *cb = (MDCommandBuffer *)(p_cmd_buffer.id); [cb->get_command_buffer() popDebugGroup]; } #pragma mark - Debug void RenderingDeviceDriverMetal::command_insert_breadcrumb(CommandBufferID p_cmd_buffer, uint32_t p_data) { // TODO: Implement. } #pragma mark - Submission void RenderingDeviceDriverMetal::begin_segment(uint32_t p_frame_index, uint32_t p_frames_drawn) { } void RenderingDeviceDriverMetal::end_segment() { } #pragma mark - Misc void RenderingDeviceDriverMetal::set_object_name(ObjectType p_type, ID p_driver_id, const String &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()]; } break; case OBJECT_TYPE_SAMPLER: { // Can't set label after creation. } break; case OBJECT_TYPE_BUFFER: { id buffer = rid::get(p_driver_id); buffer.label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; } 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]; } else if (MDComputeShader *cs = dynamic_cast(shader); cs != nullptr) { [cs->kernel setLabel:label]; } else { DEV_ASSERT(false); } } break; case OBJECT_TYPE_UNIFORM_SET: { MDUniformSet *set = (MDUniformSet *)(p_driver_id.id); for (KeyValue &keyval : set->bound_uniforms) { keyval.value.buffer.label = [NSString stringWithUTF8String:p_name.utf8().get_data()]; } } break; case OBJECT_TYPE_PIPELINE: { // Can't set label after creation. } break; default: { DEV_ASSERT(false); } } } uint64_t RenderingDeviceDriverMetal::get_resource_native_handle(DriverResource p_type, ID p_driver_id) { switch (p_type) { case DRIVER_RESOURCE_LOGICAL_DEVICE: { return 0; } case DRIVER_RESOURCE_PHYSICAL_DEVICE: { return 0; } case DRIVER_RESOURCE_TOPMOST_OBJECT: { return 0; } case DRIVER_RESOURCE_COMMAND_QUEUE: { return 0; } case DRIVER_RESOURCE_QUEUE_FAMILY: { return 0; } case DRIVER_RESOURCE_TEXTURE: { return p_driver_id.id; } case DRIVER_RESOURCE_TEXTURE_VIEW: { return p_driver_id.id; } case DRIVER_RESOURCE_TEXTURE_DATA_FORMAT: { return 0; } case DRIVER_RESOURCE_SAMPLER: { return p_driver_id.id; } case DRIVER_RESOURCE_UNIFORM_SET: return 0; case DRIVER_RESOURCE_BUFFER: { return p_driver_id.id; } case DRIVER_RESOURCE_COMPUTE_PIPELINE: return 0; case DRIVER_RESOURCE_RENDER_PIPELINE: return 0; default: { return 0; } } } uint64_t RenderingDeviceDriverMetal::get_total_memory_used() { return device.currentAllocatedSize; } uint64_t RenderingDeviceDriverMetal::limit_get(Limit p_limit) { MetalDeviceProperties const &props = (*metal_device_properties); MetalLimits const &limits = props.limits; #if defined(DEV_ENABLED) #define UNKNOWN(NAME) \ case NAME: \ WARN_PRINT_ONCE("Returning maximum value for unknown limit " #NAME "."); \ return (uint64_t)1 << 30; #else #define UNKNOWN(NAME) \ case NAME: \ return (uint64_t)1 << 30 #endif // clang-format off switch (p_limit) { case LIMIT_MAX_BOUND_UNIFORM_SETS: return limits.maxBoundDescriptorSets; case LIMIT_MAX_FRAMEBUFFER_COLOR_ATTACHMENTS: return limits.maxColorAttachments; case LIMIT_MAX_TEXTURES_PER_UNIFORM_SET: return limits.maxTexturesPerArgumentBuffer; case LIMIT_MAX_SAMPLERS_PER_UNIFORM_SET: return limits.maxSamplersPerArgumentBuffer; case LIMIT_MAX_STORAGE_BUFFERS_PER_UNIFORM_SET: return limits.maxBuffersPerArgumentBuffer; case LIMIT_MAX_STORAGE_IMAGES_PER_UNIFORM_SET: return limits.maxTexturesPerArgumentBuffer; case LIMIT_MAX_UNIFORM_BUFFERS_PER_UNIFORM_SET: return limits.maxBuffersPerArgumentBuffer; case LIMIT_MAX_DRAW_INDEXED_INDEX: return limits.maxDrawIndexedIndexValue; case LIMIT_MAX_FRAMEBUFFER_HEIGHT: return limits.maxFramebufferHeight; case LIMIT_MAX_FRAMEBUFFER_WIDTH: return limits.maxFramebufferWidth; case LIMIT_MAX_TEXTURE_ARRAY_LAYERS: return limits.maxImageArrayLayers; case LIMIT_MAX_TEXTURE_SIZE_1D: return limits.maxImageDimension1D; case LIMIT_MAX_TEXTURE_SIZE_2D: return limits.maxImageDimension2D; case LIMIT_MAX_TEXTURE_SIZE_3D: return limits.maxImageDimension3D; case LIMIT_MAX_TEXTURE_SIZE_CUBE: return limits.maxImageDimensionCube; case LIMIT_MAX_TEXTURES_PER_SHADER_STAGE: return limits.maxTexturesPerArgumentBuffer; case LIMIT_MAX_SAMPLERS_PER_SHADER_STAGE: return limits.maxSamplersPerArgumentBuffer; case LIMIT_MAX_STORAGE_BUFFERS_PER_SHADER_STAGE: return limits.maxBuffersPerArgumentBuffer; case LIMIT_MAX_STORAGE_IMAGES_PER_SHADER_STAGE: return limits.maxTexturesPerArgumentBuffer; case LIMIT_MAX_UNIFORM_BUFFERS_PER_SHADER_STAGE: return limits.maxBuffersPerArgumentBuffer; case LIMIT_MAX_PUSH_CONSTANT_SIZE: return limits.maxBufferLength; case LIMIT_MAX_UNIFORM_BUFFER_SIZE: return limits.maxBufferLength; case LIMIT_MAX_VERTEX_INPUT_ATTRIBUTE_OFFSET: return limits.maxVertexDescriptorLayoutStride; case LIMIT_MAX_VERTEX_INPUT_ATTRIBUTES: return limits.maxVertexInputAttributes; case LIMIT_MAX_VERTEX_INPUT_BINDINGS: return limits.maxVertexInputBindings; case LIMIT_MAX_VERTEX_INPUT_BINDING_STRIDE: return limits.maxVertexInputBindingStride; case LIMIT_MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT: return limits.minUniformBufferOffsetAlignment; case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_X: return limits.maxComputeWorkGroupCount.width; case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Y: return limits.maxComputeWorkGroupCount.height; case LIMIT_MAX_COMPUTE_WORKGROUP_COUNT_Z: return limits.maxComputeWorkGroupCount.depth; case LIMIT_MAX_COMPUTE_WORKGROUP_INVOCATIONS: return std::max({ limits.maxThreadsPerThreadGroup.width, limits.maxThreadsPerThreadGroup.height, limits.maxThreadsPerThreadGroup.depth }); case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_X: return limits.maxThreadsPerThreadGroup.width; case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Y: return limits.maxThreadsPerThreadGroup.height; case LIMIT_MAX_COMPUTE_WORKGROUP_SIZE_Z: return limits.maxThreadsPerThreadGroup.depth; case LIMIT_MAX_VIEWPORT_DIMENSIONS_X: return limits.maxViewportDimensionX; case LIMIT_MAX_VIEWPORT_DIMENSIONS_Y: return limits.maxViewportDimensionY; case LIMIT_SUBGROUP_SIZE: // MoltenVK sets the subgroupSize to the same as the maxSubgroupSize. return limits.maxSubgroupSize; case LIMIT_SUBGROUP_MIN_SIZE: return limits.minSubgroupSize; case LIMIT_SUBGROUP_MAX_SIZE: return limits.maxSubgroupSize; case LIMIT_SUBGROUP_IN_SHADERS: return (int64_t)limits.subgroupSupportedShaderStages; case LIMIT_SUBGROUP_OPERATIONS: return (int64_t)limits.subgroupSupportedOperations; UNKNOWN(LIMIT_VRS_TEXEL_WIDTH); UNKNOWN(LIMIT_VRS_TEXEL_HEIGHT); default: ERR_FAIL_V(0); } // clang-format on return 0; } uint64_t RenderingDeviceDriverMetal::api_trait_get(ApiTrait p_trait) { switch (p_trait) { case API_TRAIT_HONORS_PIPELINE_BARRIERS: return 0; default: return RenderingDeviceDriver::api_trait_get(p_trait); } } bool RenderingDeviceDriverMetal::has_feature(Features p_feature) { switch (p_feature) { case SUPPORTS_MULTIVIEW: return false; case SUPPORTS_FSR_HALF_FLOAT: return true; case SUPPORTS_ATTACHMENT_VRS: // TODO(sgc): Maybe supported via https://developer.apple.com/documentation/metal/render_passes/rendering_at_different_rasterization_rates?language=objc // See also: // // * https://forum.beyond3d.com/threads/variable-rate-shading-vs-variable-rate-rasterization.62243/post-2191363 // return false; case SUPPORTS_FRAGMENT_SHADER_WITH_ONLY_SIDE_EFFECTS: return true; default: return false; } } const RDD::MultiviewCapabilities &RenderingDeviceDriverMetal::get_multiview_capabilities() { return multiview_capabilities; } String RenderingDeviceDriverMetal::get_api_version() const { return vformat("%d.%d", version_major, version_minor); } String RenderingDeviceDriverMetal::get_pipeline_cache_uuid() const { return pipeline_cache_id; } const RDD::Capabilities &RenderingDeviceDriverMetal::get_capabilities() const { return capabilities; } bool RenderingDeviceDriverMetal::is_composite_alpha_supported(CommandQueueID p_queue) const { // The CAMetalLayer.opaque property is configured according to this global setting. return OS::get_singleton()->is_layered_allowed(); } size_t RenderingDeviceDriverMetal::get_texel_buffer_alignment_for_format(RDD::DataFormat p_format) const { 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]; } /******************/ 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_SHADER_LOAD_STRATEGY"); res == U"lazy") { _shader_load_strategy = ShaderLoadStrategy::LAZY; } } RenderingDeviceDriverMetal::~RenderingDeviceDriverMetal() { for (MDCommandBuffer *cb : command_buffers) { delete cb; } for (KeyValue &kv : _shader_cache) { memdelete(kv.value); } } #pragma mark - Initialization 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); return OK; } Error RenderingDeviceDriverMetal::_check_capabilities() { MTLCompileOptions *options = [MTLCompileOptions new]; version_major = (options.languageVersion >> 0x10) & 0xff; version_minor = (options.languageVersion >> 0x00) & 0xff; capabilities.device_family = DEVICE_METAL; capabilities.version_major = version_major; capabilities.version_minor = version_minor; return OK; } 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); err = _check_capabilities(); ERR_FAIL_COND_V(err, ERR_CANT_CREATE); // Set the pipeline cache ID based on the Metal version. pipeline_cache_id = "metal-driver-" + get_api_version(); metal_device_properties = memnew(MetalDeviceProperties(device)); pixel_formats = memnew(PixelFormats(device)); // Check required features and abort if any of them is missing. if (!metal_device_properties->features.imageCubeArray) { // NOTE: Apple A11 (Apple4) GPUs support image cube arrays, which are devices from 2017 and newer. 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 (!metal_device_properties->features.imageCubeArray) { error_string += "- No support for image cube arrays.\n"; } #if defined(IOS_ENABLED) // iOS platform ports currently don't exit themselves when this method returns `ERR_CANT_CREATE`. OS::get_singleton()->alert(error_string + "\nClick OK to exit (black screen will be visible)."); #else OS::get_singleton()->alert(error_string + "\nClick OK to exit."); #endif return ERR_CANT_CREATE; } return OK; }