CoCalc -- pixel_formats.cpp

GitHub Repository: godotengine/godot
Path: blob/master/drivers/metal/pixel_formats.cpp
²⁰⁹¹⁹ views
1
/**************************************************************************/
2
/*  pixel_formats.cpp                                                     */
3
/**************************************************************************/
4
/*                         This file is part of:                          */
5
/*                             GODOT ENGINE                               */
6
/*                        https://godotengine.org                         */
7
/**************************************************************************/
8
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
10
/*                                                                        */
11
/* Permission is hereby granted, free of charge, to any person obtaining  */
12
/* a copy of this software and associated documentation files (the        */
13
/* "Software"), to deal in the Software without restriction, including    */
14
/* without limitation the rights to use, copy, modify, merge, publish,    */
15
/* distribute, sublicense, and/or sell copies of the Software, and to     */
16
/* permit persons to whom the Software is furnished to do so, subject to  */
17
/* the following conditions:                                              */
18
/*                                                                        */
19
/* The above copyright notice and this permission notice shall be         */
20
/* included in all copies or substantial portions of the Software.        */
21
/*                                                                        */
22
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
23
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
24
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
26
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
27
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
28
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
29
/**************************************************************************/
30

31
/**************************************************************************/
32
/*                                                                        */
33
/* Portions of this code were derived from MoltenVK.                      */
34
/*                                                                        */
35
/* Copyright (c) 2015-2023 The Brenwill Workshop Ltd.                     */
36
/* (http://www.brenwill.com)                                              */
37
/*                                                                        */
38
/* Licensed under the Apache License, Version 2.0 (the "License");        */
39
/* you may not use this file except in compliance with the License.       */
40
/* You may obtain a copy of the License at                                */
41
/*                                                                        */
42
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
43
/*                                                                        */
44
/* Unless required by applicable law or agreed to in writing, software    */
45
/* distributed under the License is distributed on an "AS IS" BASIS,      */
46
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
47
/* implied. See the License for the specific language governing           */
48
/* permissions and limitations under the License.                         */
49
/**************************************************************************/
50

51
#include "pixel_formats.h"
52

53
#include "metal_utils.h"
54

55
#if TARGET_OS_IPHONE || TARGET_OS_TV
56
#if !(__IPHONE_OS_VERSION_MAX_ALLOWED >= 160400) // iOS/tvOS 16.4
57
#define PixelFormatBC1_RGBA PixelFormatInvalid
58
#define PixelFormatBC1_RGBA_sRGB PixelFormatInvalid
59
#define PixelFormatBC2_RGBA PixelFormatInvalid
60
#define PixelFormatBC2_RGBA_sRGB PixelFormatInvalid
61
#define PixelFormatBC3_RGBA PixelFormatInvalid
62
#define PixelFormatBC3_RGBA_sRGB PixelFormatInvalid
63
#define PixelFormatBC4_RUnorm PixelFormatInvalid
64
#define PixelFormatBC4_RSnorm PixelFormatInvalid
65
#define PixelFormatBC5_RGUnorm PixelFormatInvalid
66
#define PixelFormatBC5_RGSnorm PixelFormatInvalid
67
#define PixelFormatBC6H_RGBUfloat PixelFormatInvalid
68
#define PixelFormatBC6H_RGBFloat PixelFormatInvalid
69
#define PixelFormatBC7_RGBAUnorm PixelFormatInvalid
70
#define PixelFormatBC7_RGBAUnorm_sRGB PixelFormatInvalid
71
#endif
72

73
#define PixelFormatDepth16Unorm_Stencil8 PixelFormatDepth32Float_Stencil8
74
#define PixelFormatDepth24Unorm_Stencil8 PixelFormatInvalid
75
#define PixelFormatX24_Stencil8 PixelFormatInvalid
76
#endif
77

78
#if TARGET_OS_TV
79
#define PixelFormatASTC_4x4_HDR PixelFormatInvalid
80
#define PixelFormatASTC_5x4_HDR PixelFormatInvalid
81
#define PixelFormatASTC_5x5_HDR PixelFormatInvalid
82
#define PixelFormatASTC_6x5_HDR PixelFormatInvalid
83
#define PixelFormatASTC_6x6_HDR PixelFormatInvalid
84
#define PixelFormatASTC_8x5_HDR PixelFormatInvalid
85
#define PixelFormatASTC_8x6_HDR PixelFormatInvalid
86
#define PixelFormatASTC_8x8_HDR PixelFormatInvalid
87
#define PixelFormatASTC_10x5_HDR PixelFormatInvalid
88
#define PixelFormatASTC_10x6_HDR PixelFormatInvalid
89
#define PixelFormatASTC_10x8_HDR PixelFormatInvalid
90
#define PixelFormatASTC_10x10_HDR PixelFormatInvalid
91
#define PixelFormatASTC_12x10_HDR PixelFormatInvalid
92
#define PixelFormatASTC_12x12_HDR PixelFormatInvalid
93
#endif
94

95
#if !((__MAC_OS_X_VERSION_MAX_ALLOWED >= 140000) || (__IPHONE_OS_VERSION_MAX_ALLOWED >= 170000)) // Xcode 15
96
#define VertexFormatFloatRG11B10 VertexFormatInvalid
97
#define VertexFormatFloatRGB9E5 VertexFormatInvalid
98
#endif
99

100
template <typename T>
101
void clear(T *p_val, size_t p_count = 1) {
102
	memset(p_val, 0, sizeof(T) * p_count);
103
}
104

105
#pragma mark -
106
#pragma mark PixelFormats
107

108
bool PixelFormats::isSupported(DataFormat p_format) {
109
	return getDataFormatDesc(p_format).isSupported();
110
}
111

112
bool PixelFormats::isSupportedOrSubstitutable(DataFormat p_format) {
113
	return getDataFormatDesc(p_format).isSupportedOrSubstitutable();
114
}
115

116
bool PixelFormats::isPVRTCFormat(MTL::PixelFormat p_format) {
117
#if defined(VISIONOS_ENABLED)
118
	return false;
119
#else
120
	// Deprecated in SDK 26.0
121
	GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations")
122
	switch (p_format) {
123
		case MTL::PixelFormatPVRTC_RGBA_2BPP:
124
		case MTL::PixelFormatPVRTC_RGBA_2BPP_sRGB:
125
		case MTL::PixelFormatPVRTC_RGBA_4BPP:
126
		case MTL::PixelFormatPVRTC_RGBA_4BPP_sRGB:
127
		case MTL::PixelFormatPVRTC_RGB_2BPP:
128
		case MTL::PixelFormatPVRTC_RGB_2BPP_sRGB:
129
		case MTL::PixelFormatPVRTC_RGB_4BPP:
130
		case MTL::PixelFormatPVRTC_RGB_4BPP_sRGB:
131
			return true;
132
		default:
133
			return false;
134
	}
135
	GODOT_CLANG_WARNING_POP
136
#endif
137
}
138

139
MTLFormatType PixelFormats::getFormatType(DataFormat p_format) {
140
	return getDataFormatDesc(p_format).formatType;
141
}
142

143
MTLFormatType PixelFormats::getFormatType(MTL::PixelFormat p_format) {
144
	return getDataFormatDesc(p_format).formatType;
145
}
146

147
MTL::PixelFormat PixelFormats::getMTLPixelFormat(DataFormat p_format) {
148
	DataFormatDesc &dfDesc = getDataFormatDesc(p_format);
149
	MTL::PixelFormat mtlPixFmt = dfDesc.mtlPixelFormat;
150

151
	// If the MTL::PixelFormat is not supported but DataFormat is valid,
152
	// attempt to substitute a different format.
153
	if (mtlPixFmt == MTL::PixelFormatInvalid && p_format != RD::DATA_FORMAT_MAX && dfDesc.chromaSubsamplingPlaneCount <= 1) {
154
		mtlPixFmt = dfDesc.mtlPixelFormatSubstitute;
155
	}
156

157
	return mtlPixFmt;
158
}
159

160
RD::DataFormat PixelFormats::getDataFormat(MTL::PixelFormat p_format) {
161
	return getMTLPixelFormatDesc(p_format).dataFormat;
162
}
163

164
uint32_t PixelFormats::getBytesPerBlock(DataFormat p_format) {
165
	return getDataFormatDesc(p_format).bytesPerBlock;
166
}
167

168
uint32_t PixelFormats::getBytesPerBlock(MTL::PixelFormat p_format) {
169
	return getDataFormatDesc(p_format).bytesPerBlock;
170
}
171

172
uint8_t PixelFormats::getChromaSubsamplingPlaneCount(DataFormat p_format) {
173
	return getDataFormatDesc(p_format).chromaSubsamplingPlaneCount;
174
}
175

176
uint8_t PixelFormats::getChromaSubsamplingComponentBits(DataFormat p_format) {
177
	return getDataFormatDesc(p_format).chromaSubsamplingComponentBits;
178
}
179

180
float PixelFormats::getBytesPerTexel(DataFormat p_format) {
181
	return getDataFormatDesc(p_format).bytesPerTexel();
182
}
183

184
float PixelFormats::getBytesPerTexel(MTL::PixelFormat p_format) {
185
	return getDataFormatDesc(p_format).bytesPerTexel();
186
}
187

188
size_t PixelFormats::getBytesPerRow(DataFormat p_format, uint32_t p_texels_per_row) {
189
	DataFormatDesc &dfDesc = getDataFormatDesc(p_format);
190
	return Math::division_round_up(p_texels_per_row, dfDesc.blockTexelSize.width) * dfDesc.bytesPerBlock;
191
}
192

193
size_t PixelFormats::getBytesPerRow(MTL::PixelFormat p_format, uint32_t p_texels_per_row) {
194
	DataFormatDesc &dfDesc = getDataFormatDesc(p_format);
195
	return Math::division_round_up(p_texels_per_row, dfDesc.blockTexelSize.width) * dfDesc.bytesPerBlock;
196
}
197

198
size_t PixelFormats::getBytesPerLayer(DataFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer) {
199
	return Math::division_round_up(p_texel_rows_per_layer, getDataFormatDesc(p_format).blockTexelSize.height) * p_bytes_per_row;
200
}
201

202
size_t PixelFormats::getBytesPerLayer(MTL::PixelFormat p_format, size_t p_bytes_per_row, uint32_t p_texel_rows_per_layer) {
203
	return Math::division_round_up(p_texel_rows_per_layer, getDataFormatDesc(p_format).blockTexelSize.height) * p_bytes_per_row;
204
}
205

206
bool PixelFormats::needsSwizzle(DataFormat p_format) {
207
	return getDataFormatDesc(p_format).needsSwizzle();
208
}
209

