mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
1917bc3454
godot/drivers/metal/rendering_device_driver_metal.mm

3966 lines
143 KiB
Plaintext
Raw Blame History

/**************************************************************************/
/* 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;
}
Reference in New Issue View Git Blame Copy Permalink