Google Git
Sign in
chromium/external/github.com/WebKit/webkit/refs/heads/apple-security/./Source/ThirdParty/ANGLE/changes.diff
blob: 564db80ed7038ef5b9f1ba31ece6452a0f33bb5c [file] [edit]
diff --git a/doc/ExtensionSupport.md b/doc/ExtensionSupport.md
index bb7e1359c7a48a1cd1001515eb046e5c33e922d7..1967ac6ae373966acef3963984d7e23bb1c8b8a9 100644
--- a/doc/ExtensionSupport.md
+++ b/doc/ExtensionSupport.md
@@ -258,6 +258,7 @@ using data from registry_xml.py and gl.xml.
| [GL_ANGLE_texture_external_update](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_texture_external_update.txt) | | | | | | | |
| [GL_ANGLE_texture_multisample](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_texture_multisample.txt) | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ |
| [GL_ANGLE_texture_rectangle](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_texture_rectangle.txt) | | | | | | | |
+| [GL_ANGLE_variable_rasterization_rate_metal](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_variable_rasterization_rate_metal.txt) | | | | | | | |
| [GL_ANGLE_vulkan_image](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_vulkan_image.txt) | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ | ✔ |
| [GL_ANGLE_webgl_compatibility](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_webgl_compatibility.txt) | | | | | | | |
| [GL_ANGLE_yuv_internal_format](https://chromium.googlesource.com/angle/angle/+/refs/heads/main/extensions/ANGLE_yuv_internal_format.txt) | ✔ | | ✔ | ✔ | ✔ | ✔ | ✔ |
diff --git a/include/GLES2/gl2ext_angle.h b/include/GLES2/gl2ext_angle.h
index 7952b50a5b8637eaf53d7d9611225a12c80cdcdd..c96853fafa1f23467ef659546aa4279735d0288c 100644
--- a/include/GLES2/gl2ext_angle.h
+++ b/include/GLES2/gl2ext_angle.h
@@ -736,4 +736,16 @@ GL_APICALL void GL_APIENTRY glLogicOpANGLE (GLenum);
#define GL_PROGRAM_BINARY_READY_ANGLE 0x96BE
#endif /* GL_ANGLE_program_binary_readiness_query */
+#ifndef GL_ANGLE_variable_rasterization_rate_metal
+#define GL_ANGLE_variable_rasterization_rate_metal 1
+
+#define GL_VARIABLE_RASTERIZATION_RATE_ANGLE 0x96BC
+#define GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE 0x96BD
+typedef void *GLMTLRasterizationRateMapANGLE;
+typedef void (GL_APIENTRYP PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC) (GLuint, GLMTLRasterizationRateMapANGLE);
+#ifdef GL_GLEXT_PROTOTYPES
+GL_APICALL void GL_APIENTRY glBindMetalRasterizationRateMapANGLE(GLuint framebuffer, GLMTLRasterizationRateMapANGLE map);
+#endif
+#endif /* GL_ANGLE_variable_rasterization_rate_metal */
+
#endif // INCLUDE_GLES2_GL2EXT_ANGLE_H_
diff --git a/include/platform/autogen/FeaturesMtl_autogen.h b/include/platform/autogen/FeaturesMtl_autogen.h
index 28e27213619de12f342cdced7abe175d5a82555a..ff048aa260513b2c1536f0b858803328a8e96499 100644
--- a/include/platform/autogen/FeaturesMtl_autogen.h
+++ b/include/platform/autogen/FeaturesMtl_autogen.h
@@ -83,6 +83,13 @@ struct FeaturesMtl : FeatureSetBase
&members,
};
+ FeatureInfo hasVariableRasterizationRate = {
+ "hasVariableRasterizationRate",
+ FeatureCategory::MetalFeatures,
+ "The renderer supports variable rasterization rate",
+ &members,
+ };
+
FeatureInfo allowInlineConstVertexData = {
"allowInlineConstVertexData",
FeatureCategory::MetalFeatures,
diff --git a/include/platform/mtl_features.json b/include/platform/mtl_features.json
index 8aabccca1e1edee5fae5e28ff6bf9ab6f8967f73..bf2798455b282be6ff38a5f049e0a14a0022473e 100644
--- a/include/platform/mtl_features.json
+++ b/include/platform/mtl_features.json
@@ -70,6 +70,13 @@
"The renderer supports MTL(Shared)Event"
]
},
+ {
+ "name": "has_variable_rasterization_rate",
+ "category": "Features",
+ "description": [
+ "The renderer supports variable rasterization rate"
+ ]
+ },
{
"name": "allow_inline_const_vertex_data",
"category": "Features",
diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py
index b65053ff19bf323c618a64db6c296f1b5af15bb3..f5e05c1870a2aed854e3d6bbec1730aeb0d50a85 100755
--- a/scripts/generate_entry_points.py
+++ b/scripts/generate_entry_points.py
@@ -1010,6 +1010,7 @@ FORMAT_DICT = {
"GLfloat": "%f",
"GLint": "%d",
"GLintptr": UNSIGNED_LONG_LONG_FORMAT,
+ "GLMTLRasterizationRateMapANGLE": POINTER_FORMAT,
"GLshort": "%d",
"GLsizei": "%d",
"GLsizeiptr": UNSIGNED_LONG_LONG_FORMAT,
diff --git a/scripts/gl_angle_ext.xml b/scripts/gl_angle_ext.xml
index 466387f2a92f2bda5884e6cde7910678690fe58d..835cc7d42424dfc18067140a8c9d12369a4c7f7b 100644
--- a/scripts/gl_angle_ext.xml
+++ b/scripts/gl_angle_ext.xml
@@ -9,6 +9,11 @@
Includes data used to auto-generate ANGLE classes.
</comment>
+ <!-- SECTION: GL type definitions. -->
+ <types>
+ <type>typedef void *<name>GLMTLRasterizationRateMapANGLE</name>;</type>
+ </types>
+
<!-- SECTION: GL parameter class type definitions. -->
<groups>
<group name="CreateFlagMask">
@@ -1048,6 +1053,11 @@
<param group="LogicOp"><ptype>GLenum</ptype> <name>opcode</name></param>
<alias name="glLogicOp"/>
</command>
+ <command>
+ <proto>void <name>glBindMetalRasterizationRateMapANGLE</name></proto>
+ <param><ptype>GLuint</ptype> <name>framebuffer</name></param>
+ <param><ptype>GLMTLRasterizationRateMapANGLE</ptype> <name>map</name></param>
+ </command>
</commands>
<!-- SECTION: ANGLE extension interface definitions -->
@@ -1449,6 +1459,11 @@
<extension name="GL_ANGLE_shader_binary" supported='gles2'>
<require>
<enum name="GL_SHADER_BINARY_ANGLE"/>
+ <extension name="GL_ANGLE_variable_rasterization_rate_metal" supported="gles2">
+ <require>
+ <enum name="GL_VARIABLE_RASTERIZATION_RATE_ANGLE"/>
+ <enum name="GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE"/>
+ <command name="glBindMetalRasterizationRateMapANGLE"/>
</require>
</extension>
</extensions>
@@ -1630,4 +1645,9 @@
<enums namespace="GL" start="0x0BF2" end="0x0BF2" vendor="ANGLE">
<enum value="0x0BF2" name="GL_COLOR_LOGIC_OP_ANGLE"/>
</enums>
+
+ <enums namespace="GL" start="0x96BC" end="0x96BD" vendor="ANGLE">
+ <enum value="0x96BC" name="GL_VARIABLE_RASTERIZATION_RATE_ANGLE"/>
+ <enum value="0x96BD" name="GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE"/>
+ </enums>
</registry>
diff --git a/scripts/registry_xml.py b/scripts/registry_xml.py
index 4e428eac9e30e27598fcd2c3bf9d1b0a3a7fc6d0..9454ed3a9f1d116b3b99a74d63072d196c34dd66 100644
--- a/scripts/registry_xml.py
+++ b/scripts/registry_xml.py
@@ -73,6 +73,7 @@ angle_requestable_extensions = [
"GL_ANGLE_texture_compression_dxt5",
"GL_ANGLE_texture_external_update",
"GL_ANGLE_texture_multisample",
+ "GL_ANGLE_variable_rasterization_rate_metal",
"GL_ANGLE_vulkan_image",
"GL_ANGLE_yuv_internal_format",
"GL_CHROMIUM_color_buffer_float_rgb",
diff --git a/src/common/entry_points_enum_autogen.cpp b/src/common/entry_points_enum_autogen.cpp
index 8266c3561d4af4f06a2dab192500026802ab5e9c..c8391669fd518ff06082a83ad68429513e873757 100644
--- a/src/common/entry_points_enum_autogen.cpp
+++ b/src/common/entry_points_enum_autogen.cpp
@@ -540,6 +540,8 @@ const char *GetEntryPointName(EntryPoint ep)
return "glBindImageTexture";
case EntryPoint::GLBindImageTextures:
return "glBindImageTextures";
+ case EntryPoint::GLBindMetalRasterizationRateMapANGLE:
+ return "glBindMetalRasterizationRateMapANGLE";
case EntryPoint::GLBindProgramPipeline:
return "glBindProgramPipeline";
case EntryPoint::GLBindProgramPipelineEXT:
diff --git a/src/common/entry_points_enum_autogen.h b/src/common/entry_points_enum_autogen.h
index e45604ba4ee4eb8ebffbd506dc34c71f635f3618..441a69f7325f69d88e708647c2b5dfacdceede5f 100644
--- a/src/common/entry_points_enum_autogen.h
+++ b/src/common/entry_points_enum_autogen.h
@@ -276,6 +276,7 @@ enum class EntryPoint
GLBindFramebufferOES,
GLBindImageTexture,
GLBindImageTextures,
+ GLBindMetalRasterizationRateMapANGLE,
GLBindProgramPipeline,
GLBindProgramPipelineEXT,
GLBindRenderbuffer,
diff --git a/src/common/frame_capture_utils_autogen.cpp b/src/common/frame_capture_utils_autogen.cpp
index f356982285bc9bed6469571d6c2f0ef9ea7cc940..9f601fc824eae7e78da8e8f9b3fe6576b0d7e76c 100644
--- a/src/common/frame_capture_utils_autogen.cpp
+++ b/src/common/frame_capture_utils_autogen.cpp
@@ -222,6 +222,10 @@ void WriteParamCaptureReplay(std::ostream &os, const CallCapture &call, const Pa
WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(os, call,
param.value.GLDEBUGPROCKHRVal);
break;
+ case ParamType::TGLMTLRasterizationRateMapANGLE:
+ WriteParamValueReplay<ParamType::TGLMTLRasterizationRateMapANGLE>(
+ os, call, param.value.GLMTLRasterizationRateMapANGLEVal);
+ break;
case ParamType::TGLbitfield:
WriteParamValueReplay<ParamType::TGLbitfield>(os, call, param.value.GLbitfieldVal);
break;
@@ -768,6 +772,8 @@ const char *ParamTypeToString(ParamType paramType)
return "GLDEBUGPROC";
case ParamType::TGLDEBUGPROCKHR:
return "GLDEBUGPROCKHR";
+ case ParamType::TGLMTLRasterizationRateMapANGLE:
+ return "GLMTLRasterizationRateMapANGLE";
case ParamType::TGLbitfield:
return "GLbitfield";
case ParamType::TGLboolean:
diff --git a/src/common/frame_capture_utils_autogen.h b/src/common/frame_capture_utils_autogen.h
index e68affb0e0773ce2c83439ca9c188066cc225d34..88a18830e8037a5cf2c23d60b94f2910c6edf136 100644
--- a/src/common/frame_capture_utils_autogen.h
+++ b/src/common/frame_capture_utils_autogen.h
@@ -74,6 +74,7 @@ enum class ParamType
TFramebufferIDPointer,
TGLDEBUGPROC,
TGLDEBUGPROCKHR,
+ TGLMTLRasterizationRateMapANGLE,
TGLbitfield,
TGLboolean,
TGLbooleanConstPointer,
@@ -191,7 +192,7 @@ enum class ParamType
TvoidPointerPointer,
};
-constexpr uint32_t kParamTypeCount = 172;
+constexpr uint32_t kParamTypeCount = 173;
union ParamValue
{
@@ -252,6 +253,7 @@ union ParamValue
gl::FramebufferID *FramebufferIDPointerVal;
GLDEBUGPROC GLDEBUGPROCVal;
GLDEBUGPROCKHR GLDEBUGPROCKHRVal;
+ GLMTLRasterizationRateMapANGLE GLMTLRasterizationRateMapANGLEVal;
GLbitfield GLbitfieldVal;
GLboolean GLbooleanVal;
const GLboolean *GLbooleanConstPointerVal;
@@ -745,6 +747,14 @@ inline GLDEBUGPROCKHR GetParamVal<ParamType::TGLDEBUGPROCKHR, GLDEBUGPROCKHR>(
return value.GLDEBUGPROCKHRVal;
}
+template <>
+inline GLMTLRasterizationRateMapANGLE
+GetParamVal<ParamType::TGLMTLRasterizationRateMapANGLE, GLMTLRasterizationRateMapANGLE>(
+ const ParamValue &value)
+{
+ return value.GLMTLRasterizationRateMapANGLEVal;
+}
+
template <>
inline GLbitfield GetParamVal<ParamType::TGLbitfield, GLbitfield>(const ParamValue &value)
{
@@ -1629,6 +1639,8 @@ T AccessParamValue(ParamType paramType, const ParamValue &value)
return GetParamVal<ParamType::TGLDEBUGPROC, T>(value);
case ParamType::TGLDEBUGPROCKHR:
return GetParamVal<ParamType::TGLDEBUGPROCKHR, T>(value);
+ case ParamType::TGLMTLRasterizationRateMapANGLE:
+ return GetParamVal<ParamType::TGLMTLRasterizationRateMapANGLE, T>(value);
case ParamType::TGLbitfield:
return GetParamVal<ParamType::TGLbitfield, T>(value);
case ParamType::TGLboolean:
@@ -2227,6 +2239,14 @@ inline void SetParamVal<ParamType::TGLDEBUGPROCKHR>(GLDEBUGPROCKHR valueIn, Para
valueOut->GLDEBUGPROCKHRVal = valueIn;
}
+template <>
+inline void SetParamVal<ParamType::TGLMTLRasterizationRateMapANGLE>(
+ GLMTLRasterizationRateMapANGLE valueIn,
+ ParamValue *valueOut)
+{
+ valueOut->GLMTLRasterizationRateMapANGLEVal = valueIn;
+}
+
template <>
inline void SetParamVal<ParamType::TGLbitfield>(GLbitfield valueIn, ParamValue *valueOut)
{
@@ -3149,6 +3169,9 @@ void InitParamValue(ParamType paramType, T valueIn, ParamValue *valueOut)
case ParamType::TGLDEBUGPROCKHR:
SetParamVal<ParamType::TGLDEBUGPROCKHR>(valueIn, valueOut);
break;
+ case ParamType::TGLMTLRasterizationRateMapANGLE:
+ SetParamVal<ParamType::TGLMTLRasterizationRateMapANGLE>(valueIn, valueOut);
+ break;
case ParamType::TGLbitfield:
SetParamVal<ParamType::TGLbitfield>(valueIn, valueOut);
break;
diff --git a/src/common/gl_enum_utils_autogen.cpp b/src/common/gl_enum_utils_autogen.cpp
index 40f19699fbf375c7531b7da2e020dde7003f7ace..af39593acdc3dcbd39043ad1bfcbcbceb0e487b6 100644
--- a/src/common/gl_enum_utils_autogen.cpp
+++ b/src/common/gl_enum_utils_autogen.cpp
@@ -2814,6 +2814,10 @@ const char *GLenumToString(GLESEnum enumGroup, unsigned int value)
return "GL_RGBX8_ANGLE";
case 0x96BB:
return "GL_SHADER_BINARY_ANGLE";
+ case 0x96BC:
+ return "GL_VARIABLE_RASTERIZATION_RATE_ANGLE";
+ case 0x96BD:
+ return "GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE";
case 0x96BE:
return "GL_PROGRAM_BINARY_READY_ANGLE";
case 0x96E0:
@@ -22190,6 +22194,7 @@ static StringEnumEntry g_stringEnumTable[] = {
{"GL_MESH_SUBROUTINE_UNIFORM_NV", 0x957E},
{"GL_MESH_VERTICES_OUT_NV", 0x9579},
{"GL_MESH_WORK_GROUP_SIZE_NV", 0x953E},
+ {"GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE", 0x96BD},
{"GL_MIN", 0x8007},
{"GL_MINMAX", 0x802E},
{"GL_MINMAX_EXT", 0x802E},
@@ -24841,6 +24846,7 @@ static StringEnumEntry g_stringEnumTable[] = {
{"GL_VARIABLE_E_NV", 0x8527},
{"GL_VARIABLE_F_NV", 0x8528},
{"GL_VARIABLE_G_NV", 0x8529},
+ {"GL_VARIABLE_RASTERIZATION_RATE_ANGLE", 0x96BC},
{"GL_VARIANT_ARRAY_EXT", 0x87E8},
{"GL_VARIANT_ARRAY_POINTER_EXT", 0x87E9},
{"GL_VARIANT_ARRAY_STRIDE_EXT", 0x87E6},
diff --git a/src/common/utilities.cpp b/src/common/utilities.cpp
index 34826b47554d0d89e8b9619d46828177b2c1b873..2e03a110de26a7cb888d8e9a5997deaf3745c12c 100644
--- a/src/common/utilities.cpp
+++ b/src/common/utilities.cpp
@@ -6,6 +6,12 @@
// utilities.cpp: Conversion functions and other utility routines.
+// Older clang versions have a false positive on this warning here.
+// TODO(dino): Is this still necessary?
+#if defined(__clang__)
+# pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
#include "common/utilities.h"
#include "GLES3/gl3.h"
#include "common/mathutil.h"
diff --git a/src/compiler/fuzz/translator_fuzzer.cpp b/src/compiler/fuzz/translator_fuzzer.cpp
index f55eddef30336ffe712d1a88bb8894e6e347734f..203cba54333499fe4a794ac790143b82c880e135 100644
--- a/src/compiler/fuzz/translator_fuzzer.cpp
+++ b/src/compiler/fuzz/translator_fuzzer.cpp
@@ -139,6 +139,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
static_cast<uint32_t>(ShFragmentSynchronizationType::InvalidEnum));
std::vector<uint32_t> validOutputs;
+#ifndef ANGLE_TRANSLATOR_FUZZER_METAL_ONLY
validOutputs.push_back(SH_ESSL_OUTPUT);
validOutputs.push_back(SH_GLSL_COMPATIBILITY_OUTPUT);
validOutputs.push_back(SH_GLSL_130_OUTPUT);
@@ -155,6 +156,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
validOutputs.push_back(SH_HLSL_3_0_OUTPUT);
validOutputs.push_back(SH_HLSL_4_1_OUTPUT);
validOutputs.push_back(SH_HLSL_4_0_FL9_3_OUTPUT);
+#endif
+#ifdef ANGLE_ENABLE_METAL
+ validOutputs.push_back(SH_MSL_METAL_OUTPUT);
+#endif
bool found = false;
for (auto valid : validOutputs)
{
@@ -186,6 +191,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
if (translator == nullptr)
{
+ sh::Finalize();
return 0;
}
@@ -219,6 +225,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
if (!translator->Init(resources))
{
+ sh::Finalize();
return 0;
}
@@ -231,5 +238,6 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
const char *shaderStrings[] = {reinterpret_cast<const char *>(data)};
translator->compile(shaderStrings, 1, options);
+ sh::Finalize();
return 0;
}
diff --git a/src/compiler/preprocessor/preprocessor_tab_autogen.cpp b/src/compiler/preprocessor/preprocessor_tab_autogen.cpp
index a7607c9e529ce7a57bdc6c3c82134b144eb67130..c9ec1adec020589bd4fcfe226721042a8f2c6cf5 100644
--- a/src/compiler/preprocessor/preprocessor_tab_autogen.cpp
+++ b/src/compiler/preprocessor/preprocessor_tab_autogen.cpp
@@ -1,5 +1,8 @@
/* A Bison parser, made by GNU Bison 3.8.2. */
+/* Apple Note: For the avoidance of doubt, Apple elects to distribute this file under the terms of
+ * the BSD license. */
+
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
diff --git a/src/compiler/translator/glslang_tab_autogen.cpp b/src/compiler/translator/glslang_tab_autogen.cpp
index acde76f0189b7dc474f54c3df7e0514a8529c162..2e95ee0da27b547c5258c8d88c8ef8d461f3943e 100644
--- a/src/compiler/translator/glslang_tab_autogen.cpp
+++ b/src/compiler/translator/glslang_tab_autogen.cpp
@@ -1,5 +1,8 @@
/* A Bison parser, made by GNU Bison 3.8.2. */
+/* Apple Note: For the avoidance of doubt, Apple elects to distribute this file under the terms of
+ * the BSD license. */
+
/* Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
diff --git a/src/compiler/translator/glslang_tab_autogen.h b/src/compiler/translator/glslang_tab_autogen.h
index d5a48edd40f382359db76acf1a1ce75b6a6dc6d5..907c62e0bb659292b3912707904981863429478a 100644
--- a/src/compiler/translator/glslang_tab_autogen.h
+++ b/src/compiler/translator/glslang_tab_autogen.h
@@ -1,5 +1,8 @@
/* A Bison parser, made by GNU Bison 3.8.2. */
+/* Apple Note: For the avoidance of doubt, Apple elects to distribute this file under the terms of
+ * the BSD license. */
+
/* Bison interface for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
diff --git a/src/libANGLE/Context.cpp b/src/libANGLE/Context.cpp
index 8d05364ff463c426453332264fb0836611865c23..da8ae7bbc72c5b818917048f4058bb3c96698090 100644
--- a/src/libANGLE/Context.cpp
+++ b/src/libANGLE/Context.cpp
@@ -10018,6 +10018,14 @@ void Context::clearTexSubImage(TextureID texturePacked,
static_cast<const uint8_t *>(data)));
}
+void Context::bindMetalRasterizationRateMap(GLuint renderbufferHandle, GLMTLRasterizationRateMapANGLE map)
+{
+ Renderbuffer *renderbuffer = getRenderbuffer({renderbufferHandle});
+ rx::RenderbufferImpl *renderbufferImpl = renderbuffer ? renderbuffer->getImplementation() : nullptr;
+ ANGLE_CONTEXT_TRY(mImplementation->bindMetalRasterizationRateMap(this, renderbufferImpl, map));
+ getMutablePrivateState()->setVariableRasterizationRateMap(map);
+}
+
// ErrorSet implementation.
ErrorSet::ErrorSet(Debug *debug,
const angle::FrontendFeatures &frontendFeatures,
diff --git a/src/libANGLE/Context_gles_ext_autogen.h b/src/libANGLE/Context_gles_ext_autogen.h
index 364ea21366fc5a76de2b3e596b7039370e911bde..06916ba9627e4913cc54267792739d560fecdfbc 100644
--- a/src/libANGLE/Context_gles_ext_autogen.h
+++ b/src/libANGLE/Context_gles_ext_autogen.h
@@ -631,6 +631,8 @@
void invalidateTexture(TextureType targetPacked); \
/* GL_ANGLE_texture_multisample */ \
/* GL_ANGLE_texture_rectangle */ \
+ /* GL_ANGLE_variable_rasterization_rate_metal */ \
+ void bindMetalRasterizationRateMap(GLuint renderbuffer, GLMTLRasterizationRateMapANGLE map); \
/* GL_ANGLE_vulkan_image */ \
void acquireTextures(GLuint numTextures, const TextureID *texturesPacked, \
const GLenum *layouts); \
diff --git a/src/libANGLE/Framebuffer.cpp b/src/libANGLE/Framebuffer.cpp
index a7a1cc00168789858d23f9799317c293bda6b077..833aa8c98ad0363b94fe179451664e214a4091ef 100644
--- a/src/libANGLE/Framebuffer.cpp
+++ b/src/libANGLE/Framebuffer.cpp
@@ -1680,6 +1680,8 @@ angle::Result Framebuffer::discard(const Context *context, size_t count, const G
// Back-ends might make the contents of the FBO undefined. In WebGL 2.0, invalidate operations
// can be no-ops, so we should probably do that to ensure consistency.
// TODO(jmadill): WebGL behaviour, and robust resource init behaviour without WebGL.
+ if (context->isRobustResourceInitEnabled())
+ markDrawAttachmentsNeedInit(count, attachments);
return mImpl->discard(context, count, attachments);
}
@@ -1691,6 +1693,8 @@ angle::Result Framebuffer::invalidate(const Context *context,
// Back-ends might make the contents of the FBO undefined. In WebGL 2.0, invalidate operations
// can be no-ops, so we should probably do that to ensure consistency.
// TODO(jmadill): WebGL behaviour, and robust resource init behaviour without WebGL.
+ if (context->isRobustResourceInitEnabled())
+ markDrawAttachmentsNeedInit(count, attachments);
return mImpl->invalidate(context, count, attachments);
}
@@ -2839,4 +2843,56 @@ angle::Result Framebuffer::syncAttachmentState(const Context *context,
return angle::Result::Continue;
}
+
+void Framebuffer::markDrawAttachmentsNeedInit(size_t count, const GLenum *attachments)
+{
+ bool stateChanged = false;
+ for (size_t attachmentIdx = 0; attachmentIdx < count; attachmentIdx++)
+ {
+ GLenum attachmentBindPoint = attachments[attachmentIdx];
+ switch (attachmentBindPoint)
+ {
+ case GL_DEPTH_ATTACHMENT:
+ case GL_DEPTH_EXT:
+ if (mState.mDepthAttachment.isAttached())
+ {
+ mDirtyBits.set(DIRTY_BIT_DEPTH_ATTACHMENT);
+ mState.mResourceNeedsInit.set(DIRTY_BIT_DEPTH_ATTACHMENT);
+ mState.mDepthAttachment.setInitState(InitState::MayNeedInit);
+ stateChanged = true;
+ }
+ break;
+ case GL_STENCIL_ATTACHMENT:
+ case GL_STENCIL_EXT:
+ if (mState.mStencilAttachment.isAttached())
+ {
+ mDirtyBits.set(DIRTY_BIT_STENCIL_ATTACHMENT);
+ mState.mResourceNeedsInit.set(DIRTY_BIT_STENCIL_ATTACHMENT);
+ mState.mStencilAttachment.setInitState(InitState::MayNeedInit);
+ stateChanged = true;
+ }
+ break;
+ default:
+ if (attachmentBindPoint == GL_COLOR_EXT)
+ {
+ attachmentBindPoint = GL_COLOR_ATTACHMENT0;
+ }
+ int colorDirtyBit = attachmentBindPoint - GL_COLOR_ATTACHMENT0;
+ if (colorDirtyBit >= 0 && colorDirtyBit < IMPLEMENTATION_MAX_DRAW_BUFFERS &&
+ mState.mColorAttachments[colorDirtyBit].isAttached())
+ {
+ mDirtyBits.set(colorDirtyBit);
+ mState.mResourceNeedsInit.set(colorDirtyBit);
+ mState.mColorAttachments[colorDirtyBit].setInitState(InitState::MayNeedInit);
+ stateChanged = true;
+ }
+ break;
+ }
+ }
+
+ if (stateChanged)
+ {
+ onStateChange(angle::SubjectMessage::DirtyBitsFlagged);
+ }
+}
} // namespace gl
diff --git a/src/libANGLE/Framebuffer.h b/src/libANGLE/Framebuffer.h
index f690cf4932b165ff099b1ea1c80002023f559dd5..41cc590b8a636af5508fd3b4735486eec29a1fa7 100644
--- a/src/libANGLE/Framebuffer.h
+++ b/src/libANGLE/Framebuffer.h
@@ -545,6 +545,8 @@ class Framebuffer final : public angle::ObserverInterface,
Command command,
const FramebufferAttachment *attachment) const;
+ void markDrawAttachmentsNeedInit(size_t count, const GLenum *attachments);
+
FramebufferState mState;
rx::FramebufferImpl *mImpl;
diff --git a/src/libANGLE/State.cpp b/src/libANGLE/State.cpp
index f280a5b1630e36f9d85fa5fc75b38f6aba8dd37b..1c65fd4628421efe5e317b0036c9c34a3b5a1fa9 100644
--- a/src/libANGLE/State.cpp
+++ b/src/libANGLE/State.cpp
@@ -6,6 +6,9 @@
// State.cpp: Implements the State class, encapsulating raw GL state.
+// Older clang versions have a false positive on this warning here.
+#pragma clang diagnostic ignored "-Wglobal-constructors"
+
#include "libANGLE/State.h"
#include <string.h>
@@ -369,6 +372,8 @@ PrivateState::PrivateState(const EGLenum clientType,
mLogicOp(LogicalOperation::Copy),
mPatchVertices(3),
mPixelLocalStorageActivePlanes(0),
+ mVariableRasterizationRateEnabled(false),
+ mVariableRasterizationRateMap(nullptr),
mNoSimultaneousConstantColorAndAlphaBlendFunc(false),
mSetBlendIndexedInvoked(false),
mSetBlendFactorsIndexedInvoked(false),
@@ -1247,6 +1252,26 @@ void PrivateState::setLogicOp(LogicalOperation opcode)
}
}
+void PrivateState::setVariableRasterizationRateEnabled(bool enabled)
+{
+ if (mVariableRasterizationRateEnabled != enabled)
+ {
+ mVariableRasterizationRateEnabled = enabled;
+ mDirtyBits.set(state::DIRTY_BIT_EXTENDED);
+ mExtendedDirtyBits.set(state::EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE);
+ }
+}
+
+void PrivateState::setVariableRasterizationRateMap(GLMTLRasterizationRateMapANGLE map)
+{
+ if (mVariableRasterizationRateMap != map)
+ {
+ mVariableRasterizationRateMap = map;
+ mDirtyBits.set(state::DIRTY_BIT_EXTENDED);
+ mExtendedDirtyBits.set(state::EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE);
+ }
+}
+
void PrivateState::setVertexAttribf(GLuint index, const GLfloat values[4])
{
ASSERT(static_cast<size_t>(index) < mVertexAttribCurrentValues.size());
@@ -1379,6 +1404,9 @@ void PrivateState::setEnableFeature(GLenum feature, bool enabled)
case GL_FETCH_PER_SAMPLE_ARM:
mFetchPerSample = enabled;
return;
+ case GL_VARIABLE_RASTERIZATION_RATE_ANGLE:
+ setVariableRasterizationRateEnabled(enabled);
+ return;
default:
break;
}
@@ -1545,6 +1573,8 @@ bool PrivateState::getEnableFeature(GLenum feature) const
return mShadingRatePreserveAspectRatio;
case GL_FETCH_PER_SAMPLE_ARM:
return mFetchPerSample;
+ case GL_VARIABLE_RASTERIZATION_RATE_ANGLE:
+ return mVariableRasterizationRateEnabled;
}
ASSERT(mClientVersion.major == 1);
@@ -3426,6 +3456,9 @@ void State::getPointerv(const Context *context, GLenum pname, void **params) con
context->vertexArrayIndex(ParamToVertexArrayType(pname))),
GL_VERTEX_ATTRIB_ARRAY_POINTER, params);
return;
+ case GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE:
+ *params = privateState().getVariableRasterizationRateMap();
+ break;
default:
UNREACHABLE();
break;
diff --git a/src/libANGLE/State.h b/src/libANGLE/State.h
index a1ac0dd3075d43422336e74317c93c0106cb448f..f7bc28d978000abedfe9f71058dcc8d122d16106 100644
--- a/src/libANGLE/State.h
+++ b/src/libANGLE/State.h
@@ -180,6 +180,7 @@ enum ExtendedDirtyBitType
EXTENDED_DIRTY_BIT_LOGIC_OP_ENABLED, // ANGLE_logic_op
EXTENDED_DIRTY_BIT_LOGIC_OP, // ANGLE_logic_op
EXTENDED_DIRTY_BIT_BLEND_ADVANCED_COHERENT, // KHR_blend_operation_advanced_coherent
+ EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE, // ANGLE_variable_rasterization_rate_metal
EXTENDED_DIRTY_BIT_INVALID,
EXTENDED_DIRTY_BIT_MAX = EXTENDED_DIRTY_BIT_INVALID,
@@ -475,6 +476,15 @@ class PrivateState : angle::NonCopyable
void setPixelLocalStorageActivePlanes(GLsizei n);
GLsizei getPixelLocalStorageActivePlanes() const { return mPixelLocalStorageActivePlanes; }
+ // GL_ANGLE_variable_rasterization_rate_metal
+ void setVariableRasterizationRateEnabled(bool enabled);
+ bool isVariableRasterizationRateEnabled() const { return mVariableRasterizationRateEnabled; }
+ void setVariableRasterizationRateMap(GLMTLRasterizationRateMapANGLE map);
+ GLMTLRasterizationRateMapANGLE getVariableRasterizationRateMap() const
+ {
+ return mVariableRasterizationRateMap;
+ }
+
// Line width state setter
void setLineWidth(GLfloat width);
float getLineWidth() const { return mLineWidth; }
@@ -702,6 +712,10 @@ class PrivateState : angle::NonCopyable
// GL_ANGLE_shader_pixel_local_storage
GLsizei mPixelLocalStorageActivePlanes;
+ // GL_ANGLE_variable_rasterization_rate_metal
+ bool mVariableRasterizationRateEnabled;
+ GLMTLRasterizationRateMapANGLE mVariableRasterizationRateMap;
+
// GLES1 emulation: state specific to GLES1
GLES1State mGLES1State;
diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.cpp b/src/libANGLE/capture/capture_gles_ext_autogen.cpp
index 8fd39cbd8e1e15cd8b7142bf31b64719d0079c7e..de5bee2e6af92a11b68a9a60ac84f5bcf3f278a8 100644
--- a/src/libANGLE/capture/capture_gles_ext_autogen.cpp
+++ b/src/libANGLE/capture/capture_gles_ext_autogen.cpp
@@ -5164,6 +5164,18 @@ CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
return CallCapture(angle::EntryPoint::GLGetTranslatedShaderSourceANGLE, std::move(paramBuffer));
}
+CallCapture CaptureBindMetalRasterizationRateMapANGLE(const State &glState,
+ bool isCallValid,
+ GLMTLRasterizationRateMapANGLE map)
+{
+ ParamBuffer paramBuffer;
+
+ paramBuffer.addValueParam("map", ParamType::TGLMTLRasterizationRateMapANGLE, map);
+
+ return CallCapture(angle::EntryPoint::GLBindMetalRasterizationRateMapANGLE,
+ std::move(paramBuffer));
+}
+
CallCapture CaptureAcquireTexturesANGLE(const State &glState,
bool isCallValid,
GLuint numTextures,
diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.h b/src/libANGLE/capture/capture_gles_ext_autogen.h
index e06b394709e2e712312c3596cd51f1465f705c07..14a484d89f89e79a03d18b463082ce069fa39cdc 100644
--- a/src/libANGLE/capture/capture_gles_ext_autogen.h
+++ b/src/libANGLE/capture/capture_gles_ext_autogen.h
@@ -993,6 +993,11 @@ angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState,
GLsizei *length,
GLchar *source);
+// GL_ANGLE_variable_rasterization_rate_metal
+angle::CallCapture CaptureBindMetalRasterizationRateMapANGLE(const State &glState,
+ bool isCallValid,
+ GLMTLRasterizationRateMapANGLE map);
+
// GL_ANGLE_vulkan_image
angle::CallCapture CaptureAcquireTexturesANGLE(const State &glState,
bool isCallValid,
diff --git a/src/libANGLE/features.h b/src/libANGLE/features.h
index a6fe076c72d043dba3fc347bf020ebf8ec895f51..add46e99c91d19bbd790d2de0d8768b8953d633e 100644
--- a/src/libANGLE/features.h
+++ b/src/libANGLE/features.h
@@ -44,4 +44,11 @@
# define ANGLE_PROGRAM_LINK_VALIDATE_UNIFORM_PRECISION 1
#endif
+// Lose context on Metal command queue error
+// ENABLED check Metal command buffer status on completion for error and lose context on error.
+// DISABLED Metal backed contexts are never lost.
+#if !defined(ANGLE_METAL_LOSE_CONTEXT_ON_ERROR)
+# define ANGLE_METAL_LOSE_CONTEXT_ON_ERROR ANGLE_ENABLED
+#endif
+
#endif // LIBANGLE_FEATURES_H_
diff --git a/src/libANGLE/formatutils.cpp b/src/libANGLE/formatutils.cpp
index 8068c7dd1fbc62d2177b771b583f24a3d81084b3..9de76b5ee42b6026cec4662daff6e35445477735 100644
--- a/src/libANGLE/formatutils.cpp
+++ b/src/libANGLE/formatutils.cpp
@@ -592,7 +592,8 @@ static GLenum EquivalentBlitInternalFormat(GLenum internalformat)
// sized, even if there is a swizzle (for example, blitting from a
// multisampled RGBA8 renderbuffer to a BGRA8 texture). This could
// be expanded and/or autogenerated if that is found necessary.
- if (internalformat == GL_BGRA8_EXT || internalformat == GL_BGRA8_SRGB_ANGLEX)
+ if (internalformat == GL_SRGB8_ALPHA8_EXT || internalformat == GL_BGRA8_EXT ||
+ internalformat == GL_BGRA8_SRGB_ANGLEX)
{
return GL_RGBA8;
}
diff --git a/src/libANGLE/gles_extensions_autogen.cpp b/src/libANGLE/gles_extensions_autogen.cpp
index 08d6416ee0ff64ae1db4bd0b61df3fe48856df20..56138198776d6dac1139f69a05c161629a11b80b 100644
--- a/src/libANGLE/gles_extensions_autogen.cpp
+++ b/src/libANGLE/gles_extensions_autogen.cpp
@@ -270,6 +270,7 @@ const ExtensionInfoMap &GetExtensionInfoMap()
map["GL_ANGLE_texture_external_update"] = enableableExtension(&Extensions::textureExternalUpdateANGLE);
map["GL_ANGLE_texture_multisample"] = enableableExtension(&Extensions::textureMultisampleANGLE);
map["GL_ANGLE_texture_rectangle"] = enableableDisablableExtension(&Extensions::textureRectangleANGLE);
+ map["GL_ANGLE_variable_rasterization_rate_metal"] = enableableExtension(&Extensions::variableRasterizationRateMetalANGLE);
map["GL_ANGLE_vulkan_image"] = enableableExtension(&Extensions::vulkanImageANGLE);
map["GL_ANGLE_webgl_compatibility"] = esOnlyExtension(&Extensions::webglCompatibilityANGLE);
map["GL_ANGLE_yuv_internal_format"] = enableableExtension(&Extensions::yuvInternalFormatANGLE);
diff --git a/src/libANGLE/gles_extensions_autogen.h b/src/libANGLE/gles_extensions_autogen.h
index d3f6ae8aefceec8ff7db974ad0dbdb817bb8d8ed..b4e6567fbcd47295c30ee84a1696667a5ee05af7 100644
--- a/src/libANGLE/gles_extensions_autogen.h
+++ b/src/libANGLE/gles_extensions_autogen.h
@@ -770,6 +770,9 @@ struct Extensions
// GL_ANGLE_texture_rectangle
bool textureRectangleANGLE = false;
+ // GL_ANGLE_variable_rasterization_rate_metal
+ bool variableRasterizationRateMetalANGLE = false;
+
// GL_ANGLE_vulkan_image
bool vulkanImageANGLE = false;
diff --git a/src/libANGLE/renderer/ContextImpl.cpp b/src/libANGLE/renderer/ContextImpl.cpp
index dea6f2f500ee89410847e205d2b86eae4a5a2f1f..23d5d18b7c00186a7bf5a6a657c87f3494f3038a 100644
--- a/src/libANGLE/renderer/ContextImpl.cpp
+++ b/src/libANGLE/renderer/ContextImpl.cpp
@@ -124,4 +124,13 @@ angle::Result ContextImpl::drawPixelLocalStorageEXTDisable(gl::Context *,
UNREACHABLE();
return angle::Result::Stop;
}
+
+angle::Result ContextImpl::bindMetalRasterizationRateMap(gl::Context *,
+ RenderbufferImpl *renderbuffer,
+ GLMTLRasterizationRateMapANGLE map)
+{
+ UNREACHABLE();
+ return angle::Result::Stop;
+}
+
} // namespace rx
diff --git a/src/libANGLE/renderer/ContextImpl.h b/src/libANGLE/renderer/ContextImpl.h
index ec84d044755d61e14353fb32735a7d13a60d19dd..c3f918bb49ca3d10bcd767079e8c6f7e77dbc042 100644
--- a/src/libANGLE/renderer/ContextImpl.h
+++ b/src/libANGLE/renderer/ContextImpl.h
@@ -298,6 +298,11 @@ class ContextImpl : public GLImplFactory
const gl::PixelLocalStoragePlane[],
const GLenum storeops[]);
+ // GL_ANGLE_variable_rasterization_rate_metal
+ virtual angle::Result bindMetalRasterizationRateMap(gl::Context *,
+ RenderbufferImpl *renderbuffer,
+ GLMTLRasterizationRateMapANGLE map);
+
protected:
const gl::State &mState;
gl::MemoryProgramCache *mMemoryProgramCache;
diff --git a/src/libANGLE/renderer/gl/FunctionsGL.cpp b/src/libANGLE/renderer/gl/FunctionsGL.cpp
index 9d8c7a4f4be3f1afd54163e2aacb12b9a832664e..9c3661be5fb3f51c15404bad23a1942a9eb2a6a4 100644
--- a/src/libANGLE/renderer/gl/FunctionsGL.cpp
+++ b/src/libANGLE/renderer/gl/FunctionsGL.cpp
@@ -53,7 +53,8 @@ static std::vector<std::string> GetIndexedExtensions(PFNGLGETINTEGERVPROC getInt
for (GLint i = 0; i < numExtensions; i++)
{
- result.push_back(reinterpret_cast<const char *>(getStringIFunction(GL_EXTENSIONS, i)));
+ if (const char* extensionString = reinterpret_cast<const char *>(getStringIFunction(GL_EXTENSIONS, i)))
+ result.push_back(extensionString);
}
return result;
diff --git a/src/libANGLE/renderer/gl/StateManagerGL.cpp b/src/libANGLE/renderer/gl/StateManagerGL.cpp
index af3dbcec1bc5b30dde37e666446ca9cec2301239..fd82127caebb53e95be778518dbc748be917f6bc 100644
--- a/src/libANGLE/renderer/gl/StateManagerGL.cpp
+++ b/src/libANGLE/renderer/gl/StateManagerGL.cpp
@@ -2492,6 +2492,8 @@ angle::Result StateManagerGL::syncState(const gl::Context *context,
break;
case gl::state::EXTENDED_DIRTY_BIT_BLEND_ADVANCED_COHERENT:
setBlendAdvancedCoherent(state.isBlendAdvancedCoherentEnabled());
+ case gl::state::EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE:
+ // Unimplemented extensions.
break;
default:
UNREACHABLE();
diff --git a/src/libANGLE/renderer/metal/BufferMtl.mm b/src/libANGLE/renderer/metal/BufferMtl.mm
index 398e6d3e3809da8b0d7ed81458a8f5b752433b16..4689f7484593f8654680d2650d8903324771ecb3 100644
--- a/src/libANGLE/renderer/metal/BufferMtl.mm
+++ b/src/libANGLE/renderer/metal/BufferMtl.mm
@@ -390,7 +390,7 @@ ConversionBufferMtl *BufferMtl::getUniformConversionBuffer(ContextMtl *context,
{
if (buffer.offset.second <= offset.second &&
(offset.second - buffer.offset.second) % buffer.uniformBufferBlockSize == 0)
- return &buffer;
+ return static_cast<ConversionBufferMtl *>(&buffer);
}
}
diff --git a/src/libANGLE/renderer/metal/ContextMtl.h b/src/libANGLE/renderer/metal/ContextMtl.h
index acdd008c5424d3ab67df0ffe384bb459143348a1..7283095e00b5c260f276c497de5d53d1de27d2b9 100644
--- a/src/libANGLE/renderer/metal/ContextMtl.h
+++ b/src/libANGLE/renderer/metal/ContextMtl.h
@@ -272,6 +272,10 @@ class ContextMtl : public ContextImpl, public mtl::Context
angle::Result memoryBarrier(const gl::Context *context, GLbitfield barriers) override;
angle::Result memoryBarrierByRegion(const gl::Context *context, GLbitfield barriers) override;
+ angle::Result bindMetalRasterizationRateMap(gl::Context *context,
+ RenderbufferImpl *renderbuffer,
+ GLMTLRasterizationRateMapANGLE map) override;
+
// override mtl::ErrorHandler
void handleError(GLenum error,
const char *message,
@@ -555,6 +559,7 @@ class ContextMtl : public ContextImpl, public mtl::Context
DIRTY_BIT_RENDER_PIPELINE,
DIRTY_BIT_UNIFORM_BUFFERS_BINDING,
DIRTY_BIT_RASTERIZER_DISCARD,
+ DIRTY_BIT_VARIABLE_RASTERIZATION_RATE,
DIRTY_BIT_INVALID,
DIRTY_BIT_MAX = DIRTY_BIT_INVALID,
@@ -649,6 +654,9 @@ class ContextMtl : public ContextImpl, public mtl::Context
IncompleteTextureSet mIncompleteTextures;
ProvokingVertexHelper mProvokingVertexHelper;
+ mtl::RasterizationRateMapRef mRasterizationRateMap;
+ id<MTLTexture> mRasterizationRateMapTexture;
+
mtl::ContextDevice mContextDevice;
};
diff --git a/src/libANGLE/renderer/metal/ContextMtl.mm b/src/libANGLE/renderer/metal/ContextMtl.mm
index 62a9482ecc478b65431fe323e0e219b0d90fe101..3b53d1e9e38e74c28f66ecd67f4233eebb0a8ab4 100644
--- a/src/libANGLE/renderer/metal/ContextMtl.mm
+++ b/src/libANGLE/renderer/metal/ContextMtl.mm
@@ -263,6 +263,8 @@ void ContextMtl::onDestroy(const gl::Context *context)
mIncompleteTextures.onDestroy(context);
mProvokingVertexHelper.onDestroy(this);
mDummyXFBRenderTexture = nullptr;
+ mRasterizationRateMap.reset();
+ mRasterizationRateMapTexture = nil;
mContextDevice.reset();
}
@@ -1084,6 +1086,13 @@ angle::Result ContextMtl::multiDrawElementsInstancedBaseVertexBaseInstance(
// Device loss
gl::GraphicsResetStatus ContextMtl::getResetStatus()
{
+#if ANGLE_METAL_LOSE_CONTEXT_ON_ERROR == ANGLE_ENABLED
+ if (cmdQueue().isDeviceLost())
+ {
+ return gl::GraphicsResetStatus::UnknownContextReset;
+ }
+#endif
+
return gl::GraphicsResetStatus::NoError;
}
@@ -1425,6 +1434,9 @@ void ContextMtl::updateExtendedState(const gl::State &glState,
case gl::state::EXTENDED_DIRTY_BIT_POLYGON_OFFSET_LINE_ENABLED:
mDirtyBits.set(DIRTY_BIT_DEPTH_BIAS);
break;
+ case gl::state::EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE:
+ mDirtyBits.set(DIRTY_BIT_VARIABLE_RASTERIZATION_RATE);
+ break;
default:
break;
}
@@ -1675,6 +1687,36 @@ angle::Result ContextMtl::memoryBarrierByRegion(const gl::Context *context, GLbi
return angle::Result::Stop;
}
+angle::Result ContextMtl::bindMetalRasterizationRateMap(gl::Context *context,
+ RenderbufferImpl *renderbuffer,
+ GLMTLRasterizationRateMapANGLE map)
+{
+ id<MTLRasterizationRateMap> rateMap = (__bridge id<MTLRasterizationRateMap>)(map);
+ if (rateMap && rateMap.device != mContextDevice.get())
+ {
+ return angle::Result::Stop;
+ }
+
+ if (auto *metalRenderbuffer = static_cast<RenderbufferMtl*>(renderbuffer))
+ {
+ FramebufferAttachmentRenderTarget *rtOut = nullptr;
+ gl::ImageIndex index;
+ GLenum binding = 0;
+ if (angle::Result::Continue == metalRenderbuffer->getAttachmentRenderTarget(context, binding, index, 1, &rtOut))
+ {
+ if (auto *renderTargetMetal = static_cast<RenderTargetMtl*>(rtOut))
+ {
+ mtl::RenderPassAttachmentDesc desc;
+ renderTargetMetal->toRenderPassAttachmentDesc(&desc);
+ mRasterizationRateMapTexture = desc.hasImplicitMSTexture() ? desc.implicitMSTexture.get()->get() : desc.texture.get()->get();
+ }
+ }
+ }
+
+ mRasterizationRateMap = std::move(rateMap);
+ return angle::Result::Continue;
+}
+
// override mtl::ErrorHandler
void ContextMtl::handleError(GLenum glErrorCode,
const char *message,
@@ -2531,8 +2573,22 @@ angle::Result ContextMtl::setupDraw(const gl::Context *context,
return angle::Result::Continue;
}
// Setup with flushed state should either produce a working encoder or fail with an error
- // result.
- ASSERT(mRenderEncoder.valid());
+ // result. if that's not the case, something's gone seriously wrong. Try to
+ // recover from the error by bailing out of the draw call, and finishing the command buffer.
+ // This will result in an unfinished / corrupted draw, but will avoid a browser/GPU process
+ // crash.
+ if (ANGLE_UNLIKELY(!mRenderEncoder.valid() || !mRenderEncoder.hasPipelineState()))
+ {
+ // Completely flush the command buffer, waiting synchronously.
+ flushCommandBuffer(mtl::WaitUntilFinished);
+ // Invalidate all state
+ invalidateState(context);
+ // Return fail, and drop the draw call. This is
+ // a worst case scenario. If in a debug roots situation,
+ // we should try to catch the call stack.
+ ERR() << "Draw call is unusable - please report a bug on bugs.webkit.org";
+ return angle::Result::Stop;
+ }
}
return angle::Result::Continue;
}
@@ -2641,10 +2697,10 @@ angle::Result ContextMtl::setupDrawImpl(const gl::Context *context,
mState.getBlendColor().blue, mState.getBlendColor().alpha);
break;
case DIRTY_BIT_VIEWPORT:
- mRenderEncoder.setViewport(mViewport);
+ mRenderEncoder.setViewport(mViewport, mRenderEncoder.rasterizationRateMapForPass(mRasterizationRateMap, mRasterizationRateMapTexture));
break;
case DIRTY_BIT_SCISSOR:
- mRenderEncoder.setScissorRect(mScissorRect);
+ mRenderEncoder.setScissorRect(mScissorRect, mRenderEncoder.rasterizationRateMapForPass(mRasterizationRateMap, mRasterizationRateMapTexture));
break;
case DIRTY_BIT_DRAW_FRAMEBUFFER:
// Already handled.
@@ -2669,6 +2725,12 @@ angle::Result ContextMtl::setupDrawImpl(const gl::Context *context,
case DIRTY_BIT_RASTERIZER_DISCARD:
// Already handled.
break;
+ case DIRTY_BIT_VARIABLE_RASTERIZATION_RATE:
+ if (getState().privateState().isVariableRasterizationRateEnabled() && mRasterizationRateMap)
+ {
+ mRenderEncoder.setRasterizationRateMap(mRenderEncoder.rasterizationRateMapForPass(mRasterizationRateMap, mRasterizationRateMapTexture));
+ }
+ break;
default:
UNREACHABLE();
break;
diff --git a/src/libANGLE/renderer/metal/DisplayMtl.h b/src/libANGLE/renderer/metal/DisplayMtl.h
index 16ae6340e37283bcd49e8ea926f75a1f6f17f1d6..34aadf0c7e20c05ab4c6791ba412ae2ab120b14a 100644
--- a/src/libANGLE/renderer/metal/DisplayMtl.h
+++ b/src/libANGLE/renderer/metal/DisplayMtl.h
@@ -142,6 +142,7 @@ class DisplayMtl : public DisplayImpl
bool supportsMetal2_2() const;
bool supportsDepth24Stencil8PixelFormat() const;
bool supports32BitFloatFiltering() const;
+ bool supportsVariableRasterizationRate() const;
bool isAMD() const;
bool isAMDBronzeDriver() const;
bool isAMDFireProDevice() const;
diff --git a/src/libANGLE/renderer/metal/DisplayMtl.mm b/src/libANGLE/renderer/metal/DisplayMtl.mm
index 7a7e4c63faf11767e36ef22168c355a94e5145d6..16e834f2a09b3487e7c68ba19f1324b07621e34e 100644
--- a/src/libANGLE/renderer/metal/DisplayMtl.mm
+++ b/src/libANGLE/renderer/metal/DisplayMtl.mm
@@ -184,12 +184,22 @@ void DisplayMtl::terminate()
bool DisplayMtl::testDeviceLost()
{
+#if ANGLE_METAL_LOSE_CONTEXT_ON_ERROR == ANGLE_ENABLED
+ return mCmdQueue.isDeviceLost();
+#else
return false;
+#endif
}
egl::Error DisplayMtl::restoreLostDevice(const egl::Display *display)
{
+#if ANGLE_METAL_LOSE_CONTEXT_ON_ERROR == ANGLE_ENABLED
+ // A Metal device cannot be restored, the entire context would have to be
+ // re-created along with any other EGL objects that reference it.
+ return egl::EglBadDisplay();
+#else
return egl::NoError();
+#endif
}
std::string DisplayMtl::getRendererDescription()
@@ -1179,6 +1189,10 @@ void DisplayMtl::initializeExtensions() const
mNativeCaps.maxImageUnits = gl::IMPLEMENTATION_MAX_PIXEL_LOCAL_STORAGE_PLANES;
}
}
+
+ // GL_ANGLE_variable_rasterization_rate_metal
+ mNativeExtensions.variableRasterizationRateMetalANGLE = mFeatures.hasVariableRasterizationRate.enabled;
+
// "The GPUs in Apple3 through Apple8 families only support memory barriers for compute command
// encoders, and for vertex-to-vertex and vertex-to-fragment stages of render command encoders."
mHasFragmentMemoryBarriers = !supportsAppleGPUFamily(3);
@@ -1251,6 +1265,8 @@ void DisplayMtl::initializeFeatures()
supportsMetal2_1() && (isOSX || isCatalyst) && !isARM);
ANGLE_FEATURE_CONDITION((&mFeatures), hasDepthAutoResolve, supportsEitherGPUFamily(3, 2));
ANGLE_FEATURE_CONDITION((&mFeatures), hasStencilAutoResolve, supportsEitherGPUFamily(5, 2));
+ ANGLE_FEATURE_CONDITION((&mFeatures), hasVariableRasterizationRate,
+ supportsVariableRasterizationRate());
ANGLE_FEATURE_CONDITION((&mFeatures), allowMultisampleStoreAndResolve,
supportsEitherGPUFamily(3, 1));
@@ -1441,8 +1457,7 @@ bool DisplayMtl::supportsMetal2_2() const
bool DisplayMtl::supports32BitFloatFiltering() const
{
#if (defined(__MAC_11_0) && __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_11_0) || \
- (defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_14_0) || \
- (defined(__TVOS_14_0) && __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_14_0)
+ (defined(__IPHONE_14_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_14_0)
if (@available(ios 14.0, macOS 11.0, *))
{
return [mMetalDevice supports32BitFloatFiltering];
@@ -1462,6 +1477,17 @@ bool DisplayMtl::supportsDepth24Stencil8PixelFormat() const
return false;
#endif
}
+
+bool DisplayMtl::supportsVariableRasterizationRate() const
+{
+ if (@available(ios 13.0, macOS 10.15.4, macCatalyst 13.4, tvOS 16.0, *))
+ {
+ return [mMetalDevice supportsRasterizationRateMapWithLayerCount:1];
+ }
+
+ return false;
+}
+
bool DisplayMtl::isAMD() const
{
return angle::IsAMD(mMetalDeviceVendorId);
diff --git a/src/libANGLE/renderer/metal/FrameBufferMtl.mm b/src/libANGLE/renderer/metal/FrameBufferMtl.mm
index b58d7f9d67932bb582c149623aca5054c53333e7..c61d5f65d4e9b6cc85eae02d42f751813e7f796a 100644
--- a/src/libANGLE/renderer/metal/FrameBufferMtl.mm
+++ b/src/libANGLE/renderer/metal/FrameBufferMtl.mm
@@ -1685,8 +1685,13 @@ angle::Result FramebufferMtl::readPixelsToPBO(const gl::Context *context,
ContextMtl *contextMtl = mtl::GetImpl(context);
- ANGLE_MTL_CHECK(contextMtl, packPixelsParams.offset <= std::numeric_limits<uint32_t>::max(),
+ if constexpr (sizeof(packPixelsParams.offset) > sizeof(uint32_t))
+ {
+ ANGLE_MTL_CHECK(contextMtl,
+ static_cast<std::make_unsigned_t<decltype(packPixelsParams.offset)>>(
+ packPixelsParams.offset) <= std::numeric_limits<uint32_t>::max(),
GL_INVALID_OPERATION);
+ }
uint32_t offset = static_cast<uint32_t>(packPixelsParams.offset);
BufferMtl *packBufferMtl = mtl::GetImpl(packPixelsParams.packBuffer);
diff --git a/src/libANGLE/renderer/metal/ImageMtl.mm b/src/libANGLE/renderer/metal/ImageMtl.mm
index a4a809fabe7572c1d212ff8fb4da35b1f67b6a01..eb2bd204b9edda65ba372b8fcb24f8092b9f4f65 100644
--- a/src/libANGLE/renderer/metal/ImageMtl.mm
+++ b/src/libANGLE/renderer/metal/ImageMtl.mm
@@ -86,7 +86,9 @@ egl::Error TextureImageSiblingMtl::ValidateClientBuffer(const DisplayMtl *displa
return egl::EglBadAttribute() << "Unrecognized format";
}
- if (format.metalFormat != texture.pixelFormat)
+ angle::FormatID srcAngleFormatId = mtl::Format::MetalToAngleFormatID(texture.pixelFormat);
+ const mtl::Format &srcFormat = display->getPixelFormat(srcAngleFormatId);
+ if (!format.isViewCompatible(srcFormat))
{
return egl::EglBadAttribute() << "Incompatible format";
}
@@ -120,18 +122,21 @@ angle::Result TextureImageSiblingMtl::initImpl(DisplayMtl *displayMtl)
{
mNativeTexture = mtl::Texture::MakeFromMetal((__bridge id<MTLTexture>)(mBuffer));
- if (mNativeTexture->textureType() == MTLTextureType2DArray)
+ angle::FormatID angleFormatId = intendedFormatForMTLTexture(mNativeTexture->get(), mAttribs);
+ mFormat = displayMtl->getPixelFormat(angleFormatId);
+
+ if (mNativeTexture->textureType() == MTLTextureType2DArray ||
+ mNativeTexture->pixelFormat() != mFormat.metalFormat)
{
mtl::TextureRef baseTexture = std::move(mNativeTexture);
unsigned textureArraySlice =
static_cast<unsigned>(mAttribs.getAsInt(EGL_METAL_TEXTURE_ARRAY_SLICE_ANGLE, 0));
mNativeTexture =
- baseTexture->createSliceMipView(textureArraySlice, mtl::kZeroNativeMipLevel);
+ baseTexture->createSliceMipViewWithCompatibleFormat(textureArraySlice,
+ mtl::kZeroNativeMipLevel,
+ mFormat.metalFormat);
}
- angle::FormatID angleFormatId = intendedFormatForMTLTexture(mNativeTexture->get(), mAttribs);
- mFormat = displayMtl->getPixelFormat(angleFormatId);
-
if (mNativeTexture)
{
size_t resourceSize = EstimateTextureSizeInBytes(
diff --git a/src/libANGLE/renderer/metal/ProgramExecutableMtl.mm b/src/libANGLE/renderer/metal/ProgramExecutableMtl.mm
index d86b83a770764255b12733bf52505db510dac5ac..1fb577f4777bbd6c78046ab64461a99437fb32fa 100644
--- a/src/libANGLE/renderer/metal/ProgramExecutableMtl.mm
+++ b/src/libANGLE/renderer/metal/ProgramExecutableMtl.mm
@@ -897,7 +897,7 @@ angle::Result ProgramExecutableMtl::setupDraw(const gl::Context *glContext,
{
ContextMtl *context = mtl::GetImpl(glContext);
- if (pipelineDescChanged)
+ if (pipelineDescChanged || !cmdEncoder->hasPipelineState())
{
id<MTLFunction> vertexShader = nil;
ANGLE_TRY(
diff --git a/src/libANGLE/renderer/metal/SurfaceMtl.mm b/src/libANGLE/renderer/metal/SurfaceMtl.mm
index 1089fb59517f0c50d055275a66992dda7f380e5f..1c1e2b823d9a4c1340fabb9dff87e8b60993e015 100644
--- a/src/libANGLE/renderer/metal/SurfaceMtl.mm
+++ b/src/libANGLE/renderer/metal/SurfaceMtl.mm
@@ -686,8 +686,7 @@ angle::Result WindowSurfaceMtl::obtainNextDrawable(const gl::Context *context)
mColorTexture->set(mCurrentDrawable.get().texture);
}
- ANGLE_MTL_LOG("Current metal drawable size=%d,%d", mColorTexture->width(),
- mColorTexture->height());
+ ANGLE_MTL_LOG("Current metal drawable size=%d,%d", mColorTexture->width(mtl::MipmapNativeLevel(0)), mColorTexture->height(mtl::MipmapNativeLevel(0)));
// Now we have to resize depth stencil buffers if required.
ANGLE_TRY(ensureCompanionTexturesSizeCorrect(context));
diff --git a/src/libANGLE/renderer/metal/VertexArrayMtl.mm b/src/libANGLE/renderer/metal/VertexArrayMtl.mm
index d93f10afc07d12b88cd234e569fa658a1fbf6ad2..24fc07ff9b0e8294d972e7623173b9d47ff49679 100644
--- a/src/libANGLE/renderer/metal/VertexArrayMtl.mm
+++ b/src/libANGLE/renderer/metal/VertexArrayMtl.mm
@@ -1084,16 +1084,23 @@ angle::Result VertexArrayMtl::convertVertexBufferGPU(const gl::Context *glContex
ANGLE_TRY(conversion->data.allocate(contextMtl, numVertices * targetStride, nullptr, &newBuffer,
&newBufferOffset));
- ANGLE_CHECK_GL_MATH(contextMtl, binding.getOffset() <= std::numeric_limits<uint32_t>::max());
+ GLintptr bindingOffset = binding.getOffset();
+
+ if constexpr (sizeof(bindingOffset) > sizeof(uint32_t))
+ ANGLE_CHECK_GL_MATH(contextMtl, static_cast<std::make_unsigned_t<decltype(bindingOffset)>>(
+ bindingOffset) <= std::numeric_limits<uint32_t>::max());
ANGLE_CHECK_GL_MATH(contextMtl, newBufferOffset <= std::numeric_limits<uint32_t>::max());
ANGLE_CHECK_GL_MATH(contextMtl, numVertices <= std::numeric_limits<uint32_t>::max());
mtl::VertexFormatConvertParams params;
VertexConversionBufferMtl *vertexConversion =
static_cast<VertexConversionBufferMtl *>(conversion);
+ if constexpr (sizeof(vertexConversion->offset) > sizeof(uint32_t))
+ ANGLE_CHECK_GL_MATH(contextMtl,
+ vertexConversion->offset <= std::numeric_limits<uint32_t>::max());
params.srcBuffer = srcBuffer->getCurrentBuffer();
- params.srcBufferStartOffset = static_cast<uint32_t>(
- MIN(static_cast<GLintptr>(vertexConversion->offset), binding.getOffset()));
+ params.srcBufferStartOffset = std::min(static_cast<uint32_t>(vertexConversion->offset),
+ static_cast<uint32_t>(bindingOffset));
params.srcStride = binding.getStride();
params.srcDefaultAlphaData = convertedFormat.defaultAlpha;
diff --git a/src/libANGLE/renderer/metal/mtl_command_buffer.h b/src/libANGLE/renderer/metal/mtl_command_buffer.h
index 7cf68b2d13a8b04fffc57d6223a8b60c7c0df010..0bbd15bd77be43272d8b8542a76926e544af59e8 100644
--- a/src/libANGLE/renderer/metal/mtl_command_buffer.h
+++ b/src/libANGLE/renderer/metal/mtl_command_buffer.h
@@ -104,6 +104,8 @@ class CommandQueue final : public WrappedObject<id<MTLCommandQueue>>, angle::Non
bool isTimeElapsedEntryComplete(uint64_t id);
double getTimeElapsedEntryInSeconds(uint64_t id);
+ bool isDeviceLost() const { return mIsDeviceLost; }
+
private:
void onCommandBufferCompleted(id<MTLCommandBuffer> buf,
uint64_t serial,
@@ -146,6 +148,8 @@ class CommandQueue final : public WrappedObject<id<MTLCommandQueue>>, angle::Non
void recordCommandBufferTimeElapsed(std::lock_guard<std::mutex> &lg,
uint64_t id,
double seconds);
+
+ std::atomic_bool mIsDeviceLost = false;
};
class CommandBuffer final : public WrappedObject<id<MTLCommandBuffer>>, angle::NonCopyable
@@ -426,8 +430,10 @@ class RenderCommandEncoder final : public CommandEncoder
RenderCommandEncoder &setStencilRefVals(uint32_t frontRef, uint32_t backRef);
RenderCommandEncoder &setStencilRefVal(uint32_t ref);
- RenderCommandEncoder &setViewport(const MTLViewport &viewport);
- RenderCommandEncoder &setScissorRect(const MTLScissorRect &rect);
+ RenderCommandEncoder &setViewport(const MTLViewport &viewport,
+ id<MTLRasterizationRateMap> map);
+ RenderCommandEncoder &setScissorRect(const MTLScissorRect &rect,
+ id<MTLRasterizationRateMap> map);
RenderCommandEncoder &setBlendColor(float r, float g, float b, float a);
@@ -576,6 +582,8 @@ class RenderCommandEncoder final : public CommandEncoder
RenderCommandEncoder &setDepthLoadAction(MTLLoadAction action, double clearValue);
RenderCommandEncoder &setStencilLoadAction(MTLLoadAction action, uint32_t clearValue);
+ RenderCommandEncoder &setRasterizationRateMap(id<MTLRasterizationRateMap> map);
+
void setLabel(NSString *label);
void pushDebugGroup(NSString *label) override;
@@ -583,8 +591,11 @@ class RenderCommandEncoder final : public CommandEncoder
const RenderPassDesc &renderPassDesc() const { return mRenderPassDesc; }
bool hasDrawCalls() const { return mHasDrawCalls; }
+ bool hasPipelineState() const { return mPipelineStateSet; }
uint64_t getSerial() const { return mSerial; }
+ id<MTLRasterizationRateMap> rasterizationRateMapForPass(id<MTLRasterizationRateMap> map,
+ id<MTLTexture> colorTexture) const;
private:
// Override CommandEncoder
diff --git a/src/libANGLE/renderer/metal/mtl_command_buffer.mm b/src/libANGLE/renderer/metal/mtl_command_buffer.mm
index 8399d093b04c1d70276219097c0f38a77f17ac0f..1d08dff9d8d2f0f2dd567145a1a5ea095f41760d 100644
--- a/src/libANGLE/renderer/metal/mtl_command_buffer.mm
+++ b/src/libANGLE/renderer/metal/mtl_command_buffer.mm
@@ -373,12 +373,20 @@ inline void SetVisibilityResultModeCmd(id<MTLRenderCommandEncoder> encoder,
[encoder setVisibilityResultMode:mode offset:offset];
}
+#if (defined(__MAC_13_0) && __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_13_0) || \
+ (defined(__IPHONE_16_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_16_0)
+# define ANGLE_MTL_USE_RESOURCE_USAGE_DEPRECATED 1
+#endif
+
inline void UseResourceCmd(id<MTLRenderCommandEncoder> encoder, IntermediateCommandStream *stream)
{
id<MTLResource> resource = stream->fetch<id<MTLResource>>();
MTLResourceUsage usage = stream->fetch<MTLResourceUsage>();
mtl::RenderStages stages = stream->fetch<mtl::RenderStages>();
ANGLE_UNUSED_VARIABLE(stages);
+#if ANGLE_MTL_USE_RESOURCE_USAGE_DEPRECATED
+ [encoder useResource:resource usage:usage stages:stages];
+#else
#if defined(__IPHONE_13_0) || defined(__MAC_10_15)
if (ANGLE_APPLE_AVAILABLE_XCI(10.15, 13.1, 13.0))
{
@@ -391,6 +399,7 @@ inline void UseResourceCmd(id<MTLRenderCommandEncoder> encoder, IntermediateComm
[encoder useResource:resource usage:usage];
ANGLE_APPLE_ALLOW_DEPRECATED_END
}
+#endif
[resource ANGLE_MTL_RELEASE];
}
@@ -644,6 +653,20 @@ void CommandQueue::onCommandBufferCompleted(id<MTLCommandBuffer> buf,
ANGLE_MTL_LOG("Completed MTLCommandBuffer %llu:%p", serial, buf);
+ MTLCommandBufferStatus status = buf.status;
+ if (status != MTLCommandBufferStatusCompleted)
+ {
+ NSError *error = buf.error;
+ // MTLCommandBufferErrorNotPermitted is non-fatal, all other errors
+ // result in device lost.
+ // TODO(djg): Should this also check error.domain for MTLCommandBufferErrorDomain?
+ mIsDeviceLost = !error || error.code != MTLCommandBufferErrorNotPermitted;
+ if (mIsDeviceLost)
+ {
+ return;
+ }
+ }
+
if (timeElapsedEntry != 0)
{
// Record this command buffer's elapsed time.
@@ -1362,6 +1385,7 @@ void RenderCommandEncoder::reset()
CommandEncoder::reset();
mRecording = false;
mPipelineStateSet = false;
+ setRasterizationRateMap(nil);
mCommands.clear();
}
@@ -1776,7 +1800,8 @@ RenderCommandEncoder &RenderCommandEncoder::setStencilRefVal(uint32_t ref)
return setStencilRefVals(ref, ref);
}
-RenderCommandEncoder &RenderCommandEncoder::setViewport(const MTLViewport &viewport)
+RenderCommandEncoder &RenderCommandEncoder::setViewport(const MTLViewport &viewport,
+ id<MTLRasterizationRateMap> map)
{
if (mStateCache.viewport.valid() && mStateCache.viewport.value() == viewport)
{
@@ -1789,12 +1814,22 @@ RenderCommandEncoder &RenderCommandEncoder::setViewport(const MTLViewport &viewp
return *this;
}
-RenderCommandEncoder &RenderCommandEncoder::setScissorRect(const MTLScissorRect &rect)
+RenderCommandEncoder &RenderCommandEncoder::setScissorRect(const MTLScissorRect &rect, id<MTLRasterizationRateMap> map)
{
+ auto maxScissorRect =
+ MTLCoordinate2DMake(mRenderPassMaxScissorRect.width, mRenderPassMaxScissorRect.height);
+
+ if (map)
+ {
+ maxScissorRect = [map mapPhysicalToScreenCoordinates:maxScissorRect forLayer:0];
+ if (!(rect.width * rect.height))
+ return *this;
+ }
+
NSUInteger clampedWidth =
- rect.x > mRenderPassMaxScissorRect.width ? 0 : mRenderPassMaxScissorRect.width - rect.x;
+ rect.x > maxScissorRect.x ? 0 : (NSUInteger)ceilf(maxScissorRect.x) - rect.x;
NSUInteger clampedHeight =
- rect.y > mRenderPassMaxScissorRect.height ? 0 : mRenderPassMaxScissorRect.height - rect.y;
+ rect.y > maxScissorRect.y ? 0 : (NSUInteger)ceilf(maxScissorRect.y) - rect.y;
MTLScissorRect clampedRect = {rect.x, rect.y, std::min(rect.width, clampedWidth),
std::min(rect.height, clampedHeight)};
@@ -1806,6 +1841,23 @@ RenderCommandEncoder &RenderCommandEncoder::setScissorRect(const MTLScissorRect
mStateCache.scissorRect = clampedRect;
+ if (map)
+ {
+ auto adjustedOrigin =
+ [map mapPhysicalToScreenCoordinates:MTLCoordinate2DMake(clampedRect.x, clampedRect.y)
+ forLayer:0];
+ auto adjustedSize =
+ [map mapPhysicalToScreenCoordinates:MTLCoordinate2DMake(clampedRect.width,
+ clampedRect.height)
+ forLayer:0];
+
+ clampedRect.x = (NSUInteger)roundf(adjustedOrigin.x);
+ clampedRect.y = (NSUInteger)roundf(adjustedOrigin.y);
+ MTLSize screenSize = [map screenSize];
+ clampedRect.width = std::min<NSUInteger>(screenSize.width, roundf(adjustedSize.x));
+ clampedRect.height = std::min<NSUInteger>(screenSize.height, roundf(adjustedSize.y));
+ }
+
mCommands.push(CmdType::SetScissorRect).push(clampedRect);
return *this;
@@ -2211,6 +2263,17 @@ void RenderCommandEncoder::popDebugGroup()
mCommands.push(CmdType::PopDebugGroup);
}
+id<MTLRasterizationRateMap> RenderCommandEncoder::rasterizationRateMapForPass(id<MTLRasterizationRateMap> map,
+ id<MTLTexture> texture) const
+{
+ if (!mCachedRenderPassDescObjC.get())
+ return nil;
+
+ MTLSize size = [map physicalSizeForLayer:0];
+ id<MTLTexture> t = mCachedRenderPassDescObjC.get().colorAttachments[0].texture;
+ return t.width == size.width && t.height == size.height ? map : nil;
+}
+
RenderCommandEncoder &RenderCommandEncoder::setColorStoreAction(MTLStoreAction action,
uint32_t colorAttachmentIndex)
{
@@ -2306,6 +2369,16 @@ RenderCommandEncoder &RenderCommandEncoder::setStencilLoadAction(MTLLoadAction a
return *this;
}
+RenderCommandEncoder &RenderCommandEncoder::setRasterizationRateMap(id<MTLRasterizationRateMap> map)
+{
+ if (map != mCachedRenderPassDescObjC.get().rasterizationRateMap)
+ {
+ mCachedRenderPassDescObjC.get().rasterizationRateMap = map;
+ }
+
+ return *this;
+}
+
void RenderCommandEncoder::setLabel(NSString *label)
{
mLabel.retainAssign(label);
diff --git a/src/libANGLE/renderer/metal/mtl_common.h b/src/libANGLE/renderer/metal/mtl_common.h
index b430aa0263545ce6d35ae410e62b035cd41b6c23..96438f09f8b4f576ee2280206b3bdbf461c7618e 100644
--- a/src/libANGLE/renderer/metal/mtl_common.h
+++ b/src/libANGLE/renderer/metal/mtl_common.h
@@ -407,6 +407,8 @@ inline AutoObjCObj<U> adoptObjCObj(U *NS_RELEASES_ARGUMENT src)
# define ANGLE_MTL_EVENT_AVAILABLE 0
#endif
+using RasterizationRateMapRef = AutoObjCPtr<id<MTLRasterizationRateMap>>;
+
// The native image index used by Metal back-end, the image index uses native mipmap level instead
// of "virtual" level modified by OpenGL's base level.
using MipmapNativeLevel = gl::LevelIndexWrapper<uint32_t>;
diff --git a/src/libANGLE/renderer/metal/mtl_format_utils.h b/src/libANGLE/renderer/metal/mtl_format_utils.h
index db95298598177500cebd0eb81cfcb845656031b2..8cbd1014b7dd9c2886272df3ae0923ccec49b512 100644
--- a/src/libANGLE/renderer/metal/mtl_format_utils.h
+++ b/src/libANGLE/renderer/metal/mtl_format_utils.h
@@ -89,6 +89,10 @@ struct Format : public FormatBase
// Need conversion between source format and this format?
bool needConversion(angle::FormatID srcFormatId) const;
+ // Are the formats view compatible without requiring
+ // MTLTextureUsagePixelFormatView?
+ bool isViewCompatible(const Format &srcFormat) const;
+
MTLPixelFormat metalFormat = MTLPixelFormatInvalid;
LoadFunctionMap textureLoadFunctions = nullptr;
diff --git a/src/libANGLE/renderer/metal/mtl_format_utils.mm b/src/libANGLE/renderer/metal/mtl_format_utils.mm
index 42ea015fdd35d71234acd7b64db032ba2831fb9b..047c119251175ca9a3b5bbafb84d6f686b0b22dd 100644
--- a/src/libANGLE/renderer/metal/mtl_format_utils.mm
+++ b/src/libANGLE/renderer/metal/mtl_format_utils.mm
@@ -161,6 +161,26 @@ bool Format::needConversion(angle::FormatID srcFormatId) const
return srcFormatId != actualFormatId;
}
+bool Format::isViewCompatible(const Format &srcFormat) const
+{
+ if (srcFormat.metalFormat == metalFormat)
+ return true;
+
+ // The pixel layout is considered different if the number of components differs,
+ if (srcFormat.caps.channels != caps.channels)
+ return false;
+
+ // ... or if their size or order is different from the components in the original pixel format.
+ if (srcFormat.caps.pixelBytes != caps.pixelBytes)
+ return false;
+
+ // This is overly conservative but reject compressed formats
+ if (srcFormat.caps.compressed || caps.compressed)
+ return false;
+
+ return true;
+}
+
bool Format::isPVRTC() const
{
switch (metalFormat)
diff --git a/src/libANGLE/renderer/metal/mtl_render_utils.mm b/src/libANGLE/renderer/metal/mtl_render_utils.mm
index 9e5487d393a0a2bd64106fc70e7b3f73626e2490..956808f2cd03665bd09d95cf4af90e2eeacdd0ef 100644
--- a/src/libANGLE/renderer/metal/mtl_render_utils.mm
+++ b/src/libANGLE/renderer/metal/mtl_render_utils.mm
@@ -607,7 +607,8 @@ void DispatchCompute(ContextMtl *contextMtl,
id<MTLComputePipelineState> pipelineState,
size_t numThreads)
{
- NSUInteger w = std::min<NSUInteger>(pipelineState.threadExecutionWidth, numThreads);
+ ASSERT(numThreads != 0);
+ NSUInteger w = std::clamp<NSUInteger>(numThreads, 1u, pipelineState.threadExecutionWidth);
MTLSize threadsPerThreadgroup = MTLSizeMake(w, 1, 1);
if (contextMtl->getDisplay()->getFeatures().hasNonUniformDispatch.enabled)
@@ -687,8 +688,9 @@ void SetupCommonBlitWithDrawStates(const gl::Context *context,
GetViewport(params.dstRect, params.dstTextureSize.height, params.dstFlipY);
MTLScissorRect scissorRectMtl =
GetScissorRect(params.dstScissorRect, params.dstTextureSize.height, params.dstFlipY);
- cmdEncoder->setViewport(viewportMtl);
- cmdEncoder->setScissorRect(scissorRectMtl);
+
+ cmdEncoder->setViewport(viewportMtl, nil);
+ cmdEncoder->setScissorRect(scissorRectMtl, nil);
if (params.src)
{
@@ -1222,8 +1224,8 @@ angle::Result ClearUtils::setupClearWithDraw(const gl::Context *context,
scissorRect = GetScissorRect(params.clearArea, params.dstTextureSize.height, params.flipY);
- cmdEncoder->setViewport(viewport);
- cmdEncoder->setScissorRect(scissorRect);
+ cmdEncoder->setViewport(viewport, nil);
+ cmdEncoder->setScissorRect(scissorRect, nil);
// uniform
ClearParamsUniform uniformParams;
diff --git a/src/libANGLE/renderer/metal/mtl_resource_spi.h b/src/libANGLE/renderer/metal/mtl_resource_spi.h
index 3eaa9a64e79af26faa786102ece3f0bdea84d090..7ecb6db9d993df8985fcb6f701dfe7ca75857cae 100644
--- a/src/libANGLE/renderer/metal/mtl_resource_spi.h
+++ b/src/libANGLE/renderer/metal/mtl_resource_spi.h
@@ -1,9 +1,63 @@
-//
-// Copyright 2021 The ANGLE Project Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
+/*
+ * Copyright (C) 2021 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
//
// mtl_resource_spi.h:
-// Used to set Metal resource ownership identity with SPI.
-// Purposefully empty header file. Actual implementation will be hosted in WebKit.
+// Used to set Metal resource ownership identity with SPI
//
+
+#ifndef LIBANGLE_RENDERER_METAL_RESOURCE_SPI_H_
+#define LIBANGLE_RENDERER_METAL_RESOURCE_SPI_H_
+
+#import "common/apple/apple_platform.h"
+
+#if ANGLE_USE_METAL_OWNERSHIP_IDENTITY
+
+# import <Metal/MTLResource_Private.h>
+# import <Metal/Metal.h>
+# import <mach/mach_types.h>
+
+namespace rx
+{
+namespace mtl
+{
+inline void setOwnerWithIdentity(id<MTLResource> resource, task_id_token_t identityToken)
+{
+ if (identityToken != TASK_ID_TOKEN_NULL)
+ {
+ kern_return_t kr = [(id<MTLResourceSPI>)resource setOwnerWithIdentity:identityToken];
+ if (ANGLE_UNLIKELY(kr != KERN_SUCCESS))
+ {
+ ERR() << "setOwnerWithIdentity failed with: %s (%x)" << mach_error_string(kr) << kr;
+ ASSERT(false);
+ }
+ }
+ return;
+}
+} // namespace mtl
+} // namespace rx
+#endif
+
+#endif /* LIBANGLE_RENDERER_METAL_RESOURCE_SPI_H_ */
diff --git a/src/libANGLE/renderer/metal/mtl_resources.h b/src/libANGLE/renderer/metal/mtl_resources.h
index 081c46ef66b3e24f228cd8ee4db46f68abfbcd35..dcd2aee71eb386f3c8d4e8ee773863b048aac379 100644
--- a/src/libANGLE/renderer/metal/mtl_resources.h
+++ b/src/libANGLE/renderer/metal/mtl_resources.h
@@ -227,6 +227,11 @@ class Texture final : public Resource,
TextureRef createCubeFaceView(uint32_t face);
// Create a view of one slice at a level.
TextureRef createSliceMipView(uint32_t slice, const MipmapNativeLevel &level);
+ // Same as createSliceMipView but the target format must be compatible, for example sRGB to linear. In this
+ // case texture doesn't need format view usage flag.
+ TextureRef createSliceMipViewWithCompatibleFormat(uint32_t slice,
+ const MipmapNativeLevel &level,
+ MTLPixelFormat format);
// Create a levels range view
TextureRef createMipsView(const MipmapNativeLevel &baseLevel, uint32_t levels);
// Create a view of a level.
diff --git a/src/libANGLE/renderer/metal/mtl_resources.mm b/src/libANGLE/renderer/metal/mtl_resources.mm
index 50873854b075ce7327e2ecff25a2c37ba707eb88..d9a21b6ec4f1928acace805e61254c20d0f80cda 100644
--- a/src/libANGLE/renderer/metal/mtl_resources.mm
+++ b/src/libANGLE/renderer/metal/mtl_resources.mm
@@ -78,12 +78,10 @@ MTLResourceOptions resourceOptionsForStorageMode(MTLStorageMode storageMode)
return MTLResourceStorageModePrivate;
case MTLStorageModeMemoryless:
return MTLResourceStorageModeMemoryless;
-#if TARGET_OS_SIMULATOR
default:
// TODO(http://anglebug.com/42266474): Remove me once hacked SDKs are fixed.
UNREACHABLE();
return MTLResourceStorageModeShared;
-#endif
}
}
@@ -704,7 +702,9 @@ TextureRef Texture::createCubeFaceView(uint32_t face)
}
}
-TextureRef Texture::createSliceMipView(uint32_t slice, const MipmapNativeLevel &level)
+TextureRef Texture::createSliceMipViewWithCompatibleFormat(uint32_t slice,
+ const MipmapNativeLevel &level,
+ MTLPixelFormat format)
{
ANGLE_MTL_OBJC_SCOPE
{
@@ -713,7 +713,7 @@ TextureRef Texture::createSliceMipView(uint32_t slice, const MipmapNativeLevel &
case MTLTextureTypeCube:
case MTLTextureType2D:
case MTLTextureType2DArray:
- return TextureRef(new Texture(this, pixelFormat(), MTLTextureType2D,
+ return TextureRef(new Texture(this, format, MTLTextureType2D,
NSMakeRange(level.get(), 1), NSMakeRange(slice, 1)));
default:
UNREACHABLE();
@@ -722,6 +722,11 @@ TextureRef Texture::createSliceMipView(uint32_t slice, const MipmapNativeLevel &
}
}
+TextureRef Texture::createSliceMipView(uint32_t slice, const MipmapNativeLevel &level)
+{
+ return createSliceMipViewWithCompatibleFormat(slice, level, pixelFormat());
+}
+
TextureRef Texture::createMipView(const MipmapNativeLevel &level)
{
ANGLE_MTL_OBJC_SCOPE
diff --git a/src/libANGLE/renderer/metal/mtl_state_cache.mm b/src/libANGLE/renderer/metal/mtl_state_cache.mm
index 8534c5c32fbc218da6c00ed95804026ccab508ef..7b2e9926b29407d7870b0da20a6591d0982146e7 100644
--- a/src/libANGLE/renderer/metal/mtl_state_cache.mm
+++ b/src/libANGLE/renderer/metal/mtl_state_cache.mm
@@ -21,9 +21,16 @@
#define ANGLE_OBJC_CP_PROPERTY(DST, SRC, PROPERTY) \
(DST).PROPERTY = static_cast<__typeof__((DST).PROPERTY)>(ToObjC((SRC).PROPERTY))
+#define ANGLE_OBJC_CP_PROPERTY2(DST, SRC, PROPERTY, DST_PROPERTY) \
+ (DST).DST_PROPERTY = static_cast<__typeof__((DST).DST_PROPERTY)>(ToObjC((SRC).PROPERTY))
#define ANGLE_PROP_EQ(LHS, RHS, PROP) ((LHS).PROP == (RHS).PROP)
+#if (defined(__MAC_13_0) && __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_13_0) || \
+ (defined(__IPHONE_16_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_16_0)
+# define ANGLE_MTL_RENDER_PIPELINE_DESC_RASTER_SAMPLE_COUNT_AVAILABLE 1
+#endif
+
namespace rx
{
namespace mtl
diff --git a/src/libANGLE/renderer/metal/mtl_utils.mm b/src/libANGLE/renderer/metal/mtl_utils.mm
index 538a50893839c8a905744524d85e513c9914de0d..e403f8b6c795e5268d45677868c6adf30dda8b9e 100644
--- a/src/libANGLE/renderer/metal/mtl_utils.mm
+++ b/src/libANGLE/renderer/metal/mtl_utils.mm
@@ -1557,6 +1557,24 @@ bool SupportsAppleGPUFamily(id<MTLDevice> device, uint8_t appleFamily)
#endif // TARGET_OS_IOS || TARGET_OS_TV
}
+#if (defined(__MAC_13_0) && __MAC_OS_X_VERSION_MIN_REQUIRED >= __MAC_13_0) || \
+ (defined(__IPHONE_16_0) && __IPHONE_OS_VERSION_MIN_REQUIRED >= __IPHONE_16_0) || \
+ (defined(__TVOS_16_0) && __TV_OS_VERSION_MIN_REQUIRED >= __TVOS_16_0)
+# define ANGLE_MTL_FEATURE_SET_DEPRECATED 1
+# define ANGLE_MTL_GPU_FAMILY_MAC1_DEPRECATED 1
+#endif
+
+#if ANGLE_MTL_GPU_FAMILY_MAC1_DEPRECATED
+# define ANGLE_MTL_GPU_FAMILY_MAC1 MTLGPUFamilyMac2
+# define ANGLE_MTL_GPU_FAMILY_MAC2 MTLGPUFamilyMac2
+#elif TARGET_OS_MACCATALYST
+# define ANGLE_MTL_GPU_FAMILY_MAC1 MTLGPUFamilyMacCatalyst1
+# define ANGLE_MTL_GPU_FAMILY_MAC2 MTLGPUFamilyMacCatalyst2
+#else // !ANGLE_MTL_GPU_FAMILY_MAC1_DEPRECATED && !TARGET_OS_MACCATALYST
+# define ANGLE_MTL_GPU_FAMILY_MAC1 MTLGPUFamilyMac1
+# define ANGLE_MTL_GPU_FAMILY_MAC2 MTLGPUFamilyMac2
+#endif
+
bool SupportsMacGPUFamily(id<MTLDevice> device, uint8_t macFamily)
{
#if TARGET_OS_OSX || TARGET_OS_MACCATALYST
@@ -1571,10 +1589,10 @@ bool SupportsMacGPUFamily(id<MTLDevice> device, uint8_t macFamily)
# if TARGET_OS_MACCATALYST
ANGLE_APPLE_ALLOW_DEPRECATED_BEGIN
case 1:
- family = MTLGPUFamilyMacCatalyst1;
+ family = ANGLE_MTL_GPU_FAMILY_MAC1;
break;
case 2:
- family = MTLGPUFamilyMacCatalyst2;
+ family = ANGLE_MTL_GPU_FAMILY_MAC2;
break;
ANGLE_APPLE_ALLOW_DEPRECATED_END
# else // TARGET_OS_MACCATALYST
@@ -1597,7 +1615,7 @@ bool SupportsMacGPUFamily(id<MTLDevice> device, uint8_t macFamily)
// If device doesn't support [MTLDevice supportsFamily:], then use
// [MTLDevice supportsFeatureSet:].
-# if TARGET_OS_MACCATALYST
+# if TARGET_OS_MACCATALYST || ANGLE_MTL_FEATURE_SET_DEPRECATED
UNREACHABLE();
return false;
# else
diff --git a/src/libANGLE/renderer/metal/shaders/create_mtl_internal_shaders.py b/src/libANGLE/renderer/metal/shaders/create_mtl_internal_shaders.py
new file mode 100644
index 0000000000000000000000000000000000000000..23e8295bcc16412d3aef3fc8e85748fa4ad77a70
--- /dev/null
+++ b/src/libANGLE/renderer/metal/shaders/create_mtl_internal_shaders.py
@@ -0,0 +1,65 @@
+#!/usr/bin/python3
+# Copyright 2021 The ANGLE Project Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+#
+# create_mtl_internal_shaders.py:
+# Script to compile a metalLib into NSData, for including the compilded
+# library in the ANGLE dylib.
+
+import os
+import sys
+import json
+from datetime import datetime
+
+sys.path.append('../..')
+
+template_header_boilerplate = """// GENERATED FILE - DO NOT EDIT.
+// Generated by {script_name}
+//
+// Copyright {copyright_year} The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+"""
+
+
+# Convert content of a file to byte array and store in a header file.
+# variable_name: name of C++ variable that will hold the file content as byte array.
+# filename: the file whose content will be converted to C++ byte array.
+# dest_src_file: destination header file that will contain the byte array.
+def append_file_as_byte_array_string(variable_name, filename, dest_src_file):
+ string = '// Generated from {0}:\n'.format(filename)
+ string += 'constexpr uint8_t {0}[]={{\n'.format(variable_name)
+ bytes_ = open(filename, "rb").read()
+ for byte in bytes_:
+ string += '0x{:02x}'.format(byte) + ", "
+ string += "\n};\n"
+ with open(dest_src_file, "a") as out_file:
+ out_file.write(string)
+
+
+def main():
+ input_file = sys.argv[1]
+ output_file = sys.argv[2]
+ os.chdir(sys.path[0])
+
+ boilerplate_code = template_header_boilerplate.format(
+ script_name=os.path.basename(sys.argv[0]), copyright_year=datetime.today().year)
+
+ # -------- Compile shaders -----------
+ # boiler plate code
+ os.system("echo \"{0}\" > \"{1}\"".format(boilerplate_code, output_file))
+ os.system(
+ 'echo "// Compiled binary for Metal default shaders.\n\n" >> \"{0}\"'.format(output_file))
+ os.system('echo "#include <TargetConditionals.h>\n\n" >> \"{0}\"'.format(output_file))
+
+ os.system('echo "// clang-format off" >> \"{0}\"'.format(output_file))
+
+ append_file_as_byte_array_string('gDefaultMetallib', input_file, output_file)
+
+ os.system('echo "// clang-format on" >> \"{0}\"'.format(output_file))
+
+
+if __name__ == '__main__':
+ sys.exit(main())
diff --git a/src/libANGLE/renderer/vulkan/ContextVk.cpp b/src/libANGLE/renderer/vulkan/ContextVk.cpp
index 9ffb67631de977b6e92d1112a2464b317f89bf92..d7f77cf43b7b4523f86b5b7062509b65a204bc9c 100644
--- a/src/libANGLE/renderer/vulkan/ContextVk.cpp
+++ b/src/libANGLE/renderer/vulkan/ContextVk.cpp
@@ -5920,6 +5920,10 @@ angle::Result ContextVk::syncState(const gl::Context *context,
break;
case gl::state::EXTENDED_DIRTY_BIT_BLEND_ADVANCED_COHERENT:
break;
+ case gl::state::EXTENDED_DIRTY_BIT_VARIABLE_RASTERIZATION_RATE:
+ // Noop until addition of backend support for
+ // ANGLE_variable_rasterization_rate_metal extension
+ break;
default:
UNREACHABLE();
}
diff --git a/src/libANGLE/validationES2.cpp b/src/libANGLE/validationES2.cpp
index eee496a8bb604930b3336b35126c400e52704d5f..a68767be82a7e7a337169782c98c5baae485f89f 100644
--- a/src/libANGLE/validationES2.cpp
+++ b/src/libANGLE/validationES2.cpp
@@ -691,6 +691,9 @@ bool ValidCap(const PrivateState &state, ErrorSet *errors, GLenum cap, bool quer
return state.getClientVersion() >= Version(2, 0) &&
state.getExtensions().blendEquationAdvancedCoherentKHR;
+ case GL_VARIABLE_RASTERIZATION_RATE_ANGLE:
+ return state.getExtensions().variableRasterizationRateMetalANGLE;
+
default:
break;
}
@@ -6344,6 +6347,18 @@ bool ValidateMaxShaderCompilerThreadsKHR(const Context *context,
return true;
}
+bool ValidateBindMetalRasterizationRateMapANGLE(const Context *context,
+ angle::EntryPoint entryPoint,
+ GLMTLRasterizationRateMapANGLE map)
+{
+ if (!context->getExtensions().variableRasterizationRateMetalANGLE)
+ {
+ ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kExtensionNotEnabled);
+ return false;
+ }
+ return true;
+}
+
bool ValidateMultiDrawArraysANGLE(const Context *context,
angle::EntryPoint entryPoint,
PrimitiveMode mode,
diff --git a/src/libANGLE/validationES32.cpp b/src/libANGLE/validationES32.cpp
index f170fc4d8bac3b766bd80083641622fe3571dd6e..4a9c9053385b54ec158d6934e4349d60cd84646e 100644
--- a/src/libANGLE/validationES32.cpp
+++ b/src/libANGLE/validationES32.cpp
@@ -469,6 +469,9 @@ bool ValidateGetPointerv(const Context *context,
case GL_DEBUG_CALLBACK_FUNCTION:
case GL_DEBUG_CALLBACK_USER_PARAM:
return true;
+ // GL_ANGLE_variable_rasterization_rate_metal
+ case GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE:
+ return context->getExtensions().variableRasterizationRateMetalANGLE;
default:
ANGLE_VALIDATION_ERROR(GL_INVALID_ENUM, kInvalidPointerQuery);
return false;
@@ -476,9 +479,16 @@ bool ValidateGetPointerv(const Context *context,
}
else
{
+ switch (pname)
+ {
+ // GL_ANGLE_variable_rasterization_rate_metal
+ case GL_METAL_RASTERIZATION_RATE_MAP_BINDING_ANGLE:
+ return context->getExtensions().variableRasterizationRateMetalANGLE;
+ default:
ANGLE_VALIDATION_ERROR(GL_INVALID_OPERATION, kES1or32Required);
return false;
}
+ }
}
bool ValidateGetSamplerParameterIiv(const Context *context,
diff --git a/src/libANGLE/validationESEXT_autogen.h b/src/libANGLE/validationESEXT_autogen.h
index de36b7a9d310208e2a600c895b253003c0a11484..41bd167ae5c715a32107b1c9a037d3740cc26b15 100644
--- a/src/libANGLE/validationESEXT_autogen.h
+++ b/src/libANGLE/validationESEXT_autogen.h
@@ -995,6 +995,11 @@ bool ValidateGetTranslatedShaderSourceANGLE(const Context *context,
const GLsizei *length,
const GLchar *source);
+// GL_ANGLE_variable_rasterization_rate_metal
+bool ValidateBindMetalRasterizationRateMapANGLE(const Context *context,
+ angle::EntryPoint entryPoint,
+ GLMTLRasterizationRateMapANGLE map);
+
// GL_ANGLE_vulkan_image
bool ValidateAcquireTexturesANGLE(const Context *context,
angle::EntryPoint entryPoint,
diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
index cb14151bfad4eade0972bec0dc9c1bb51b27f3e4..60a78aa6e35d9b36b1d75dd23a17de6f4028bc96 100644
--- a/src/libGLESv2/entry_points_gles_ext_autogen.cpp
+++ b/src/libGLESv2/entry_points_gles_ext_autogen.cpp
@@ -4638,6 +4638,36 @@ void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader,
ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
}
+// GL_ANGLE_variable_rasterization_rate_metal
+void GL_APIENTRY GL_BindMetalRasterizationRateMapANGLE(GLuint renderbuffer, GLMTLRasterizationRateMapANGLE map)
+{
+ Context *context = GetValidGlobalContext();
+ EVENT(context, GLBindMetalRasterizationRateMapANGLE, "context = %d, map = 0x%016" PRIxPTR "",
+ CID(context), (uintptr_t)map);
+
+ if (context)
+ {
+ SCOPED_SHARE_CONTEXT_LOCK(context);
+ bool isCallValid =
+ (context->skipValidation() ||
+ (ValidatePixelLocalStorageInactive(
+ context->getPrivateState(), context->getMutableErrorSetForValidation(),
+ angle::EntryPoint::GLBindMetalRasterizationRateMapANGLE) &&
+ ValidateBindMetalRasterizationRateMapANGLE(
+ context, angle::EntryPoint::GLBindMetalRasterizationRateMapANGLE, map)));
+ if (isCallValid)
+ {
+ context->bindMetalRasterizationRateMap(renderbuffer, map);
+ }
+ ANGLE_CAPTURE_GL(BindMetalRasterizationRateMapANGLE, isCallValid, context, map);
+ }
+ else
+ {
+ GenerateContextLostErrorOnCurrentGlobalContext();
+ }
+ ASSERT(!egl::Display::GetCurrentThreadUnlockedTailCall()->any());
+}
+
// GL_ANGLE_vulkan_image
void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures,
const GLuint *textures,
diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.h b/src/libGLESv2/entry_points_gles_ext_autogen.h
index e389d4728c4f16da54842c71e13e6857ed81daa2..0260d8adc5541ca8e12086207c382784fa9766eb 100644
--- a/src/libGLESv2/entry_points_gles_ext_autogen.h
+++ b/src/libGLESv2/entry_points_gles_ext_autogen.h
@@ -738,6 +738,10 @@ ANGLE_EXPORT void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader,
GLsizei *length,
GLchar *source);
+// GL_ANGLE_variable_rasterization_rate_metal
+ANGLE_EXPORT void GL_APIENTRY
+GL_BindMetalRasterizationRateMapANGLE(GLuint framebuffer, GLMTLRasterizationRateMapANGLE map);
+
// GL_ANGLE_vulkan_image
ANGLE_EXPORT void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures,
const GLuint *textures,
diff --git a/src/libGLESv2/libGLESv2_autogen.cpp b/src/libGLESv2/libGLESv2_autogen.cpp
index 5cc6a38217e8074633a63afd66c8ac7519c75f43..213539b2cefb4e794b47c01396c804c8414ad233 100644
--- a/src/libGLESv2/libGLESv2_autogen.cpp
+++ b/src/libGLESv2/libGLESv2_autogen.cpp
@@ -3942,6 +3942,12 @@ void GL_APIENTRY glGetTranslatedShaderSourceANGLE(GLuint shader,
return GL_GetTranslatedShaderSourceANGLE(shader, bufSize, length, source);
}
+// GL_ANGLE_variable_rasterization_rate_metal
+void GL_APIENTRY glBindMetalRasterizationRateMapANGLE(GLuint renderbuffer, GLMTLRasterizationRateMapANGLE map)
+{
+ return GL_BindMetalRasterizationRateMapANGLE(renderbuffer, map);
+}
+
// GL_ANGLE_vulkan_image
void GL_APIENTRY glAcquireTexturesANGLE(GLuint numTextures,
const GLuint *textures,
diff --git a/src/libGLESv2/libGLESv2_autogen.def b/src/libGLESv2/libGLESv2_autogen.def
index 8117e28d0ec91924ece75f22a64c87e6573f70a4..200c7110e26346d3172542a1a598324322df10ab 100644
--- a/src/libGLESv2/libGLESv2_autogen.def
+++ b/src/libGLESv2/libGLESv2_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/libGLESv2_no_capture_autogen.def b/src/libGLESv2/libGLESv2_no_capture_autogen.def
index 57875834664dc72e867fd161b0f0b27d683affd4..dfcc2c424ee4a976782f01add8a3051435db8906 100644
--- a/src/libGLESv2/libGLESv2_no_capture_autogen.def
+++ b/src/libGLESv2/libGLESv2_no_capture_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/libGLESv2_vulkan_secondaries_autogen.def b/src/libGLESv2/libGLESv2_vulkan_secondaries_autogen.def
index ba0237ae105122f6e8f6349a2f0f294b5de30375..7efab9e284c4da08a95d01917ad59ca7410ba189 100644
--- a/src/libGLESv2/libGLESv2_vulkan_secondaries_autogen.def
+++ b/src/libGLESv2/libGLESv2_vulkan_secondaries_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/libGLESv2_with_capture_autogen.def b/src/libGLESv2/libGLESv2_with_capture_autogen.def
index a242e6df2f07d273730e8fead7b1a7e5086a08a8..2559cd521aab1e6066559a44c7ecda1f98f8bd22 100644
--- a/src/libGLESv2/libGLESv2_with_capture_autogen.def
+++ b/src/libGLESv2/libGLESv2_with_capture_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/opengl32_autogen.def b/src/libGLESv2/opengl32_autogen.def
index 782e627b9e2270d8cbb335fee5f191e15cbd98c7..910c861ae5917b8c6048e7519d03dec28e7d52a9 100644
--- a/src/libGLESv2/opengl32_autogen.def
+++ b/src/libGLESv2/opengl32_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/opengl32_with_wgl_autogen.def b/src/libGLESv2/opengl32_with_wgl_autogen.def
index 30763ef3b30b4184d92008adea49e0eb3d6d1f9c..f1ba5c64dfaeb7350ef31c033e54a87696985ab4 100644
--- a/src/libGLESv2/opengl32_with_wgl_autogen.def
+++ b/src/libGLESv2/opengl32_with_wgl_autogen.def
@@ -668,6 +668,9 @@ EXPORTS
; GL_ANGLE_translated_shader_source
glGetTranslatedShaderSourceANGLE
+ ; GL_ANGLE_variable_rasterization_rate_metal
+ glBindMetalRasterizationRateMapANGLE
+
; GL_ANGLE_vulkan_image
glAcquireTexturesANGLE
glReleaseTexturesANGLE
diff --git a/src/libGLESv2/proc_table_egl_autogen.cpp b/src/libGLESv2/proc_table_egl_autogen.cpp
index 4669eb7255e7c5d2f38415717e41f9a52978c446..b4ebf9cce3da85b54d2793485dbb9aad21e2a1f9 100644
--- a/src/libGLESv2/proc_table_egl_autogen.cpp
+++ b/src/libGLESv2/proc_table_egl_autogen.cpp
@@ -190,6 +190,7 @@ const ProcEntry g_procTable[] = {
{"glBindFramebufferOES", P(GL_BindFramebufferOES)},
{"glBindImageTexture", P(GL_BindImageTexture)},
DESKTOP_ONLY("glBindImageTextures", GL_BindImageTextures)
+ {"glBindMetalRasterizationRateMapANGLE", P(GL_BindMetalRasterizationRateMapANGLE)},
{"glBindProgramPipeline", P(GL_BindProgramPipeline)},
{"glBindProgramPipelineEXT", P(GL_BindProgramPipelineEXT)},
{"glBindRenderbuffer", P(GL_BindRenderbuffer)},
diff --git a/src/libGLESv2/proc_table_glx_autogen.cpp b/src/libGLESv2/proc_table_glx_autogen.cpp
index 413a54610cfc5a2404c5b703e638e003041e3668..e7b49f3f4a63d09a81282d10efad58ffd1b4f7da 100644
--- a/src/libGLESv2/proc_table_glx_autogen.cpp
+++ b/src/libGLESv2/proc_table_glx_autogen.cpp
@@ -67,6 +67,7 @@ const ProcEntry g_procTable[] = {
{"glBindFramebufferOES", P(GL_BindFramebufferOES)},
{"glBindImageTexture", P(GL_BindImageTexture)},
{"glBindImageTextures", P(GL_BindImageTextures)},
+ {"glBindMetalRasterizationRateMapANGLE", P(GL_BindMetalRasterizationRateMapANGLE)},
{"glBindProgramPipeline", P(GL_BindProgramPipeline)},
{"glBindProgramPipelineEXT", P(GL_BindProgramPipelineEXT)},
{"glBindRenderbuffer", P(GL_BindRenderbuffer)},
diff --git a/src/libGLESv2/proc_table_wgl_autogen.cpp b/src/libGLESv2/proc_table_wgl_autogen.cpp
index 4cfd778a60259c742692602a6a0d9f10bdab5806..63fc1cb00b9b5f36a4ded5b55c6f993c1febe84d 100644
--- a/src/libGLESv2/proc_table_wgl_autogen.cpp
+++ b/src/libGLESv2/proc_table_wgl_autogen.cpp
@@ -67,6 +67,7 @@ const ProcEntry g_procTable[] = {
{"glBindFramebufferOES", P(GL_BindFramebufferOES)},
{"glBindImageTexture", P(GL_BindImageTexture)},
{"glBindImageTextures", P(GL_BindImageTextures)},
+ {"glBindMetalRasterizationRateMapANGLE", P(GL_BindMetalRasterizationRateMapANGLE)},
{"glBindProgramPipeline", P(GL_BindProgramPipeline)},
{"glBindProgramPipelineEXT", P(GL_BindProgramPipelineEXT)},
{"glBindRenderbuffer", P(GL_BindRenderbuffer)},
diff --git a/src/tests/angle_end2end_tests.gni b/src/tests/angle_end2end_tests.gni
index 879a6de5c94c64e6a676fe177df432a1cdc7f680..8af0ba1aa72a6d46a72f43ef3f4c76193b8460f2 100644
--- a/src/tests/angle_end2end_tests.gni
+++ b/src/tests/angle_end2end_tests.gni
@@ -226,6 +226,7 @@ angle_end2end_tests_mac_sources = [
"egl_tests/EGLSyncTestMetalSharedEvent.mm",
"egl_tests/EGLWaitUntilWorkScheduledTest.cpp",
"gl_tests/ImageTestMetal.mm",
+ "gl_tests/VariableRasterizationRateTestMetal.mm",
]
angle_end2end_tests_win_sources = [
"egl_tests/EGLDeviceTest.cpp",
diff --git a/src/tests/gl_tests/PbufferTest.cpp b/src/tests/gl_tests/PbufferTest.cpp
index 969cd2f96d302d74dd3515ac842b93eb51387cd2..730d0ffa536caf536ec750e2bac82c8187cda8ce 100644
--- a/src/tests/gl_tests/PbufferTest.cpp
+++ b/src/tests/gl_tests/PbufferTest.cpp
@@ -302,7 +302,6 @@ TEST_P(PbufferTest, BindTexImageOverwrite)
// Test skipped because Pbuffers are not supported or Pbuffer does not support binding to RGBA
// textures.
ANGLE_SKIP_TEST_IF(!mSupportsPbuffers || !mSupportsBindTexImage);
-
EGLWindow *window = getEGLWindow();
window->makeCurrent();
@@ -532,7 +531,6 @@ TEST_P(PbufferTest, BindTexImageOverwriteReleasesOrphanedPbuffer)
// Test skipped because Pbuffers are not supported or Pbuffer does not support binding to RGBA
// textures.
ANGLE_SKIP_TEST_IF(!mSupportsPbuffers || !mSupportsBindTexImage);
-
EGLWindow *window = getEGLWindow();
window->makeCurrent();
diff --git a/util/autogen/angle_features_autogen.cpp b/util/autogen/angle_features_autogen.cpp
index f4c6e4a8b7492243252413a5e17f1a35d9ee9fef..28ab6adc31f6fbb4fdf824f31812fd9679c100ec 100644
--- a/util/autogen/angle_features_autogen.cpp
+++ b/util/autogen/angle_features_autogen.cpp
@@ -200,6 +200,7 @@ constexpr PackedEnumMap<Feature, const char *> kFeatureNames = {{
{Feature::HasShaderStencilOutput, "hasShaderStencilOutput"},
{Feature::HasStencilAutoResolve, "hasStencilAutoResolve"},
{Feature::HasTextureSwizzle, "hasTextureSwizzle"},
+ {Feature::HasVariableRasterizationRate, "hasVariableRasterizationRate"},
{Feature::InitFragmentOutputVariables, "initFragmentOutputVariables"},
{Feature::InitializeCurrentVertexAttributes, "initializeCurrentVertexAttributes"},
{Feature::InjectAsmStatementIntoLoopBodies, "injectAsmStatementIntoLoopBodies"},
diff --git a/util/autogen/angle_features_autogen.h b/util/autogen/angle_features_autogen.h
index fc9632144674ae1b27ce8f1a961de3b2225f4666..a93eb665f2ee9fae1ad08abcf37926b4b71c79e6 100644
--- a/util/autogen/angle_features_autogen.h
+++ b/util/autogen/angle_features_autogen.h
@@ -200,6 +200,7 @@ enum class Feature
HasShaderStencilOutput,
HasStencilAutoResolve,
HasTextureSwizzle,
+ HasVariableRasterizationRate,
InitFragmentOutputVariables,
InitializeCurrentVertexAttributes,
InjectAsmStatementIntoLoopBodies,
diff --git a/util/capture/frame_capture_replay_autogen.cpp b/util/capture/frame_capture_replay_autogen.cpp
index 0356ae084c4e6394c3de340273b2426f9d8c2497..05684ff50b97458433160bb08ee573c6cf64898d 100644
--- a/util/capture/frame_capture_replay_autogen.cpp
+++ b/util/capture/frame_capture_replay_autogen.cpp
@@ -105,6 +105,10 @@ void ReplayTraceFunctionCall(const CallCapture &call, const TraceFunctionMap &cu
captures[3].value.GLbooleanVal, captures[4].value.GLintVal,
captures[5].value.GLenumVal, captures[6].value.GLenumVal);
break;
+ case angle::EntryPoint::GLBindMetalRasterizationRateMapANGLE:
+ glBindMetalRasterizationRateMapANGLE(
+ captures[0].value.GLMTLRasterizationRateMapANGLEVal);
+ break;
case angle::EntryPoint::GLBindProgramPipeline:
glBindProgramPipeline(gProgramPipelineMap[captures[0].value.GLuintVal]);
break;
diff --git a/util/capture/trace_gles_loader_autogen.cpp b/util/capture/trace_gles_loader_autogen.cpp
index 2a2450169abf46c88371eb7cfc3c4f5755db5a84..ba7cd722020ac6fbd156af9ff8fcb034351a57c2 100644
--- a/util/capture/trace_gles_loader_autogen.cpp
+++ b/util/capture/trace_gles_loader_autogen.cpp
@@ -630,6 +630,8 @@ ANGLE_TRACE_LOADER_EXPORT PFNGLSAMPLEMASKIANGLEPROC t_glSampleMaskiANGLE;
ANGLE_TRACE_LOADER_EXPORT PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC t_glTexStorage2DMultisampleANGLE;
ANGLE_TRACE_LOADER_EXPORT PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC
t_glGetTranslatedShaderSourceANGLE;
+ANGLE_TRACE_LOADER_EXPORT PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC
+ t_glBindMetalRasterizationRateMapANGLE;
ANGLE_TRACE_LOADER_EXPORT PFNGLACQUIRETEXTURESANGLEPROC t_glAcquireTexturesANGLE;
ANGLE_TRACE_LOADER_EXPORT PFNGLRELEASETEXTURESANGLEPROC t_glReleaseTexturesANGLE;
ANGLE_TRACE_LOADER_EXPORT PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC t_glBindUniformLocationCHROMIUM;
@@ -1845,6 +1847,9 @@ void LoadTraceGLES(LoadProc loadProc)
loadProc("glTexStorage2DMultisampleANGLE"));
t_glGetTranslatedShaderSourceANGLE = reinterpret_cast<PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC>(
loadProc("glGetTranslatedShaderSourceANGLE"));
+ t_glBindMetalRasterizationRateMapANGLE =
+ reinterpret_cast<PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC>(
+ loadProc("glBindMetalRasterizationRateMapANGLE"));
t_glAcquireTexturesANGLE =
reinterpret_cast<PFNGLACQUIRETEXTURESANGLEPROC>(loadProc("glAcquireTexturesANGLE"));
t_glReleaseTexturesANGLE =
diff --git a/util/capture/trace_gles_loader_autogen.h b/util/capture/trace_gles_loader_autogen.h
index c1e82cb5725914d533051df5e521b01e2fb872ff..c72acd9c43d3a326ff42652fdf8597fd5d8bbd99 100644
--- a/util/capture/trace_gles_loader_autogen.h
+++ b/util/capture/trace_gles_loader_autogen.h
@@ -595,6 +595,7 @@
#define glSampleMaskiANGLE t_glSampleMaskiANGLE
#define glTexStorage2DMultisampleANGLE t_glTexStorage2DMultisampleANGLE
#define glGetTranslatedShaderSourceANGLE t_glGetTranslatedShaderSourceANGLE
+#define glBindMetalRasterizationRateMapANGLE t_glBindMetalRasterizationRateMapANGLE
#define glAcquireTexturesANGLE t_glAcquireTexturesANGLE
#define glReleaseTexturesANGLE t_glReleaseTexturesANGLE
#define glBindUniformLocationCHROMIUM t_glBindUniformLocationCHROMIUM
@@ -1515,6 +1516,8 @@ ANGLE_TRACE_LOADER_EXPORT extern PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC
t_glTexStorage2DMultisampleANGLE;
ANGLE_TRACE_LOADER_EXPORT extern PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC
t_glGetTranslatedShaderSourceANGLE;
+ANGLE_TRACE_LOADER_EXPORT extern PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC
+ t_glBindMetalRasterizationRateMapANGLE;
ANGLE_TRACE_LOADER_EXPORT extern PFNGLACQUIRETEXTURESANGLEPROC t_glAcquireTexturesANGLE;
ANGLE_TRACE_LOADER_EXPORT extern PFNGLRELEASETEXTURESANGLEPROC t_glReleaseTexturesANGLE;
ANGLE_TRACE_LOADER_EXPORT extern PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC
diff --git a/util/capture/trace_interpreter_autogen.cpp b/util/capture/trace_interpreter_autogen.cpp
index 7e73814693678a881dd1f461afa8b8d0c4e33606..505f51c431db7d6ebf33f28e846c018ed1b181ac 100644
--- a/util/capture/trace_interpreter_autogen.cpp
+++ b/util/capture/trace_interpreter_autogen.cpp
@@ -896,6 +896,13 @@ CallCapture ParseCallCapture(const Token &nameToken,
paramTokens, strings);
return CallCapture(EntryPoint::GLBindImageTexture, std::move(params));
}
+ if (strcmp(nameToken, "glBindMetalRasterizationRateMapANGLE") == 0)
+ {
+ ParamBuffer params =
+ ParseParameters<std::remove_pointer<PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC>::type>(
+ paramTokens, strings);
+ return CallCapture(EntryPoint::GLBindMetalRasterizationRateMapANGLE, std::move(params));
+ }
if (strcmp(nameToken, "glBindProgramPipeline") == 0)
{
ParamBuffer params =
diff --git a/util/gles_loader_autogen.cpp b/util/gles_loader_autogen.cpp
index 65c2f5ab70c3a73d292c4225b83d2ce9403eeef0..ea62bf6a6df341f02daaeab91d1cf6a422719cb9 100644
--- a/util/gles_loader_autogen.cpp
+++ b/util/gles_loader_autogen.cpp
@@ -607,6 +607,8 @@ ANGLE_UTIL_EXPORT PFNGLGETMULTISAMPLEFVANGLEPROC l_glGetMultisamplefvANGLE;
ANGLE_UTIL_EXPORT PFNGLSAMPLEMASKIANGLEPROC l_glSampleMaskiANGLE;
ANGLE_UTIL_EXPORT PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC l_glTexStorage2DMultisampleANGLE;
ANGLE_UTIL_EXPORT PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC l_glGetTranslatedShaderSourceANGLE;
+ANGLE_UTIL_EXPORT PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC
+ l_glBindMetalRasterizationRateMapANGLE;
ANGLE_UTIL_EXPORT PFNGLACQUIRETEXTURESANGLEPROC l_glAcquireTexturesANGLE;
ANGLE_UTIL_EXPORT PFNGLRELEASETEXTURESANGLEPROC l_glReleaseTexturesANGLE;
ANGLE_UTIL_EXPORT PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC l_glBindUniformLocationCHROMIUM;
@@ -1812,6 +1814,9 @@ void LoadUtilGLES(LoadProc loadProc)
loadProc("glTexStorage2DMultisampleANGLE"));
l_glGetTranslatedShaderSourceANGLE = reinterpret_cast<PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC>(
loadProc("glGetTranslatedShaderSourceANGLE"));
+ l_glBindMetalRasterizationRateMapANGLE =
+ reinterpret_cast<PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC>(
+ loadProc("glBindMetalRasterizationRateMapANGLE"));
l_glAcquireTexturesANGLE =
reinterpret_cast<PFNGLACQUIRETEXTURESANGLEPROC>(loadProc("glAcquireTexturesANGLE"));
l_glReleaseTexturesANGLE =
diff --git a/util/gles_loader_autogen.h b/util/gles_loader_autogen.h
index 2ffeb4c8deebff80248ffc9c07230322c1a5e956..4369b668525fc6540e97cedfcc0e39cb7292ab2d 100644
--- a/util/gles_loader_autogen.h
+++ b/util/gles_loader_autogen.h
@@ -595,6 +595,7 @@
#define glSampleMaskiANGLE l_glSampleMaskiANGLE
#define glTexStorage2DMultisampleANGLE l_glTexStorage2DMultisampleANGLE
#define glGetTranslatedShaderSourceANGLE l_glGetTranslatedShaderSourceANGLE
+#define glBindMetalRasterizationRateMapANGLE l_glBindMetalRasterizationRateMapANGLE
#define glAcquireTexturesANGLE l_glAcquireTexturesANGLE
#define glReleaseTexturesANGLE l_glReleaseTexturesANGLE
#define glBindUniformLocationCHROMIUM l_glBindUniformLocationCHROMIUM
@@ -1480,6 +1481,8 @@ ANGLE_UTIL_EXPORT extern PFNGLGETMULTISAMPLEFVANGLEPROC l_glGetMultisamplefvANGL
ANGLE_UTIL_EXPORT extern PFNGLSAMPLEMASKIANGLEPROC l_glSampleMaskiANGLE;
ANGLE_UTIL_EXPORT extern PFNGLTEXSTORAGE2DMULTISAMPLEANGLEPROC l_glTexStorage2DMultisampleANGLE;
ANGLE_UTIL_EXPORT extern PFNGLGETTRANSLATEDSHADERSOURCEANGLEPROC l_glGetTranslatedShaderSourceANGLE;
+ANGLE_UTIL_EXPORT extern PFNGLBINDMETALRASTERIZATIONRATEMAPANGLEPROC
+ l_glBindMetalRasterizationRateMapANGLE;
ANGLE_UTIL_EXPORT extern PFNGLACQUIRETEXTURESANGLEPROC l_glAcquireTexturesANGLE;
ANGLE_UTIL_EXPORT extern PFNGLRELEASETEXTURESANGLEPROC l_glReleaseTexturesANGLE;
ANGLE_UTIL_EXPORT extern PFNGLBINDUNIFORMLOCATIONCHROMIUMPROC l_glBindUniformLocationCHROMIUM;