210
MTLFmtCaps PixelFormats::getCapabilities(DataFormat p_format, bool p_extended) {
211
	return getCapabilities(getDataFormatDesc(p_format).mtlPixelFormat, p_extended);
212
}
213

214
MTLFmtCaps PixelFormats::getCapabilities(MTL::PixelFormat p_format, bool p_extended) {
215
	MTLFormatDesc &mtlDesc = getMTLPixelFormatDesc(p_format);
216
	MTLFmtCaps caps = mtlDesc.mtlFmtCaps;
217
	if (!p_extended || mtlDesc.mtlViewClass == MTLViewClass::None) {
218
		return caps;
219
	}
220
	// Now get caps of all formats in the view class.
221
	for (MTLFormatDesc &otherDesc : _mtl_vertex_format_descs) {
222
		if (otherDesc.mtlViewClass == mtlDesc.mtlViewClass) {
223
			caps |= otherDesc.mtlFmtCaps;
224
		}
225
	}
226
	return caps;
227
}
228

229
MTL::VertexFormat PixelFormats::getMTLVertexFormat(DataFormat p_format) {
230
	DataFormatDesc &dfDesc = getDataFormatDesc(p_format);
231
	MTL::VertexFormat format = dfDesc.mtlVertexFormat;
232

233
	if (format == MTL::VertexFormatInvalid) {
234
		String errMsg;
235
		errMsg += "DataFormat ";
236
		errMsg += dfDesc.name;
237
		errMsg += " is not supported for vertex buffers on this device.";
238

239
		if (dfDesc.vertexIsSupportedOrSubstitutable()) {
240
			format = dfDesc.mtlVertexFormatSubstitute;
241

242
			DataFormatDesc &dfDescSubs = getDataFormatDesc(getMTLVertexFormatDesc(format).dataFormat);
243
			errMsg += " Using DataFormat ";
244
			errMsg += dfDescSubs.name;
245
			errMsg += " instead.";
246
		}
247
		WARN_PRINT(errMsg);
248
	}
249

250
	return format;
251
}
252

253
DataFormatDesc &PixelFormats::getDataFormatDesc(DataFormat p_format) {
254
	return _data_format_descs[p_format];
255
}
256

257
DataFormatDesc &PixelFormats::getDataFormatDesc(MTL::PixelFormat p_format) {
258
	return getDataFormatDesc(getMTLPixelFormatDesc(p_format).dataFormat);
259
}
260

261
// Return a reference to the Metal format descriptor corresponding to the MTL::PixelFormat.
262
MTLFormatDesc &PixelFormats::getMTLPixelFormatDesc(MTL::PixelFormat p_format) {
263
	return _mtl_pixel_format_descs[p_format];
264
}
265

266
// Return a reference to the Metal format descriptor corresponding to the MTL::VertexFormat.
267
MTLFormatDesc &PixelFormats::getMTLVertexFormatDesc(MTL::VertexFormat p_format) {
268
	return _mtl_vertex_format_descs[p_format];
269
}
270

271
PixelFormats::PixelFormats(MTL::Device *p_device, const MetalFeatures &p_feat) :
272
		device(p_device->retain()) {
273
	initMTLPixelFormatCapabilities();
274
	initMTLVertexFormatCapabilities(p_feat);
275
	modifyMTLFormatCapabilities(p_feat);
276

277
	initDataFormatCapabilities();
278
	buildDFFormatMaps();
279
}
280

281
PixelFormats::~PixelFormats() {
282
	device->release();
283
}
284

285
#define addDataFormatDescFull(DATA_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, CSPC, CSCB, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE, SWIZ_R, SWIZ_G, SWIZ_B, SWIZ_A) \
286
	dfFmt = RD::DATA_FORMAT_##DATA_FMT; \
