diff options
Diffstat (limited to 'drivers/metal/rendering_device_driver_metal.mm')
| -rw-r--r-- | drivers/metal/rendering_device_driver_metal.mm | 3965 |
1 files changed, 3965 insertions, 0 deletions
diff --git a/drivers/metal/rendering_device_driver_metal.mm b/drivers/metal/rendering_device_driver_metal.mm new file mode 100644 index 0000000000..9d691a0d23 --- /dev/null +++ b/drivers/metal/rendering_device_driver_metal.mm @@ -0,0 +1,3965 @@ +/**************************************************************************/ +/* 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 <Metal/MTLTexture.h> +#import <Metal/Metal.h> +#import <os/log.h> +#import <os/signpost.h> +#import <spirv_msl.hpp> +#import <spirv_parser.hpp> + +#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<MTLTexture> 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<BufferUsageBits> 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<MTLBuffer> 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<MTLBuffer> obj = rid::get(p_buffer); + return obj.allocatedSize; +} + +uint8_t *RenderingDeviceDriverMetal::buffer_map(BufferID p_buffer) { + id<MTLBuffer> 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<bool> 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<MTLTextureSwizzle>(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<bool> is_linear_or_err = is_valid_linear(p_format); + ERR_FAIL_COND_V(std::holds_alternative<Error>(is_linear_or_err), TextureID()); + is_linear = std::get<bool>(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<MTLTexture> 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<MTLBuffer> 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<MTLTexture> 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<MTLTextureSwizzle>(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<MTLTexture> 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<MTLTexture> 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<MTLTextureSwizzle>(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<MTLTexture> 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<MTLTexture> 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<MTLTexture> 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<MTLTexture> 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<MTLTexture> 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<RDD::TextureUsageBits> 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<RDD::TextureUsageBits> 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<MTLSamplerState> 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<VertexAttribute> 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<PipelineStageBits> p_src_stages, + BitField<PipelineStageBits> p_dst_stages, + VectorView<MemoryBarrier> p_memory_barriers, + VectorView<BufferBarrier> p_buffer_barriers, + VectorView<TextureBarrier> 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<CommandQueueFamilyBits> 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<SemaphoreID>, VectorView<CommandBufferID> p_cmd_buffers, VectorView<SemaphoreID>, FenceID p_cmd_fence, VectorView<SwapChainID> 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<MTLCommandBuffer> 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<MTLCommandQueue> 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<CommandBufferID> 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<TextureID> p_attachments, uint32_t p_width, uint32_t p_height) { + MDRenderPass *pass = (MDRenderPass *)(p_render_pass.id); + + Vector<MTL::Texture> textures; + textures.resize(p_attachments.size()); + + for (uint32_t i = 0; i < p_attachments.size(); i += 1) { + MDAttachment const &a = pass->attachments[i]; + id<MTLTexture> 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 <typename T> +concept Serializable = requires(T t, BufWriter &p_writer) { + { + t.serialize_size() + } -> std::same_as<size_t>; + { + t.serialize(p_writer) + } -> std::same_as<void>; +}; + +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 <Serializable T> + 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<uint8_t const *>(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<const uint8_t *>(p_string.ptr()), p_string.length()); + } + + template <typename T> + void write(VectorView<T> 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<uint8_t> p_vector) { + write_buffer(p_vector.ptr(), p_vector.size()); + } + + template <typename K, typename V> + void write(HashMap<K, V> const &p_map) { + write(p_map.size()); + for (KeyValue<K, V> 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 <typename T> +concept Deserializable = requires(T t, BufReader &p_reader) { + { + t.serialize_size() + } -> std::same_as<size_t>; + { + t.deserialize(p_reader) + } -> std::same_as<void>; +}; + +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 <Deserializable T> + 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<uint8_t *>(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<uint8_t> &p_val) { + uint32_t len; + read(len); + CHECK(len); + p_val.resize(len); + memcpy(p_val.ptr(), data + pos, len); + pos += len; + } + + template <typename T> + void read(LocalVector<T> &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 <typename K, typename V> + void read(HashMap<K, V> &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<RD::ShaderStage, BindingInfo> 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<RD::ShaderStage, BindingInfo> 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<UniformData> 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<RD::ShaderStage, uint32_t> 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<ShaderStageData> stages; + LocalVector<SpecializationConstantData> constants; + LocalVector<UniformSetData> 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<ShaderStageSPIRVData> 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<uint32_t const *const>(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<Resource> &resources, Writable writable, std::function<RDD::UniformType(SPIRType const &)> 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<uint8_t> RenderingDeviceDriverMetal::shader_compile_binary_from_spirv(VectorView<ShaderStageSPIRVData> p_spirv, const String &p_shader_name) { + using Result = ::Vector<uint8_t>; + 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<ShaderUniform> &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<uint32_t const *const>(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<VariableID> 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<SpecializationConstantData>::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<UniformSetData> &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<Resource> &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<UniformData>::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<uint8_t> 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<uint8_t> &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<ShaderStage, MDLibrary *> 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<UniformSet> 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<ShaderUniform> &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<RDC::ShaderStage, BindingInfo> &kv : uniform.bindings) { + ui.bindings.insert(kv.key, kv.value); + } + for (KeyValue<RDC::ShaderStage, BindingInfo> &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<MTLArgumentDescriptor *> *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<MTLArgumentEncoder> 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<BoundUniform> p_uniforms, ShaderID p_shader, uint32_t p_set_index) { + MDUniformSet *set = new MDUniformSet(); + Vector<BoundUniform> 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<MTLBuffer> buffer = rid::get(p_buffer); + + id<MTLBlitCommandEncoder> 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<BufferCopyRegion> p_regions) { + MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + id<MTLBuffer> src = rid::get(p_src_buffer); + id<MTLBuffer> dst = rid::get(p_dst_buffer); + + id<MTLBlitCommandEncoder> 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<TextureCopyRegion> p_regions) { + MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + id<MTLTexture> src = rid::get(p_src_texture); + id<MTLTexture> dst = rid::get(p_dst_texture); + + id<MTLBlitCommandEncoder> 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<MTLTexture> src_tex = rid::get(p_src_texture); + id<MTLTexture> 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<MTLTexture> 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<BufferTextureCopyRegion> p_regions) { + MDCommandBuffer *cmd = (MDCommandBuffer *)(p_cmd_buffer.id); + id<MTLBuffer> buffer = rid::get(p_buffer); + id<MTLTexture> texture = rid::get(p_texture); + + id<MTLBlitCommandEncoder> 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<BufferTextureCopyRegion> 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<BufferTextureCopyRegion> 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<uint32_t> 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<uint8_t> &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<uint8_t> RenderingDeviceDriverMetal::pipeline_cache_serialize() { + if (!archive) { + return Vector<uint8_t>(); + } + + 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<uint8_t>(); + } else { + print_line(error.localizedDescription.UTF8String); + return Vector<uint8_t>(); + } +} + +#pragma mark - Rendering + +// ----- SUBPASS ----- + +RDD::RenderPassID RenderingDeviceDriverMetal::render_pass_create(VectorView<Attachment> p_attachments, VectorView<Subpass> p_subpasses, VectorView<SubpassDependency> p_subpass_dependencies, uint32_t p_view_count) { + PixelFormats &pf = *pixel_formats; + + size_t subpass_count = p_subpasses.size(); + + Vector<MDSubpass> 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<MDAttachment> 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<RenderPassClearValue> 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<Rect2i> 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<Rect2i> 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<AttachmentClear> p_attachment_clears, VectorView<Rect2i> 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<id<MTLFunction>> RenderingDeviceDriverMetal::_create_function(MDLibrary *p_library, NSString *p_name, VectorView<PipelineSpecializationConstant> &p_specialization_constants) { + id<MTLLibrary> library = p_library.library; + if (!library) { + ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Failed to compile Metal library"); + } + + id<MTLFunction> 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<MTLFunctionConstant *> *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<int32_t> p_color_attachments, + BitField<PipelineDynamicStateFlags> p_dynamic_state, + RenderPassID p_render_pass, + uint32_t p_render_subpass, + VectorView<PipelineSpecializationConstant> 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<NSUInteger>(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<id<MTLFunction>> function_or_err = _create_function(shader->vert, @"main0", p_specialization_constants); + ERR_FAIL_COND_V(std::holds_alternative<Error>(function_or_err), PipelineID()); + desc.vertexFunction = std::get<id<MTLFunction>>(function_or_err); + } + + if (shader->frag != nil) { + Result<id<MTLFunction>> function_or_err = _create_function(shader->frag, @"main0", p_specialization_constants); + ERR_FAIL_COND_V(std::holds_alternative<Error>(function_or_err), PipelineID()); + desc.fragmentFunction = std::get<id<MTLFunction>>(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<PipelineSpecializationConstant> 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<id<MTLFunction>> function_or_err = _create_function(shader->kernel, @"main0", p_specialization_constants); + ERR_FAIL_COND_V(std::holds_alternative<Error>(function_or_err), PipelineID()); + id<MTLFunction> function = std::get<id<MTLFunction>>(function_or_err); + + MTLComputePipelineDescriptor *desc = [MTLComputePipelineDescriptor new]; + desc.computeFunction = function; + if (archive) { + desc.binaryArchives = @[ archive ]; + } + + NSError *error; + id<MTLComputePipelineState> 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<MTLTexture> 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<MTLBuffer> 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<MDRenderShader *>(shader); rs != nullptr) { + [rs->vert setLabel:label]; + [rs->frag setLabel:label]; + } else if (MDComputeShader *cs = dynamic_cast<MDComputeShader *>(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<MDShader *, BoundUniformSet> &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<SHA256Digest, ShaderCacheEntry *> &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<MDResourceCache>(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; +} |