287
	_data_format_descs[dfFmt] = { dfFmt, MTL::PixelFormat##MTL_FMT, MTL::PixelFormat##MTL_FMT_ALT, MTL::VertexFormat##MTL_VTX_FMT, MTL::VertexFormat##MTL_VTX_FMT_ALT, \
288
		CSPC, CSCB, { BLK_W, BLK_H }, BLK_BYTE_CNT, MTLFormatType::MVK_FMT_TYPE, \
289
		{ RD::TEXTURE_SWIZZLE_##SWIZ_R, RD::TEXTURE_SWIZZLE_##SWIZ_G, RD::TEXTURE_SWIZZLE_##SWIZ_B, RD::TEXTURE_SWIZZLE_##SWIZ_A }, \
290
		"DATA_FORMAT_" #DATA_FMT, false }
291

292
#define addDataFormatDesc(VK_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE) \
293
	addDataFormatDescFull(VK_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, 0, 0, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE, IDENTITY, IDENTITY, IDENTITY, IDENTITY)
294

295
#define addDataFormatDescSwizzled(VK_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE, SWIZ_R, SWIZ_G, SWIZ_B, SWIZ_A) \
296
	addDataFormatDescFull(VK_FMT, MTL_FMT, MTL_FMT_ALT, MTL_VTX_FMT, MTL_VTX_FMT_ALT, 0, 0, BLK_W, BLK_H, BLK_BYTE_CNT, MVK_FMT_TYPE, SWIZ_R, SWIZ_G, SWIZ_B, SWIZ_A)
297

298
#define addDfFormatDescChromaSubsampling(DATA_FMT, MTL_FMT, CSPC, CSCB, BLK_W, BLK_H, BLK_BYTE_CNT) \
299
	addDataFormatDescFull(DATA_FMT, MTL_FMT, Invalid, Invalid, Invalid, CSPC, CSCB, BLK_W, BLK_H, BLK_BYTE_CNT, ColorFloat, IDENTITY, IDENTITY, IDENTITY, IDENTITY)
300

301
void PixelFormats::initDataFormatCapabilities() {
302
	_data_format_descs.reserve(RD::DATA_FORMAT_MAX + 1); // reserve enough space to avoid reallocs
303
	DataFormat dfFmt;
304

305
	addDataFormatDesc(R4G4_UNORM_PACK8, Invalid, Invalid, Invalid, Invalid, 1, 1, 1, ColorFloat);
306
	addDataFormatDesc(R4G4_UNORM_PACK8, Invalid, Invalid, Invalid, Invalid, 1, 1, 1, ColorFloat);
307
	addDataFormatDesc(R4G4B4A4_UNORM_PACK16, ABGR4Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat);
308
	addDataFormatDescSwizzled(B4G4R4A4_UNORM_PACK16, Invalid, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat, B, G, R, A);
309

310
	addDataFormatDesc(R5G6B5_UNORM_PACK16, B5G6R5Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat);
311
	addDataFormatDescSwizzled(B5G6R5_UNORM_PACK16, B5G6R5Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat, B, G, R, A);
312
	addDataFormatDesc(R5G5B5A1_UNORM_PACK16, A1BGR5Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat);
313
	addDataFormatDescSwizzled(B5G5R5A1_UNORM_PACK16, A1BGR5Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat, B, G, R, A);
314
	addDataFormatDesc(A1R5G5B5_UNORM_PACK16, BGR5A1Unorm, Invalid, Invalid, Invalid, 1, 1, 2, ColorFloat);
315

316
	addDataFormatDesc(R8_UNORM, R8Unorm, Invalid, UCharNormalized, UChar2Normalized, 1, 1, 1, ColorFloat);
317
	addDataFormatDesc(R8_SNORM, R8Snorm, Invalid, CharNormalized, Char2Normalized, 1, 1, 1, ColorFloat);
318
	addDataFormatDesc(R8_USCALED, Invalid, Invalid, UChar, UChar2, 1, 1, 1, ColorFloat);
319
	addDataFormatDesc(R8_SSCALED, Invalid, Invalid, Char, Char2, 1, 1, 1, ColorFloat);
320
	addDataFormatDesc(R8_UINT, R8Uint, Invalid, UChar, UChar2, 1, 1, 1, ColorUInt8);
321
	addDataFormatDesc(R8_SINT, R8Sint, Invalid, Char, Char2, 1, 1, 1, ColorInt8);
322
	addDataFormatDesc(R8_SRGB, R8Unorm_sRGB, Invalid, UCharNormalized, UChar2Normalized, 1, 1, 1, ColorFloat);
323

324
	addDataFormatDesc(R8G8_UNORM, RG8Unorm, Invalid, UChar2Normalized, Invalid, 1, 1, 2, ColorFloat);
325
	addDataFormatDesc(R8G8_SNORM, RG8Snorm, Invalid, Char2Normalized, Invalid, 1, 1, 2, ColorFloat);
326
	addDataFormatDesc(R8G8_USCALED, Invalid, Invalid, UChar2, Invalid, 1, 1, 2, ColorFloat);
327
	addDataFormatDesc(R8G8_SSCALED, Invalid, Invalid, Char2, Invalid, 1, 1, 2, ColorFloat);
328
	addDataFormatDesc(R8G8_UINT, RG8Uint, Invalid, UChar2, Invalid, 1, 1, 2, ColorUInt8);
329
	addDataFormatDesc(R8G8_SINT, RG8Sint, Invalid, Char2, Invalid, 1, 1, 2, ColorInt8);
330
	addDataFormatDesc(R8G8_SRGB, RG8Unorm_sRGB, Invalid, UChar2Normalized, Invalid, 1, 1, 2, ColorFloat);
331

332
	addDataFormatDesc(R8G8B8_UNORM, Invalid, Invalid, UChar3Normalized, Invalid, 1, 1, 3, ColorFloat);
333
	addDataFormatDesc(R8G8B8_SNORM, Invalid, Invalid, Char3Normalized, Invalid, 1, 1, 3, ColorFloat);
334
	addDataFormatDesc(R8G8B8_USCALED, Invalid, Invalid, UChar3, Invalid, 1, 1, 3, ColorFloat);
335
	addDataFormatDesc(R8G8B8_SSCALED, Invalid, Invalid, Char3, Invalid, 1, 1, 3, ColorFloat);
336
	addDataFormatDesc(R8G8B8_UINT, Invalid, Invalid, UChar3, Invalid, 1, 1, 3, ColorUInt8);
337
	addDataFormatDesc(R8G8B8_SINT, Invalid, Invalid, Char3, Invalid, 1, 1, 3, ColorInt8);
338
	addDataFormatDesc(R8G8B8_SRGB, Invalid, Invalid, UChar3Normalized, Invalid, 1, 1, 3, ColorFloat);
339

340
	addDataFormatDesc(B8G8R8_UNORM, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorFloat);
341
	addDataFormatDesc(B8G8R8_SNORM, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorFloat);
342
	addDataFormatDesc(B8G8R8_USCALED, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorFloat);
343
	addDataFormatDesc(B8G8R8_SSCALED, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorFloat);
344
	addDataFormatDesc(B8G8R8_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorUInt8);
345
	addDataFormatDesc(B8G8R8_SINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorInt8);
346
	addDataFormatDesc(B8G8R8_SRGB, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, ColorFloat);
347

348
	addDataFormatDesc(R8G8B8A8_UNORM, RGBA8Unorm, Invalid, UChar4Normalized, Invalid, 1, 1, 4, ColorFloat);
349
	addDataFormatDesc(R8G8B8A8_SNORM, RGBA8Snorm, Invalid, Char4Normalized, Invalid, 1, 1, 4, ColorFloat);
350
	addDataFormatDesc(R8G8B8A8_USCALED, Invalid, Invalid, UChar4, Invalid, 1, 1, 4, ColorFloat);
351
	addDataFormatDesc(R8G8B8A8_SSCALED, Invalid, Invalid, Char4, Invalid, 1, 1, 4, ColorFloat);
352
	addDataFormatDesc(R8G8B8A8_UINT, RGBA8Uint, Invalid, UChar4, Invalid, 1, 1, 4, ColorUInt8);
353
	addDataFormatDesc(R8G8B8A8_SINT, RGBA8Sint, Invalid, Char4, Invalid, 1, 1, 4, ColorInt8);
354
	addDataFormatDesc(R8G8B8A8_SRGB, RGBA8Unorm_sRGB, Invalid, UChar4Normalized, Invalid, 1, 1, 4, ColorFloat);
355

356
	addDataFormatDesc(B8G8R8A8_UNORM, BGRA8Unorm, Invalid, UChar4Normalized_BGRA, Invalid, 1, 1, 4, ColorFloat);
357
	addDataFormatDescSwizzled(B8G8R8A8_SNORM, RGBA8Snorm, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat, B, G, R, A);
358
	addDataFormatDesc(B8G8R8A8_USCALED, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
359
	addDataFormatDesc(B8G8R8A8_SSCALED, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
360
	addDataFormatDescSwizzled(B8G8R8A8_UINT, RGBA8Uint, Invalid, Invalid, Invalid, 1, 1, 4, ColorUInt8, B, G, R, A);
361
	addDataFormatDescSwizzled(B8G8R8A8_SINT, RGBA8Sint, Invalid, Invalid, Invalid, 1, 1, 4, ColorInt8, B, G, R, A);
362
	addDataFormatDesc(B8G8R8A8_SRGB, BGRA8Unorm_sRGB, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
363

364
	addDataFormatDesc(A8B8G8R8_UNORM_PACK32, RGBA8Unorm, Invalid, UChar4Normalized, Invalid, 1, 1, 4, ColorFloat);
365
	addDataFormatDesc(A8B8G8R8_SNORM_PACK32, RGBA8Snorm, Invalid, Char4Normalized, Invalid, 1, 1, 4, ColorFloat);
366
	addDataFormatDesc(A8B8G8R8_USCALED_PACK32, Invalid, Invalid, UChar4, Invalid, 1, 1, 4, ColorFloat);
367
	addDataFormatDesc(A8B8G8R8_SSCALED_PACK32, Invalid, Invalid, Char4, Invalid, 1, 1, 4, ColorFloat);
368
	addDataFormatDesc(A8B8G8R8_UINT_PACK32, RGBA8Uint, Invalid, UChar4, Invalid, 1, 1, 4, ColorUInt8);
369
	addDataFormatDesc(A8B8G8R8_SINT_PACK32, RGBA8Sint, Invalid, Char4, Invalid, 1, 1, 4, ColorInt8);
370
	addDataFormatDesc(A8B8G8R8_SRGB_PACK32, RGBA8Unorm_sRGB, Invalid, UChar4Normalized, Invalid, 1, 1, 4, ColorFloat);
371

372
	addDataFormatDesc(A2R10G10B10_UNORM_PACK32, BGR10A2Unorm, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
373
	addDataFormatDesc(A2R10G10B10_SNORM_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
374
	addDataFormatDesc(A2R10G10B10_USCALED_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
375
	addDataFormatDesc(A2R10G10B10_SSCALED_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
376
	addDataFormatDesc(A2R10G10B10_UINT_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorUInt16);
377
	addDataFormatDesc(A2R10G10B10_SINT_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorInt16);
378

379
	addDataFormatDesc(A2B10G10R10_UNORM_PACK32, RGB10A2Unorm, Invalid, UInt1010102Normalized, Invalid, 1, 1, 4, ColorFloat);
380
	addDataFormatDesc(A2B10G10R10_SNORM_PACK32, Invalid, Invalid, Int1010102Normalized, Invalid, 1, 1, 4, ColorFloat);
381
	addDataFormatDesc(A2B10G10R10_USCALED_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
382
	addDataFormatDesc(A2B10G10R10_SSCALED_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
383
	addDataFormatDesc(A2B10G10R10_UINT_PACK32, RGB10A2Uint, Invalid, Invalid, Invalid, 1, 1, 4, ColorUInt16);
384
	addDataFormatDesc(A2B10G10R10_SINT_PACK32, Invalid, Invalid, Invalid, Invalid, 1, 1, 4, ColorInt16);
385

386
	addDataFormatDesc(R16_UNORM, R16Unorm, Invalid, UShortNormalized, UShort2Normalized, 1, 1, 2, ColorFloat);
387
	addDataFormatDesc(R16_SNORM, R16Snorm, Invalid, ShortNormalized, Short2Normalized, 1, 1, 2, ColorFloat);
388
	addDataFormatDesc(R16_USCALED, Invalid, Invalid, UShort, UShort2, 1, 1, 2, ColorFloat);
389
	addDataFormatDesc(R16_SSCALED, Invalid, Invalid, Short, Short2, 1, 1, 2, ColorFloat);
390
	addDataFormatDesc(R16_UINT, R16Uint, Invalid, UShort, UShort2, 1, 1, 2, ColorUInt16);
391
	addDataFormatDesc(R16_SINT, R16Sint, Invalid, Short, Short2, 1, 1, 2, ColorInt16);
392
	addDataFormatDesc(R16_SFLOAT, R16Float, Invalid, Half, Half2, 1, 1, 2, ColorFloat);
393

394
	addDataFormatDesc(R16G16_UNORM, RG16Unorm, Invalid, UShort2Normalized, Invalid, 1, 1, 4, ColorFloat);
395
	addDataFormatDesc(R16G16_SNORM, RG16Snorm, Invalid, Short2Normalized, Invalid, 1, 1, 4, ColorFloat);
396
	addDataFormatDesc(R16G16_USCALED, Invalid, Invalid, UShort2, Invalid, 1, 1, 4, ColorFloat);
397
	addDataFormatDesc(R16G16_SSCALED, Invalid, Invalid, Short2, Invalid, 1, 1, 4, ColorFloat);
398
	addDataFormatDesc(R16G16_UINT, RG16Uint, Invalid, UShort2, Invalid, 1, 1, 4, ColorUInt16);
399
	addDataFormatDesc(R16G16_SINT, RG16Sint, Invalid, Short2, Invalid, 1, 1, 4, ColorInt16);
400
	addDataFormatDesc(R16G16_SFLOAT, RG16Float, Invalid, Half2, Invalid, 1, 1, 4, ColorFloat);
401

402
	addDataFormatDesc(R16G16B16_UNORM, Invalid, Invalid, UShort3Normalized, Invalid, 1, 1, 6, ColorFloat);
403
	addDataFormatDesc(R16G16B16_SNORM, Invalid, Invalid, Short3Normalized, Invalid, 1, 1, 6, ColorFloat);
404
	addDataFormatDesc(R16G16B16_USCALED, Invalid, Invalid, UShort3, Invalid, 1, 1, 6, ColorFloat);
405
	addDataFormatDesc(R16G16B16_SSCALED, Invalid, Invalid, Short3, Invalid, 1, 1, 6, ColorFloat);
406
	addDataFormatDesc(R16G16B16_UINT, Invalid, Invalid, UShort3, Invalid, 1, 1, 6, ColorUInt16);
407
	addDataFormatDesc(R16G16B16_SINT, Invalid, Invalid, Short3, Invalid, 1, 1, 6, ColorInt16);
408
	addDataFormatDesc(R16G16B16_SFLOAT, Invalid, Invalid, Half3, Invalid, 1, 1, 6, ColorFloat);
409

410
	addDataFormatDesc(R16G16B16A16_UNORM, RGBA16Unorm, Invalid, UShort4Normalized, Invalid, 1, 1, 8, ColorFloat);
411
	addDataFormatDesc(R16G16B16A16_SNORM, RGBA16Snorm, Invalid, Short4Normalized, Invalid, 1, 1, 8, ColorFloat);
412
	addDataFormatDesc(R16G16B16A16_USCALED, Invalid, Invalid, UShort4, Invalid, 1, 1, 8, ColorFloat);
413
	addDataFormatDesc(R16G16B16A16_SSCALED, Invalid, Invalid, Short4, Invalid, 1, 1, 8, ColorFloat);
414
	addDataFormatDesc(R16G16B16A16_UINT, RGBA16Uint, Invalid, UShort4, Invalid, 1, 1, 8, ColorUInt16);
415
	addDataFormatDesc(R16G16B16A16_SINT, RGBA16Sint, Invalid, Short4, Invalid, 1, 1, 8, ColorInt16);
416
	addDataFormatDesc(R16G16B16A16_SFLOAT, RGBA16Float, Invalid, Half4, Invalid, 1, 1, 8, ColorFloat);
417

418
	addDataFormatDesc(R32_UINT, R32Uint, Invalid, UInt, Invalid, 1, 1, 4, ColorUInt32);
419
	addDataFormatDesc(R32_SINT, R32Sint, Invalid, Int, Invalid, 1, 1, 4, ColorInt32);
420
	addDataFormatDesc(R32_SFLOAT, R32Float, Invalid, Float, Invalid, 1, 1, 4, ColorFloat);
421

422
	addDataFormatDesc(R32G32_UINT, RG32Uint, Invalid, UInt2, Invalid, 1, 1, 8, ColorUInt32);
423
	addDataFormatDesc(R32G32_SINT, RG32Sint, Invalid, Int2, Invalid, 1, 1, 8, ColorInt32);
424
	addDataFormatDesc(R32G32_SFLOAT, RG32Float, Invalid, Float2, Invalid, 1, 1, 8, ColorFloat);
425

426
	addDataFormatDesc(R32G32B32_UINT, Invalid, Invalid, UInt3, Invalid, 1, 1, 12, ColorUInt32);
427
	addDataFormatDesc(R32G32B32_SINT, Invalid, Invalid, Int3, Invalid, 1, 1, 12, ColorInt32);
428
	addDataFormatDesc(R32G32B32_SFLOAT, Invalid, Invalid, Float3, Invalid, 1, 1, 12, ColorFloat);
429

430
	addDataFormatDesc(R32G32B32A32_UINT, RGBA32Uint, Invalid, UInt4, Invalid, 1, 1, 16, ColorUInt32);
431
	addDataFormatDesc(R32G32B32A32_SINT, RGBA32Sint, Invalid, Int4, Invalid, 1, 1, 16, ColorInt32);
432
	addDataFormatDesc(R32G32B32A32_SFLOAT, RGBA32Float, Invalid, Float4, Invalid, 1, 1, 16, ColorFloat);
433

434
	addDataFormatDesc(R64_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 8, ColorFloat);
435
	addDataFormatDesc(R64_SINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 8, ColorFloat);
436
	addDataFormatDesc(R64_SFLOAT, Invalid, Invalid, Invalid, Invalid, 1, 1, 8, ColorFloat);
437

438
	addDataFormatDesc(R64G64_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 16, ColorFloat);
439
	addDataFormatDesc(R64G64_SINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 16, ColorFloat);
440
	addDataFormatDesc(R64G64_SFLOAT, Invalid, Invalid, Invalid, Invalid, 1, 1, 16, ColorFloat);
441

442
	addDataFormatDesc(R64G64B64_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 24, ColorFloat);
443
	addDataFormatDesc(R64G64B64_SINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 24, ColorFloat);
444
	addDataFormatDesc(R64G64B64_SFLOAT, Invalid, Invalid, Invalid, Invalid, 1, 1, 24, ColorFloat);
445

446
	addDataFormatDesc(R64G64B64A64_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 32, ColorFloat);
447
	addDataFormatDesc(R64G64B64A64_SINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 32, ColorFloat);
448
	addDataFormatDesc(R64G64B64A64_SFLOAT, Invalid, Invalid, Invalid, Invalid, 1, 1, 32, ColorFloat);
449

450
	addDataFormatDesc(B10G11R11_UFLOAT_PACK32, RG11B10Float, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
451
	addDataFormatDesc(E5B9G9R9_UFLOAT_PACK32, RGB9E5Float, Invalid, Invalid, Invalid, 1, 1, 4, ColorFloat);
452

453
	addDataFormatDesc(D32_SFLOAT, Depth32Float, Invalid, Invalid, Invalid, 1, 1, 4, DepthStencil);
454
	addDataFormatDesc(D32_SFLOAT_S8_UINT, Depth32Float_Stencil8, Invalid, Invalid, Invalid, 1, 1, 5, DepthStencil);
455

456
	addDataFormatDesc(S8_UINT, Stencil8, Invalid, Invalid, Invalid, 1, 1, 1, DepthStencil);
457

458
	addDataFormatDesc(D16_UNORM, Depth16Unorm, Depth32Float, Invalid, Invalid, 1, 1, 2, DepthStencil);
459
	addDataFormatDesc(D16_UNORM_S8_UINT, Invalid, Invalid, Invalid, Invalid, 1, 1, 3, DepthStencil);
460
	addDataFormatDesc(D24_UNORM_S8_UINT, Depth24Unorm_Stencil8, Depth32Float_Stencil8, Invalid, Invalid, 1, 1, 4, DepthStencil);
461

462
	addDataFormatDesc(X8_D24_UNORM_PACK32, Invalid, Depth24Unorm_Stencil8, Invalid, Invalid, 1, 1, 4, DepthStencil);
463

464
	GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability")
465

466
	addDataFormatDesc(BC1_RGB_UNORM_BLOCK, BC1_RGBA, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
467
	addDataFormatDesc(BC1_RGB_SRGB_BLOCK, BC1_RGBA_sRGB, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
468
	addDataFormatDesc(BC1_RGBA_UNORM_BLOCK, BC1_RGBA, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
469
	addDataFormatDesc(BC1_RGBA_SRGB_BLOCK, BC1_RGBA_sRGB, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
470

471
	addDataFormatDesc(BC2_UNORM_BLOCK, BC2_RGBA, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
472
	addDataFormatDesc(BC2_SRGB_BLOCK, BC2_RGBA_sRGB, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
473

474
	addDataFormatDesc(BC3_UNORM_BLOCK, BC3_RGBA, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
475
	addDataFormatDesc(BC3_SRGB_BLOCK, BC3_RGBA_sRGB, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
476

477
	addDataFormatDesc(BC4_UNORM_BLOCK, BC4_RUnorm, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
478
	addDataFormatDesc(BC4_SNORM_BLOCK, BC4_RSnorm, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
479

480
	addDataFormatDesc(BC5_UNORM_BLOCK, BC5_RGUnorm, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
481
	addDataFormatDesc(BC5_SNORM_BLOCK, BC5_RGSnorm, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
482

483
	addDataFormatDesc(BC6H_UFLOAT_BLOCK, BC6H_RGBUfloat, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
484
	addDataFormatDesc(BC6H_SFLOAT_BLOCK, BC6H_RGBFloat, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
485

486
	addDataFormatDesc(BC7_UNORM_BLOCK, BC7_RGBAUnorm, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
487
	addDataFormatDesc(BC7_SRGB_BLOCK, BC7_RGBAUnorm_sRGB, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
488

489
	GODOT_CLANG_WARNING_POP
490

491
	addDataFormatDesc(ETC2_R8G8B8_UNORM_BLOCK, ETC2_RGB8, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
492
	addDataFormatDesc(ETC2_R8G8B8_SRGB_BLOCK, ETC2_RGB8_sRGB, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
493
	addDataFormatDesc(ETC2_R8G8B8A1_UNORM_BLOCK, ETC2_RGB8A1, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
494
	addDataFormatDesc(ETC2_R8G8B8A1_SRGB_BLOCK, ETC2_RGB8A1_sRGB, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
495

496
	addDataFormatDesc(ETC2_R8G8B8A8_UNORM_BLOCK, EAC_RGBA8, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
497
	addDataFormatDesc(ETC2_R8G8B8A8_SRGB_BLOCK, EAC_RGBA8_sRGB, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
498

499
	addDataFormatDesc(EAC_R11_UNORM_BLOCK, EAC_R11Unorm, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
500
	addDataFormatDesc(EAC_R11_SNORM_BLOCK, EAC_R11Snorm, Invalid, Invalid, Invalid, 4, 4, 8, Compressed);
501

502
	addDataFormatDesc(EAC_R11G11_UNORM_BLOCK, EAC_RG11Unorm, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
503
	addDataFormatDesc(EAC_R11G11_SNORM_BLOCK, EAC_RG11Snorm, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
504

505
	addDataFormatDesc(ASTC_4x4_UNORM_BLOCK, ASTC_4x4_LDR, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
506
	addDataFormatDesc(ASTC_4x4_SFLOAT_BLOCK, ASTC_4x4_HDR, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
507
	addDataFormatDesc(ASTC_4x4_SRGB_BLOCK, ASTC_4x4_sRGB, Invalid, Invalid, Invalid, 4, 4, 16, Compressed);
508
	addDataFormatDesc(ASTC_5x4_UNORM_BLOCK, ASTC_5x4_LDR, Invalid, Invalid, Invalid, 5, 4, 16, Compressed);
509
	addDataFormatDesc(ASTC_5x4_SFLOAT_BLOCK, ASTC_5x4_HDR, Invalid, Invalid, Invalid, 5, 4, 16, Compressed);
510
	addDataFormatDesc(ASTC_5x4_SRGB_BLOCK, ASTC_5x4_sRGB, Invalid, Invalid, Invalid, 5, 4, 16, Compressed);
511
	addDataFormatDesc(ASTC_5x5_UNORM_BLOCK, ASTC_5x5_LDR, Invalid, Invalid, Invalid, 5, 5, 16, Compressed);
512
	addDataFormatDesc(ASTC_5x5_SFLOAT_BLOCK, ASTC_5x5_HDR, Invalid, Invalid, Invalid, 5, 5, 16, Compressed);
513
	addDataFormatDesc(ASTC_5x5_SRGB_BLOCK, ASTC_5x5_sRGB, Invalid, Invalid, Invalid, 5, 5, 16, Compressed);
514
	addDataFormatDesc(ASTC_6x5_UNORM_BLOCK, ASTC_6x5_LDR, Invalid, Invalid, Invalid, 6, 5, 16, Compressed);
515
	addDataFormatDesc(ASTC_6x5_SFLOAT_BLOCK, ASTC_6x5_HDR, Invalid, Invalid, Invalid, 6, 5, 16, Compressed);
516
	addDataFormatDesc(ASTC_6x5_SRGB_BLOCK, ASTC_6x5_sRGB, Invalid, Invalid, Invalid, 6, 5, 16, Compressed);
517
	addDataFormatDesc(ASTC_6x6_UNORM_BLOCK, ASTC_6x6_LDR, Invalid, Invalid, Invalid, 6, 6, 16, Compressed);
518
	addDataFormatDesc(ASTC_6x6_SFLOAT_BLOCK, ASTC_6x6_HDR, Invalid, Invalid, Invalid, 6, 6, 16, Compressed);
519
	addDataFormatDesc(ASTC_6x6_SRGB_BLOCK, ASTC_6x6_sRGB, Invalid, Invalid, Invalid, 6, 6, 16, Compressed);
520
	addDataFormatDesc(ASTC_8x5_UNORM_BLOCK, ASTC_8x5_LDR, Invalid, Invalid, Invalid, 8, 5, 16, Compressed);
521
	addDataFormatDesc(ASTC_8x5_SFLOAT_BLOCK, ASTC_8x5_HDR, Invalid, Invalid, Invalid, 8, 5, 16, Compressed);
522
	addDataFormatDesc(ASTC_8x5_SRGB_BLOCK, ASTC_8x5_sRGB, Invalid, Invalid, Invalid, 8, 5, 16, Compressed);
523
	addDataFormatDesc(ASTC_8x6_UNORM_BLOCK, ASTC_8x6_LDR, Invalid, Invalid, Invalid, 8, 6, 16, Compressed);
524
	addDataFormatDesc(ASTC_8x6_SFLOAT_BLOCK, ASTC_8x6_HDR, Invalid, Invalid, Invalid, 8, 6, 16, Compressed);
525
	addDataFormatDesc(ASTC_8x6_SRGB_BLOCK, ASTC_8x6_sRGB, Invalid, Invalid, Invalid, 8, 6, 16, Compressed);
526
	addDataFormatDesc(ASTC_8x8_UNORM_BLOCK, ASTC_8x8_LDR, Invalid, Invalid, Invalid, 8, 8, 16, Compressed);
527
	addDataFormatDesc(ASTC_8x8_SFLOAT_BLOCK, ASTC_8x8_HDR, Invalid, Invalid, Invalid, 8, 8, 16, Compressed);
528
	addDataFormatDesc(ASTC_8x8_SRGB_BLOCK, ASTC_8x8_sRGB, Invalid, Invalid, Invalid, 8, 8, 16, Compressed);
529
	addDataFormatDesc(ASTC_10x5_UNORM_BLOCK, ASTC_10x5_LDR, Invalid, Invalid, Invalid, 10, 5, 16, Compressed);
530
	addDataFormatDesc(ASTC_10x5_SFLOAT_BLOCK, ASTC_10x5_HDR, Invalid, Invalid, Invalid, 10, 5, 16, Compressed);
531
	addDataFormatDesc(ASTC_10x5_SRGB_BLOCK, ASTC_10x5_sRGB, Invalid, Invalid, Invalid, 10, 5, 16, Compressed);
532
	addDataFormatDesc(ASTC_10x6_UNORM_BLOCK, ASTC_10x6_LDR, Invalid, Invalid, Invalid, 10, 6, 16, Compressed);
533
	addDataFormatDesc(ASTC_10x6_SFLOAT_BLOCK, ASTC_10x6_HDR, Invalid, Invalid, Invalid, 10, 6, 16, Compressed);
534
	addDataFormatDesc(ASTC_10x6_SRGB_BLOCK, ASTC_10x6_sRGB, Invalid, Invalid, Invalid, 10, 6, 16, Compressed);
535
	addDataFormatDesc(ASTC_10x8_UNORM_BLOCK, ASTC_10x8_LDR, Invalid, Invalid, Invalid, 10, 8, 16, Compressed);
536
	addDataFormatDesc(ASTC_10x8_SFLOAT_BLOCK, ASTC_10x8_HDR, Invalid, Invalid, Invalid, 10, 8, 16, Compressed);
537
	addDataFormatDesc(ASTC_10x8_SRGB_BLOCK, ASTC_10x8_sRGB, Invalid, Invalid, Invalid, 10, 8, 16, Compressed);
538
	addDataFormatDesc(ASTC_10x10_UNORM_BLOCK, ASTC_10x10_LDR, Invalid, Invalid, Invalid, 10, 10, 16, Compressed);
539
	addDataFormatDesc(ASTC_10x10_SFLOAT_BLOCK, ASTC_10x10_HDR, Invalid, Invalid, Invalid, 10, 10, 16, Compressed);
540
	addDataFormatDesc(ASTC_10x10_SRGB_BLOCK, ASTC_10x10_sRGB, Invalid, Invalid, Invalid, 10, 10, 16, Compressed);
541
	addDataFormatDesc(ASTC_12x10_UNORM_BLOCK, ASTC_12x10_LDR, Invalid, Invalid, Invalid, 12, 10, 16, Compressed);
542
	addDataFormatDesc(ASTC_12x10_SFLOAT_BLOCK, ASTC_12x10_HDR, Invalid, Invalid, Invalid, 12, 10, 16, Compressed);
543
	addDataFormatDesc(ASTC_12x10_SRGB_BLOCK, ASTC_12x10_sRGB, Invalid, Invalid, Invalid, 12, 10, 16, Compressed);
544
	addDataFormatDesc(ASTC_12x12_UNORM_BLOCK, ASTC_12x12_LDR, Invalid, Invalid, Invalid, 12, 12, 16, Compressed);
545
	addDataFormatDesc(ASTC_12x12_SFLOAT_BLOCK, ASTC_12x12_HDR, Invalid, Invalid, Invalid, 12, 12, 16, Compressed);
546
	addDataFormatDesc(ASTC_12x12_SRGB_BLOCK, ASTC_12x12_sRGB, Invalid, Invalid, Invalid, 12, 12, 16, Compressed);
547

548
	addDfFormatDescChromaSubsampling(G8B8G8R8_422_UNORM, GBGR422, 1, 8, 2, 1, 4);
549
	addDfFormatDescChromaSubsampling(B8G8R8G8_422_UNORM, BGRG422, 1, 8, 2, 1, 4);
550
	addDfFormatDescChromaSubsampling(G8_B8_R8_3PLANE_420_UNORM, Invalid, 3, 8, 2, 2, 6);
551
	addDfFormatDescChromaSubsampling(G8_B8R8_2PLANE_420_UNORM, Invalid, 2, 8, 2, 2, 6);
552
	addDfFormatDescChromaSubsampling(G8_B8_R8_3PLANE_422_UNORM, Invalid, 3, 8, 2, 1, 4);
553
	addDfFormatDescChromaSubsampling(G8_B8R8_2PLANE_422_UNORM, Invalid, 2, 8, 2, 1, 4);
554
	addDfFormatDescChromaSubsampling(G8_B8_R8_3PLANE_444_UNORM, Invalid, 3, 8, 1, 1, 3);
555
	addDfFormatDescChromaSubsampling(R10X6_UNORM_PACK16, R16Unorm, 0, 10, 1, 1, 2);
556
	addDfFormatDescChromaSubsampling(R10X6G10X6_UNORM_2PACK16, RG16Unorm, 0, 10, 1, 1, 4);
557
	addDfFormatDescChromaSubsampling(R10X6G10X6B10X6A10X6_UNORM_4PACK16, RGBA16Unorm, 0, 10, 1, 1, 8);
558
	addDfFormatDescChromaSubsampling(G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, Invalid, 1, 10, 2, 1, 8);
559
	addDfFormatDescChromaSubsampling(B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, Invalid, 1, 10, 2, 1, 8);
560
	addDfFormatDescChromaSubsampling(G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, Invalid, 3, 10, 2, 2, 12);
561
	addDfFormatDescChromaSubsampling(G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, Invalid, 2, 10, 2, 2, 12);
562
	addDfFormatDescChromaSubsampling(G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, Invalid, 3, 10, 2, 1, 8);
563
	addDfFormatDescChromaSubsampling(G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, Invalid, 2, 10, 2, 1, 8);
564
	addDfFormatDescChromaSubsampling(G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, Invalid, 3, 10, 1, 1, 6);
565
	addDfFormatDescChromaSubsampling(R12X4_UNORM_PACK16, R16Unorm, 0, 12, 1, 1, 2);
566
	addDfFormatDescChromaSubsampling(R12X4G12X4_UNORM_2PACK16, RG16Unorm, 0, 12, 1, 1, 4);
567
	addDfFormatDescChromaSubsampling(R12X4G12X4B12X4A12X4_UNORM_4PACK16, RGBA16Unorm, 0, 12, 1, 1, 8);
568
	addDfFormatDescChromaSubsampling(G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, Invalid, 1, 12, 2, 1, 8);
569
	addDfFormatDescChromaSubsampling(B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, Invalid, 1, 12, 2, 1, 8);
570
	addDfFormatDescChromaSubsampling(G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, Invalid, 3, 12, 2, 2, 12);
571
	addDfFormatDescChromaSubsampling(G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, Invalid, 2, 12, 2, 2, 12);
572
	addDfFormatDescChromaSubsampling(G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, Invalid, 3, 12, 2, 1, 8);
573
	addDfFormatDescChromaSubsampling(G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, Invalid, 2, 12, 2, 1, 8);
574
	addDfFormatDescChromaSubsampling(G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, Invalid, 3, 12, 1, 1, 6);
575
	addDfFormatDescChromaSubsampling(G16B16G16R16_422_UNORM, Invalid, 1, 16, 2, 1, 8);
576
	addDfFormatDescChromaSubsampling(B16G16R16G16_422_UNORM, Invalid, 1, 16, 2, 1, 8);
577
	addDfFormatDescChromaSubsampling(G16_B16_R16_3PLANE_420_UNORM, Invalid, 3, 16, 2, 2, 12);
578
	addDfFormatDescChromaSubsampling(G16_B16R16_2PLANE_420_UNORM, Invalid, 2, 16, 2, 2, 12);
579
	addDfFormatDescChromaSubsampling(G16_B16_R16_3PLANE_422_UNORM, Invalid, 3, 16, 2, 1, 8);
580
	addDfFormatDescChromaSubsampling(G16_B16R16_2PLANE_422_UNORM, Invalid, 2, 16, 2, 1, 8);
581
	addDfFormatDescChromaSubsampling(G16_B16_R16_3PLANE_444_UNORM, Invalid, 3, 16, 1, 1, 6);
582
}
583

584
void PixelFormats::addMTLPixelFormatDescImpl(MTL::PixelFormat p_pix_fmt, MTL::PixelFormat p_pix_fmt_linear,
585
		MTLViewClass p_view_class, MTLFmtCaps p_fmt_caps, const char *p_name) {
586
	_mtl_pixel_format_descs[p_pix_fmt] = { .mtlPixelFormat = p_pix_fmt, DataFormat::DATA_FORMAT_MAX, p_fmt_caps, p_view_class, p_pix_fmt_linear, p_name };
587
}
588

589
#define addMTLPixelFormatDescFull(mtlFmt, mtlFmtLinear, viewClass, appleGPUCaps) \
590
	addMTLPixelFormatDescImpl(MTL::PixelFormat##mtlFmt, MTL::PixelFormat##mtlFmtLinear, MTLViewClass::viewClass, \
591
			appleGPUCaps, "MTL::PixelFormat" #mtlFmt)
592

593
#define addMTLPixelFormatDesc(mtlFmt, viewClass, appleGPUCaps) \
594
	addMTLPixelFormatDescFull(mtlFmt, mtlFmt, viewClass, kMTLFmtCaps##appleGPUCaps)
595

596
#define addMTLPixelFormatDescSRGB(mtlFmt, viewClass, appleGPUCaps, mtlFmtLinear) \
597
	/* Cannot write to sRGB textures in the simulator */ \
598
	if (TARGET_OS_SIMULATOR) { \
599
		MTLFmtCaps appleFmtCaps = kMTLFmtCaps##appleGPUCaps; \
600
		flags::clear(appleFmtCaps, kMTLFmtCapsWrite); \
601
		addMTLPixelFormatDescFull(mtlFmt, mtlFmtLinear, viewClass, appleFmtCaps); \
602
	} else { \
603
		addMTLPixelFormatDescFull(mtlFmt, mtlFmtLinear, viewClass, kMTLFmtCaps##appleGPUCaps); \
604
	}
605

606
void PixelFormats::initMTLPixelFormatCapabilities() {
607
	_mtl_pixel_format_descs.reserve(1024);
608

609
	// MTL::PixelFormatInvalid must come first. Use addMTLPixelFormatDescImpl to avoid guard code.
610
	addMTLPixelFormatDescImpl(MTL::PixelFormatInvalid, MTL::PixelFormatInvalid, MTLViewClass::None, kMTLFmtCapsNone, "MTL::PixelFormatInvalid");
611

612
	// Ordinary 8-bit pixel formats.
613
	addMTLPixelFormatDesc(A8Unorm, Color8, All);
614
	addMTLPixelFormatDesc(R8Unorm, Color8, All);
615
	addMTLPixelFormatDescSRGB(R8Unorm_sRGB, Color8, All, R8Unorm);
616
	addMTLPixelFormatDesc(R8Snorm, Color8, All);
617
	addMTLPixelFormatDesc(R8Uint, Color8, RWCM);
618
	addMTLPixelFormatDesc(R8Sint, Color8, RWCM);
619

620
	// Ordinary 16-bit pixel formats
621
	addMTLPixelFormatDesc(R16Unorm, Color16, RFWCMB);
622
	addMTLPixelFormatDesc(R16Snorm, Color16, RFWCMB);
623
	addMTLPixelFormatDesc(R16Uint, Color16, RWCM);
624
	addMTLPixelFormatDesc(R16Sint, Color16, RWCM);
625
	addMTLPixelFormatDesc(R16Float, Color16, All);
626

627
	addMTLPixelFormatDesc(RG8Unorm, Color16, All);
628
	addMTLPixelFormatDescSRGB(RG8Unorm_sRGB, Color16, All, RG8Unorm);
629
	addMTLPixelFormatDesc(RG8Snorm, Color16, All);
630
	addMTLPixelFormatDesc(RG8Uint, Color16, RWCM);
631
	addMTLPixelFormatDesc(RG8Sint, Color16, RWCM);
632

633
	// Packed 16-bit pixel formats
634
	addMTLPixelFormatDesc(B5G6R5Unorm, Color16, RFCMRB);
635
	addMTLPixelFormatDesc(A1BGR5Unorm, Color16, RFCMRB);
636
	addMTLPixelFormatDesc(ABGR4Unorm, Color16, RFCMRB);
637
	addMTLPixelFormatDesc(BGR5A1Unorm, Color16, RFCMRB);
638

639
	// Ordinary 32-bit pixel formats
640
	addMTLPixelFormatDesc(R32Uint, Color32, RWC);
641
	addMTLPixelFormatDesc(R32Sint, Color32, RWC);
642
	addMTLPixelFormatDesc(R32Float, Color32, All);
643

644
	addMTLPixelFormatDesc(RG16Unorm, Color32, RFWCMB);
645
	addMTLPixelFormatDesc(RG16Snorm, Color32, RFWCMB);
646
	addMTLPixelFormatDesc(RG16Uint, Color32, RWCM);
647
	addMTLPixelFormatDesc(RG16Sint, Color32, RWCM);
648
	addMTLPixelFormatDesc(RG16Float, Color32, All);
649

650
	addMTLPixelFormatDesc(RGBA8Unorm, Color32, All);
651
	addMTLPixelFormatDescSRGB(RGBA8Unorm_sRGB, Color32, All, RGBA8Unorm);
652
	addMTLPixelFormatDesc(RGBA8Snorm, Color32, All);
653
	addMTLPixelFormatDesc(RGBA8Uint, Color32, RWCM);
654
	addMTLPixelFormatDesc(RGBA8Sint, Color32, RWCM);
655

656
	addMTLPixelFormatDesc(BGRA8Unorm, Color32, All);
657
	addMTLPixelFormatDescSRGB(BGRA8Unorm_sRGB, Color32, All, BGRA8Unorm);
658

659
	// Packed 32-bit pixel formats
660
	addMTLPixelFormatDesc(RGB10A2Unorm, Color32, All);
661
	addMTLPixelFormatDesc(BGR10A2Unorm, Color32, All);
662
	addMTLPixelFormatDesc(RGB10A2Uint, Color32, RWCM);
663
	addMTLPixelFormatDesc(RG11B10Float, Color32, All);
664
	addMTLPixelFormatDesc(RGB9E5Float, Color32, All);
665

666
	// Ordinary 64-bit pixel formats
667
	addMTLPixelFormatDesc(RG32Uint, Color64, RWCM);
668
	addMTLPixelFormatDesc(RG32Sint, Color64, RWCM);
669
	addMTLPixelFormatDesc(RG32Float, Color64, All);
670

671
	addMTLPixelFormatDesc(RGBA16Unorm, Color64, RFWCMB);
672
	addMTLPixelFormatDesc(RGBA16Snorm, Color64, RFWCMB);
673
	addMTLPixelFormatDesc(RGBA16Uint, Color64, RWCM);
674
	addMTLPixelFormatDesc(RGBA16Sint, Color64, RWCM);
675
	addMTLPixelFormatDesc(RGBA16Float, Color64, All);
676

677
	// Ordinary 128-bit pixel formats
678
	addMTLPixelFormatDesc(RGBA32Uint, Color128, RWC);
679
	addMTLPixelFormatDesc(RGBA32Sint, Color128, RWC);
680
	addMTLPixelFormatDesc(RGBA32Float, Color128, All);
681

682
#if !defined(VISIONOS_ENABLED)
683
	GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wdeprecated-declarations")
684
	// Compressed pixel formats
685
	addMTLPixelFormatDesc(PVRTC_RGBA_2BPP, PVRTC_RGBA_2BPP, RF);
686
	addMTLPixelFormatDescSRGB(PVRTC_RGBA_2BPP_sRGB, PVRTC_RGBA_2BPP, RF, PVRTC_RGBA_2BPP);
687
	addMTLPixelFormatDesc(PVRTC_RGBA_4BPP, PVRTC_RGBA_4BPP, RF);
688
	addMTLPixelFormatDescSRGB(PVRTC_RGBA_4BPP_sRGB, PVRTC_RGBA_4BPP, RF, PVRTC_RGBA_4BPP);
689
	GODOT_CLANG_WARNING_POP
690
#endif
691

692
	addMTLPixelFormatDesc(ETC2_RGB8, ETC2_RGB8, RF);
693
	addMTLPixelFormatDescSRGB(ETC2_RGB8_sRGB, ETC2_RGB8, RF, ETC2_RGB8);
694
	addMTLPixelFormatDesc(ETC2_RGB8A1, ETC2_RGB8A1, RF);
695
	addMTLPixelFormatDescSRGB(ETC2_RGB8A1_sRGB, ETC2_RGB8A1, RF, ETC2_RGB8A1);
696
	addMTLPixelFormatDesc(EAC_RGBA8, EAC_RGBA8, RF);
697
	addMTLPixelFormatDescSRGB(EAC_RGBA8_sRGB, EAC_RGBA8, RF, EAC_RGBA8);
698
	addMTLPixelFormatDesc(EAC_R11Unorm, EAC_R11, RF);
699
	addMTLPixelFormatDesc(EAC_R11Snorm, EAC_R11, RF);
700
	addMTLPixelFormatDesc(EAC_RG11Unorm, EAC_RG11, RF);
701
	addMTLPixelFormatDesc(EAC_RG11Snorm, EAC_RG11, RF);
702

703
	addMTLPixelFormatDesc(ASTC_4x4_LDR, ASTC_4x4, RF);
704
	addMTLPixelFormatDescSRGB(ASTC_4x4_sRGB, ASTC_4x4, RF, ASTC_4x4_LDR);
705
	addMTLPixelFormatDesc(ASTC_4x4_HDR, ASTC_4x4, RF);
706
	addMTLPixelFormatDesc(ASTC_5x4_LDR, ASTC_5x4, RF);
707
	addMTLPixelFormatDescSRGB(ASTC_5x4_sRGB, ASTC_5x4, RF, ASTC_5x4_LDR);
708
	addMTLPixelFormatDesc(ASTC_5x4_HDR, ASTC_5x4, RF);
709
	addMTLPixelFormatDesc(ASTC_5x5_LDR, ASTC_5x5, RF);
710
	addMTLPixelFormatDescSRGB(ASTC_5x5_sRGB, ASTC_5x5, RF, ASTC_5x5_LDR);
711
	addMTLPixelFormatDesc(ASTC_5x5_HDR, ASTC_5x5, RF);
712
	addMTLPixelFormatDesc(ASTC_6x5_LDR, ASTC_6x5, RF);
713
	addMTLPixelFormatDescSRGB(ASTC_6x5_sRGB, ASTC_6x5, RF, ASTC_6x5_LDR);
714
	addMTLPixelFormatDesc(ASTC_6x5_HDR, ASTC_6x5, RF);
715
	addMTLPixelFormatDesc(ASTC_6x6_LDR, ASTC_6x6, RF);
716
	addMTLPixelFormatDescSRGB(ASTC_6x6_sRGB, ASTC_6x6, RF, ASTC_6x6_LDR);
717
	addMTLPixelFormatDesc(ASTC_6x6_HDR, ASTC_6x6, RF);
718
	addMTLPixelFormatDesc(ASTC_8x5_LDR, ASTC_8x5, RF);
719
	addMTLPixelFormatDescSRGB(ASTC_8x5_sRGB, ASTC_8x5, RF, ASTC_8x5_LDR);
720
	addMTLPixelFormatDesc(ASTC_8x5_HDR, ASTC_8x5, RF);
721
	addMTLPixelFormatDesc(ASTC_8x6_LDR, ASTC_8x6, RF);
722
	addMTLPixelFormatDescSRGB(ASTC_8x6_sRGB, ASTC_8x6, RF, ASTC_8x6_LDR);
723
	addMTLPixelFormatDesc(ASTC_8x6_HDR, ASTC_8x6, RF);
724
	addMTLPixelFormatDesc(ASTC_8x8_LDR, ASTC_8x8, RF);
725
	addMTLPixelFormatDescSRGB(ASTC_8x8_sRGB, ASTC_8x8, RF, ASTC_8x8_LDR);
726
	addMTLPixelFormatDesc(ASTC_8x8_HDR, ASTC_8x8, RF);
727
	addMTLPixelFormatDesc(ASTC_10x5_LDR, ASTC_10x5, RF);
728
	addMTLPixelFormatDescSRGB(ASTC_10x5_sRGB, ASTC_10x5, RF, ASTC_10x5_LDR);
729
	addMTLPixelFormatDesc(ASTC_10x5_HDR, ASTC_10x5, RF);
730
	addMTLPixelFormatDesc(ASTC_10x6_LDR, ASTC_10x6, RF);
731
	addMTLPixelFormatDescSRGB(ASTC_10x6_sRGB, ASTC_10x6, RF, ASTC_10x6_LDR);
732
	addMTLPixelFormatDesc(ASTC_10x6_HDR, ASTC_10x6, RF);
733
	addMTLPixelFormatDesc(ASTC_10x8_LDR, ASTC_10x8, RF);
734
	addMTLPixelFormatDescSRGB(ASTC_10x8_sRGB, ASTC_10x8, RF, ASTC_10x8_LDR);
735
	addMTLPixelFormatDesc(ASTC_10x8_HDR, ASTC_10x8, RF);
736
	addMTLPixelFormatDesc(ASTC_10x10_LDR, ASTC_10x10, RF);
737
	addMTLPixelFormatDescSRGB(ASTC_10x10_sRGB, ASTC_10x10, RF, ASTC_10x10_LDR);
738
	addMTLPixelFormatDesc(ASTC_10x10_HDR, ASTC_10x10, RF);
739
	addMTLPixelFormatDesc(ASTC_12x10_LDR, ASTC_12x10, RF);
740
	addMTLPixelFormatDescSRGB(ASTC_12x10_sRGB, ASTC_12x10, RF, ASTC_12x10_LDR);
741
	addMTLPixelFormatDesc(ASTC_12x10_HDR, ASTC_12x10, RF);
742
	addMTLPixelFormatDesc(ASTC_12x12_LDR, ASTC_12x12, RF);
743
	addMTLPixelFormatDescSRGB(ASTC_12x12_sRGB, ASTC_12x12, RF, ASTC_12x12_LDR);
744
	addMTLPixelFormatDesc(ASTC_12x12_HDR, ASTC_12x12, RF);
745

746
	GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability")
747

748
	addMTLPixelFormatDesc(BC1_RGBA, BC1_RGBA, RF);
749
	addMTLPixelFormatDescSRGB(BC1_RGBA_sRGB, BC1_RGBA, RF, BC1_RGBA);
750
	addMTLPixelFormatDesc(BC2_RGBA, BC2_RGBA, RF);
751
	addMTLPixelFormatDescSRGB(BC2_RGBA_sRGB, BC2_RGBA, RF, BC2_RGBA);
752
	addMTLPixelFormatDesc(BC3_RGBA, BC3_RGBA, RF);
753
	addMTLPixelFormatDescSRGB(BC3_RGBA_sRGB, BC3_RGBA, RF, BC3_RGBA);
754
	addMTLPixelFormatDesc(BC4_RUnorm, BC4_R, RF);
755
	addMTLPixelFormatDesc(BC4_RSnorm, BC4_R, RF);
756
	addMTLPixelFormatDesc(BC5_RGUnorm, BC5_RG, RF);
757
	addMTLPixelFormatDesc(BC5_RGSnorm, BC5_RG, RF);
758
	addMTLPixelFormatDesc(BC6H_RGBUfloat, BC6H_RGB, RF);
759
	addMTLPixelFormatDesc(BC6H_RGBFloat, BC6H_RGB, RF);
760
	addMTLPixelFormatDesc(BC7_RGBAUnorm, BC7_RGBA, RF);
761
	addMTLPixelFormatDescSRGB(BC7_RGBAUnorm_sRGB, BC7_RGBA, RF, BC7_RGBAUnorm);
762

763
	GODOT_CLANG_WARNING_POP
764

765
	// YUV pixel formats
766
	addMTLPixelFormatDesc(GBGR422, None, RF);
767
	addMTLPixelFormatDesc(BGRG422, None, RF);
768

769
	// Extended range and wide color pixel formats
770
	addMTLPixelFormatDesc(BGRA10_XR, BGRA10_XR, All);
771
	addMTLPixelFormatDescSRGB(BGRA10_XR_sRGB, BGRA10_XR, All, BGRA10_XR);
772
	addMTLPixelFormatDesc(BGR10_XR, BGR10_XR, All);
773
	addMTLPixelFormatDescSRGB(BGR10_XR_sRGB, BGR10_XR, All, BGR10_XR);
774

775
	// Depth and stencil pixel formats
776
	addMTLPixelFormatDesc(Depth16Unorm, None, DRFMR);
777
	addMTLPixelFormatDesc(Depth32Float, None, DRMR);
778
	addMTLPixelFormatDesc(Stencil8, None, DRM);
779
	addMTLPixelFormatDesc(Depth24Unorm_Stencil8, Depth24_Stencil8, None);
780
	addMTLPixelFormatDesc(Depth32Float_Stencil8, Depth32_Stencil8, DRMR);
781
	addMTLPixelFormatDesc(X24_Stencil8, Depth24_Stencil8, None);
782
	addMTLPixelFormatDesc(X32_Stencil8, Depth32_Stencil8, DRM);
783
}
784

785
// If necessary, resize vector with empty elements.
786
void PixelFormats::addMTLVertexFormatDescImpl(MTL::VertexFormat mtlVtxFmt, MTLFmtCaps vtxCap, const char *name) {
787
	if (mtlVtxFmt >= _mtl_vertex_format_descs.size()) {
788
		_mtl_vertex_format_descs.resize(mtlVtxFmt + 1);
789
	}
790
	_mtl_vertex_format_descs[mtlVtxFmt] = { .mtlVertexFormat = mtlVtxFmt, RD::DATA_FORMAT_MAX, vtxCap, MTLViewClass::None, MTL::PixelFormatInvalid, name };
791
}
792

793
// Check mtlVtx exists on platform, to avoid overwriting the MTL::VertexFormatInvalid entry.
794
#define addMTLVertexFormatDesc(mtlVtx) \
795
	if (MTL::VertexFormat##mtlVtx) { \
796
		addMTLVertexFormatDescImpl(MTL::VertexFormat##mtlVtx, kMTLFmtCapsVertex, "MTL::VertexFormat" #mtlVtx); \
797
	}
798

799
void PixelFormats::initMTLVertexFormatCapabilities(const MetalFeatures &p_feat) {
800
	_mtl_vertex_format_descs.resize(MTL::VertexFormatHalf + 3);
801
	// MTL::VertexFormatInvalid must come first. Use addMTLVertexFormatDescImpl to avoid guard code.
802
	addMTLVertexFormatDescImpl(MTL::VertexFormatInvalid, kMTLFmtCapsNone, "MTL::VertexFormatInvalid");
803

804
	addMTLVertexFormatDesc(UChar2Normalized);
805
	addMTLVertexFormatDesc(Char2Normalized);
806
	addMTLVertexFormatDesc(UChar2);
807
	addMTLVertexFormatDesc(Char2);
808

809
	addMTLVertexFormatDesc(UChar3Normalized);
810
	addMTLVertexFormatDesc(Char3Normalized);
811
	addMTLVertexFormatDesc(UChar3);
812
	addMTLVertexFormatDesc(Char3);
813

814
	addMTLVertexFormatDesc(UChar4Normalized);
815
	addMTLVertexFormatDesc(Char4Normalized);
816
	addMTLVertexFormatDesc(UChar4);
817
	addMTLVertexFormatDesc(Char4);
818

819
	addMTLVertexFormatDesc(UInt1010102Normalized);
820
	addMTLVertexFormatDesc(Int1010102Normalized);
821

822
	addMTLVertexFormatDesc(UShort2Normalized);
823
	addMTLVertexFormatDesc(Short2Normalized);
824
	addMTLVertexFormatDesc(UShort2);
825
	addMTLVertexFormatDesc(Short2);
826
	addMTLVertexFormatDesc(Half2);
827

828
	addMTLVertexFormatDesc(UShort3Normalized);
829
	addMTLVertexFormatDesc(Short3Normalized);
830
	addMTLVertexFormatDesc(UShort3);
831
	addMTLVertexFormatDesc(Short3);
832
	addMTLVertexFormatDesc(Half3);
833

834
	addMTLVertexFormatDesc(UShort4Normalized);
835
	addMTLVertexFormatDesc(Short4Normalized);
836
	addMTLVertexFormatDesc(UShort4);
837
	addMTLVertexFormatDesc(Short4);
838
	addMTLVertexFormatDesc(Half4);
839

840
	addMTLVertexFormatDesc(UInt);
841
	addMTLVertexFormatDesc(Int);
842
	addMTLVertexFormatDesc(Float);
843

844
	addMTLVertexFormatDesc(UInt2);
845
	addMTLVertexFormatDesc(Int2);
846
	addMTLVertexFormatDesc(Float2);
847

848
	addMTLVertexFormatDesc(UInt3);
849
	addMTLVertexFormatDesc(Int3);
850
	addMTLVertexFormatDesc(Float3);
851

852
	addMTLVertexFormatDesc(UInt4);
853
	addMTLVertexFormatDesc(Int4);
854
	addMTLVertexFormatDesc(Float4);
855

856
	addMTLVertexFormatDesc(UCharNormalized);
857
	addMTLVertexFormatDesc(CharNormalized);
858
	addMTLVertexFormatDesc(UChar);
859
	addMTLVertexFormatDesc(Char);
860

861
	addMTLVertexFormatDesc(UShortNormalized);
862
	addMTLVertexFormatDesc(ShortNormalized);
863
	addMTLVertexFormatDesc(UShort);
864
	addMTLVertexFormatDesc(Short);
865
	addMTLVertexFormatDesc(Half);
866

867
	addMTLVertexFormatDesc(UChar4Normalized_BGRA);
868

869
	if (__builtin_available(macos 14.0, ios 17.0, tvos 17.0, *)) {
870
		if (p_feat.highestFamily >= MTL::GPUFamilyApple5) {
871
			addMTLVertexFormatDesc(FloatRG11B10);
872
			addMTLVertexFormatDesc(FloatRGB9E5);
873
		}
874
	}
875
}
876

877
// Return a reference to the format capabilities, so the caller can manipulate them.
878
// Check mtlPixFmt exists on platform, to avoid overwriting the MTL::PixelFormatInvalid entry.
879
// When returning the dummy, reset it on each access because it can be written to by caller.
880
MTLFmtCaps &PixelFormats::getMTLPixelFormatCapsIf(MTL::PixelFormat mtlPixFmt, bool cond) {
881
	static MTLFmtCaps dummyFmtCaps;
882
	if (mtlPixFmt && cond) {
883
		return getMTLPixelFormatDesc(mtlPixFmt).mtlFmtCaps;
884
	} else {
885
		dummyFmtCaps = kMTLFmtCapsNone;
886
		return dummyFmtCaps;
887
	}
888
}
889

890
#define setMTLPixFmtCapsIf(cond, mtlFmt, caps) getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond) = kMTLFmtCaps##caps;
891
#define setMTLPixFmtCapsIfGPU(gpuFam, mtlFmt, caps) setMTLPixFmtCapsIf(gpuCaps.supports##gpuFam, mtlFmt, caps)
892

893
#define enableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::set(getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond), kMTLFmtCaps##caps);
894
#define enableMTLPixFmtCapsIfGPU(gpuFam, mtlFmt, caps) enableMTLPixFmtCapsIf(p_feat.highestFamily >= MTL::GPUFamily##gpuFam, mtlFmt, caps)
895

896
#define disableMTLPixFmtCapsIf(cond, mtlFmt, caps) flags::clear(getMTLPixelFormatCapsIf(MTL::PixelFormat##mtlFmt, cond), kMTLFmtCaps##caps);
897

898
// Modifies the format capability tables based on the capabilities of the specific MTLDevice.
899
void PixelFormats::modifyMTLFormatCapabilities(const MetalFeatures &p_feat) {
900
	bool noVulkanSupport = false; // Indicated supported in Metal but not Vulkan or SPIR-V.
901
	bool notMac = !p_feat.supportsMac;
902
	bool iosOnly1 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple2;
903
	bool iosOnly2 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple3;
904
	bool iosOnly6 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple7;
905
	bool iosOnly8 = notMac && p_feat.highestFamily < MTL::GPUFamilyApple9;
906

907
	setMTLPixFmtCapsIf(iosOnly2, A8Unorm, RF);
908
	setMTLPixFmtCapsIf(iosOnly1, R8Unorm_sRGB, RFCMRB);
909
	setMTLPixFmtCapsIf(iosOnly1, R8Snorm, RFWCMB);
910

911
	setMTLPixFmtCapsIf(iosOnly1, RG8Unorm_sRGB, RFCMRB);
912
	setMTLPixFmtCapsIf(iosOnly1, RG8Snorm, RFWCMB);
913

914
	enableMTLPixFmtCapsIfGPU(Apple6, R32Uint, Atomic);
915
	enableMTLPixFmtCapsIfGPU(Apple6, R32Sint, Atomic);
916

917
	setMTLPixFmtCapsIf(iosOnly8, R32Float, RWCMB);
918

919
	setMTLPixFmtCapsIf(iosOnly1, RGBA8Unorm_sRGB, RFCMRB);
920
	setMTLPixFmtCapsIf(iosOnly1, RGBA8Snorm, RFWCMB);
921
	setMTLPixFmtCapsIf(iosOnly1, BGRA8Unorm_sRGB, RFCMRB);
922

923
	setMTLPixFmtCapsIf(iosOnly2, RGB10A2Unorm, RFCMRB);
924
	setMTLPixFmtCapsIf(iosOnly2, RGB10A2Uint, RCM);
925
	setMTLPixFmtCapsIf(iosOnly2, RG11B10Float, RFCMRB);
926
	setMTLPixFmtCapsIf(iosOnly2, RGB9E5Float, RFCMRB);
927

928
	// Blending is actually supported for RGB9E5Float, but format channels cannot
929
	// be individually write-enabled during blending on macOS. Disabling blending
930
	// on macOS is the least-intrusive way to handle this in a Vulkan-friendly way.
931
	disableMTLPixFmtCapsIf(p_feat.supportsMac, RGB9E5Float, Blend);
932

933
	// RGB9E5Float cannot be used as a render target on the simulator.
934
	disableMTLPixFmtCapsIf(TARGET_OS_SIMULATOR, RGB9E5Float, ColorAtt);
935

936
	setMTLPixFmtCapsIf(iosOnly6, RG32Uint, RWC);
937
	setMTLPixFmtCapsIf(iosOnly6, RG32Sint, RWC);
938

939
	// Metal supports reading both R&G into as one 64-bit atomic operation, but Vulkan and SPIR-V do not.
940
	// Including this here so we remember to update this if support is added to Vulkan in the future.
941
	bool atomic64 = noVulkanSupport && (p_feat.highestFamily >= MTL::GPUFamilyApple9 || (p_feat.highestFamily >= MTL::GPUFamilyApple8 && p_feat.supportsMac));
942
	enableMTLPixFmtCapsIf(atomic64, RG32Uint, Atomic);
943
	enableMTLPixFmtCapsIf(atomic64, RG32Sint, Atomic);
944

945
	setMTLPixFmtCapsIf(iosOnly8, RG32Float, RWCMB);
946
	setMTLPixFmtCapsIf(iosOnly6, RG32Float, RWCB);
947

948
	setMTLPixFmtCapsIf(iosOnly8, RGBA32Float, RWCM);
949
	setMTLPixFmtCapsIf(iosOnly6, RGBA32Float, RWC);
950

951
	bool msaa32 = p_feat.supports32BitMSAA;
952
	enableMTLPixFmtCapsIf(msaa32, R32Uint, MSAA);
953
	enableMTLPixFmtCapsIf(msaa32, R32Sint, MSAA);
954
	enableMTLPixFmtCapsIf(msaa32, R32Float, Resolve);
955
	enableMTLPixFmtCapsIf(msaa32, RG32Uint, MSAA);
956
	enableMTLPixFmtCapsIf(msaa32, RG32Sint, MSAA);
957
	enableMTLPixFmtCapsIf(msaa32, RG32Float, Resolve);
958
	enableMTLPixFmtCapsIf(msaa32, RGBA32Uint, MSAA);
959
	enableMTLPixFmtCapsIf(msaa32, RGBA32Sint, MSAA);
960
	enableMTLPixFmtCapsIf(msaa32, RGBA32Float, Resolve);
961

962
	bool floatFB = p_feat.supports32BitFloatFiltering;
963
	enableMTLPixFmtCapsIf(floatFB, R32Float, Filter);
964
	enableMTLPixFmtCapsIf(floatFB, RG32Float, Filter);
965
	enableMTLPixFmtCapsIf(floatFB, RGBA32Float, Filter);
966
	enableMTLPixFmtCapsIf(floatFB, RGBA32Float, Blend); // Undocumented by confirmed through testing.
967

968
	bool noHDR_ASTC = p_feat.highestFamily < MTL::GPUFamilyApple6;
969
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_4x4_HDR, None);
970
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_5x4_HDR, None);
971
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_5x5_HDR, None);
972
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_6x5_HDR, None);
973
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_6x6_HDR, None);
974
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_8x5_HDR, None);
975
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_8x6_HDR, None);
976
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_8x8_HDR, None);
977
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_10x5_HDR, None);
978
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_10x6_HDR, None);
979
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_10x8_HDR, None);
980
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_10x10_HDR, None);
981
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_12x10_HDR, None);
982
	setMTLPixFmtCapsIf(noHDR_ASTC, ASTC_12x12_HDR, None);
983

984
	GODOT_CLANG_WARNING_PUSH_AND_IGNORE("-Wunguarded-availability")
985

986
	bool noBC = !p_feat.supportsBCTextureCompression;
987
	setMTLPixFmtCapsIf(noBC, BC1_RGBA, None);
988
	setMTLPixFmtCapsIf(noBC, BC1_RGBA_sRGB, None);
989
	setMTLPixFmtCapsIf(noBC, BC2_RGBA, None);
990
	setMTLPixFmtCapsIf(noBC, BC2_RGBA_sRGB, None);
991
	setMTLPixFmtCapsIf(noBC, BC3_RGBA, None);
992
	setMTLPixFmtCapsIf(noBC, BC3_RGBA_sRGB, None);
993
	setMTLPixFmtCapsIf(noBC, BC4_RUnorm, None);
994
	setMTLPixFmtCapsIf(noBC, BC4_RSnorm, None);
995
	setMTLPixFmtCapsIf(noBC, BC5_RGUnorm, None);
996
	setMTLPixFmtCapsIf(noBC, BC5_RGSnorm, None);
997
	setMTLPixFmtCapsIf(noBC, BC6H_RGBUfloat, None);
998
	setMTLPixFmtCapsIf(noBC, BC6H_RGBFloat, None);
999
	setMTLPixFmtCapsIf(noBC, BC7_RGBAUnorm, None);
1000
	setMTLPixFmtCapsIf(noBC, BC7_RGBAUnorm_sRGB, None);
1001

1002
	GODOT_CLANG_WARNING_POP
1003

1004
	setMTLPixFmtCapsIf(iosOnly2, BGRA10_XR, None);
1005
	setMTLPixFmtCapsIf(iosOnly2, BGRA10_XR_sRGB, None);
1006
	setMTLPixFmtCapsIf(iosOnly2, BGR10_XR, None);
1007
	setMTLPixFmtCapsIf(iosOnly2, BGR10_XR_sRGB, None);
1008

1009
	setMTLPixFmtCapsIf(iosOnly2, Depth16Unorm, DRFM);
1010
	setMTLPixFmtCapsIf(iosOnly2, Depth32Float, DRM);
1011

1012
	setMTLPixFmtCapsIf(!p_feat.supportsDepth24Stencil8, Depth24Unorm_Stencil8, None);
1013
	setMTLPixFmtCapsIf(iosOnly2, Depth32Float_Stencil8, DRM);
1014
}
1015

1016
// Populates the DataFormat lookup maps and connects Godot and Metal pixel formats to one-another.
1017
void PixelFormats::buildDFFormatMaps() {
1018
	for (DataFormatDesc &dfDesc : _data_format_descs) {
1019
		// Populate the back reference from the Metal formats to the Godot format.
1020
		// Validate the corresponding Metal formats for the platform, and clear them
1021
		// in the Godot format if not supported.
1022
		if (dfDesc.mtlPixelFormat) {
1023
			MTLFormatDesc &mtlDesc = getMTLPixelFormatDesc(dfDesc.mtlPixelFormat);
1024
			if (mtlDesc.dataFormat == RD::DATA_FORMAT_MAX) {
1025
				mtlDesc.dataFormat = dfDesc.dataFormat;
1026
			}
1027
			if (!mtlDesc.isSupported()) {
1028
				dfDesc.mtlPixelFormat = MTL::PixelFormatInvalid;
1029
			}
1030
		}
1031
		if (dfDesc.mtlPixelFormatSubstitute) {
1032
			MTLFormatDesc &mtlDesc = getMTLPixelFormatDesc(dfDesc.mtlPixelFormatSubstitute);
1033
			if (!mtlDesc.isSupported()) {
1034
				dfDesc.mtlPixelFormatSubstitute = MTL::PixelFormatInvalid;
1035
			}
1036
		}
1037
		if (dfDesc.mtlVertexFormat) {
1038
			MTLFormatDesc &mtlDesc = getMTLVertexFormatDesc(dfDesc.mtlVertexFormat);
1039
			if (mtlDesc.dataFormat == RD::DATA_FORMAT_MAX) {
1040
				mtlDesc.dataFormat = dfDesc.dataFormat;
1041
			}
1042
			if (!mtlDesc.isSupported()) {
1043
				dfDesc.mtlVertexFormat = MTL::VertexFormatInvalid;
1044
			}
1045
		}
1046
		if (dfDesc.mtlVertexFormatSubstitute) {
1047
			MTLFormatDesc &mtlDesc = getMTLVertexFormatDesc(dfDesc.mtlVertexFormatSubstitute);
1048
			if (!mtlDesc.isSupported()) {
1049
				dfDesc.mtlVertexFormatSubstitute = MTL::VertexFormatInvalid;
1050
			}
1051
		}
1052
	}
1053
}
1054

1055
Product

Resources

Company
