diff --git a/DEPS b/DEPS index 8ec714d61..d76edce19 100644 --- a/DEPS +++ b/DEPS @@ -473,7 +473,7 @@ deps = { }, 'third_party/OpenGL-Registry/src': { - 'url': '{chromium_git}/external/github.com/KhronosGroup/OpenGL-Registry@5048bd8682a4483d00ea8de495cd8e59b2c720af', + 'url': '{chromium_git}/external/github.com/KhronosGroup/OpenGL-Registry@11d7b7baebfc2b58116670cd17266f9c6a0d760b', 'condition': 'not build_with_chromium', }, diff --git a/scripts/code_generation_hashes/Extension_files.json b/scripts/code_generation_hashes/Extension_files.json index 7d9e6ab0e..04771420c 100644 --- a/scripts/code_generation_hashes/Extension_files.json +++ b/scripts/code_generation_hashes/Extension_files.json @@ -20,11 +20,11 @@ "scripts/extension_data/swiftshader_win10_gles1.json": "fbf1c3dc83570c1e3fffdbee313bca30", "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", + "c79f59912f42e96ea958dddb5e029d47", "scripts/gl_angle_ext.xml": - "37eebedc1153cd9d208efa469a10a7b2", + "07ce630bceb8d419943bfc8064e247b3", "scripts/registry_xml.py": - "4d162936baeb7e803561559e11b7fd89", + "b1150b94db620646a38156213cbba402", "src/libANGLE/gen_extensions.py": "6ea1cb1733c4df98b527bbf2752e118b", "src/libANGLE/gles_extensions_autogen.cpp": @@ -38,5 +38,5 @@ "third_party/OpenGL-Registry/src/xml/glx.xml": "94f3eee4b076801d117804eb466714b7", "third_party/OpenGL-Registry/src/xml/wgl.xml": - "b674e6e4ae71067341985e93b410b5f1" + "eae784bf4d1b983a42af5671b140b7c4" } \ No newline at end of file diff --git a/scripts/code_generation_hashes/GL_EGL_WGL_loader.json b/scripts/code_generation_hashes/GL_EGL_WGL_loader.json index c28914257..57c0f14e3 100644 --- a/scripts/code_generation_hashes/GL_EGL_WGL_loader.json +++ b/scripts/code_generation_hashes/GL_EGL_WGL_loader.json @@ -4,11 +4,11 @@ "scripts/generate_loader.py": "101c7ad1f8f1bcd7c1afee3b854913af", "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", + "c79f59912f42e96ea958dddb5e029d47", "scripts/gl_angle_ext.xml": - "37eebedc1153cd9d208efa469a10a7b2", + "07ce630bceb8d419943bfc8064e247b3", "scripts/registry_xml.py": - "4d162936baeb7e803561559e11b7fd89", + "b1150b94db620646a38156213cbba402", "src/libEGL/egl_loader_autogen.cpp": "f8e305c5b9defa9ec419cac1a4c2247c", "src/libEGL/egl_loader_autogen.h": @@ -20,7 +20,7 @@ "third_party/OpenGL-Registry/src/xml/glx.xml": "94f3eee4b076801d117804eb466714b7", "third_party/OpenGL-Registry/src/xml/wgl.xml": - "b674e6e4ae71067341985e93b410b5f1", + "eae784bf4d1b983a42af5671b140b7c4", "util/capture/trace_egl_loader_autogen.cpp": "757d54a7afc30f8aa3d285ad2318f68c", "util/capture/trace_egl_loader_autogen.h": diff --git a/scripts/code_generation_hashes/GL_EGL_entry_points.json b/scripts/code_generation_hashes/GL_EGL_entry_points.json index fd42fc12c..dceb8dd98 100644 --- a/scripts/code_generation_hashes/GL_EGL_entry_points.json +++ b/scripts/code_generation_hashes/GL_EGL_entry_points.json @@ -6,13 +6,13 @@ "scripts/entry_point_packed_gl_enums.json": "413cb2b6fb98a4465d50d59d55757cf3", "scripts/generate_entry_points.py": - "72312c837798c241d426159706d4848d", + "b90b38e9891bfef0922702ff0ae101cd", "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", + "c79f59912f42e96ea958dddb5e029d47", "scripts/gl_angle_ext.xml": - "37eebedc1153cd9d208efa469a10a7b2", + "07ce630bceb8d419943bfc8064e247b3", "scripts/registry_xml.py": - "4d162936baeb7e803561559e11b7fd89", + "b1150b94db620646a38156213cbba402", "src/common/entry_points_enum_autogen.cpp": "c78602e4d4280c80bd72299291db1e81", "src/common/entry_points_enum_autogen.h": @@ -24,61 +24,61 @@ "src/libANGLE/Context_gl_3_autogen.h": "cf9b149f033b1349409c0b4ee4042bdd", "src/libANGLE/Context_gl_4_autogen.h": - "90ef34d3aa1ed1bbd2664ad614f94873", + "4fc9189726b0e554f9c5840a781788b5", "src/libANGLE/Context_gles_1_0_autogen.h": "51fce95acbf8de72d21255adbbe0e8cd", "src/libANGLE/Context_gles_2_0_autogen.h": - "443d00d45de147d1d1e3b66846ea0c29", + "b1321cf0207870029cb759bd603e9267", "src/libANGLE/Context_gles_3_0_autogen.h": - "6c07c41ebd6f1d0ff9d97894332c9e1a", + "815d4227d514b55b731cc4c5ed43e70a", "src/libANGLE/Context_gles_3_1_autogen.h": - "bb8198422232ca9ceaa06a5d37c3cd92", + "e26ffdad1be7d4a4aabecf7bfb40bf3f", "src/libANGLE/Context_gles_3_2_autogen.h": "48567dca16fd881dfe6d61fee0e3106f", "src/libANGLE/Context_gles_ext_autogen.h": - "57fc78926098de0050c161c69ff03597", + "d075bea905b1cf6d2f94ebc2ea9639e2", "src/libANGLE/capture/capture_gl_1_autogen.cpp": - "f6247f09190caa17199c2b9244396954", + "a43ea4d99dfec5682df0e37cf7266536", "src/libANGLE/capture/capture_gl_1_autogen.h": "48ab591d9671ea49aa9ae977b6a0d2fb", "src/libANGLE/capture/capture_gl_2_autogen.cpp": - "1906ffba0308dd5dd84a62a2eeb2b9f4", + "2fb35570619b2e7a2088e523d0017b15", "src/libANGLE/capture/capture_gl_2_autogen.h": "1e5b7623566fe1282567e3b31cddbee1", "src/libANGLE/capture/capture_gl_3_autogen.cpp": - "8bc0721889bc2e927e9c3b958219276d", + "257e0e9b36c2111165122799054b6277", "src/libANGLE/capture/capture_gl_3_autogen.h": "32e061964a2bccfc27dc95eb1a69558e", "src/libANGLE/capture/capture_gl_4_autogen.cpp": - "066de670a7d009a210b8067c9871cd1c", + "334403c06a9ae7b5a537ca762dfb32ff", "src/libANGLE/capture/capture_gl_4_autogen.h": - "1dad31a56d2779866afeb6559e7c1648", + "985366fe10b1e96e557a84d26769a042", "src/libANGLE/capture/capture_gles_1_0_autogen.cpp": - "7ec7ef8f779b809a45d74b97502c419b", + "2acd6c6ffcd2c8598793921dad8995f0", "src/libANGLE/capture/capture_gles_1_0_autogen.h": "141838b474dda3d9a6122e73d3621972", "src/libANGLE/capture/capture_gles_2_0_autogen.cpp": - "8d1c4534e00a4b373a409704e5d6a0c5", + "7e02010e01264c0c538c4f6caef7243b", "src/libANGLE/capture/capture_gles_2_0_autogen.h": - "5d5fb0985b28b67ed094e1a4dcc17211", + "73d813905e7e938cf11d1722f98de84b", "src/libANGLE/capture/capture_gles_3_0_autogen.cpp": - "c4fd6b2e604d8bb30953d5ba6021b683", + "124063a757419fa0246948e141312768", "src/libANGLE/capture/capture_gles_3_0_autogen.h": - "0f617befef65c1884072ec1244eca0ef", + "c5bff0201be9dc51fdb507a63dd9d8f8", "src/libANGLE/capture/capture_gles_3_1_autogen.cpp": - "22d19a77da41f82785cb7f580e39b3db", + "c94c8573246f3c281d3a4b68e8a3301a", "src/libANGLE/capture/capture_gles_3_1_autogen.h": - "d39d7cb1086dfeb870d0496c0d7cb79d", + "414b92fe8db95146d8af3c13830e3685", "src/libANGLE/capture/capture_gles_3_2_autogen.cpp": - "1b836129d15ec1f64241b6cfcda61785", + "1c8511a8acf5a58bded506939dad0fef", "src/libANGLE/capture/capture_gles_3_2_autogen.h": "74ed7366af3a46c0661397cfa29ec6fc", "src/libANGLE/capture/capture_gles_ext_autogen.cpp": - "d499679e0b866b158126975bc4316ae1", + "4586e267b78bc2b97f3b5aa33d9e5742", "src/libANGLE/capture/capture_gles_ext_autogen.h": - "8b520a438b11ac81d701adda917c57e2", + "8de2bc5804cd050286d0c7f8814d2179", "src/libANGLE/capture/frame_capture_replay_autogen.cpp": - "fff6fb40131a7208b406c416c6c02925", + "09fcd082294a40b8b253ff138570e291", "src/libANGLE/capture/frame_capture_utils_autogen.cpp": "90caecf105e7f7a500561d4c5447844b", "src/libANGLE/capture/frame_capture_utils_autogen.h": @@ -90,15 +90,15 @@ "src/libANGLE/validationES1_autogen.h": "99af5e328690ae78d7724a80e94cfac5", "src/libANGLE/validationES2_autogen.h": - "4a7a6baee242078fae637df6e2572370", + "b8d463545b6f53f3fd11f020e2dbaf02", "src/libANGLE/validationES31_autogen.h": - "401e678d5826eabf7dde4eb3350a8d94", + "38e169b05cafd2692466653579ae44e7", "src/libANGLE/validationES32_autogen.h": "d0c353bad157ce2297adaedb9ff3e003", "src/libANGLE/validationES3_autogen.h": - "0147506ce91c68d8ccbca9688c7251ba", + "d34affed6670d9748af70c9b2d9b6f05", "src/libANGLE/validationESEXT_autogen.h": - "859889cf0801517fe72cc801d91fdb44", + "64ec73f56e94433a48a017fc6f572310", "src/libANGLE/validationGL1_autogen.h": "a247dddc40418180d4b2dbefeb75f233", "src/libANGLE/validationGL2_autogen.h": @@ -106,7 +106,7 @@ "src/libANGLE/validationGL3_autogen.h": "d44457c3b3bc40fc7db904a4bb433966", "src/libANGLE/validationGL4_autogen.h": - "4ea886c218c2a44e11870e453f3c39a1", + "cd7ad03880470cae2fe26fc9b7902ce9", "src/libEGL/libEGL_autogen.cpp": "d2a4716a1e32416b64aa11da7294a2d1", "src/libEGL/libEGL_autogen.def": @@ -132,53 +132,53 @@ "src/libGLESv2/entry_points_egl_ext_autogen.h": "5ce03067f75c6179d47fe85186dff646", "src/libGLESv2/entry_points_gl_1_autogen.cpp": - "6f9b97ffc4803f7ea362bdd1e0e29d0d", + "d4a2563f39dce48c37c4f932d199195e", "src/libGLESv2/entry_points_gl_1_autogen.h": "fc92166806eac5dc285f6a3f06e89d2b", "src/libGLESv2/entry_points_gl_2_autogen.cpp": - "e5aa3ffc470dcc639b05281fdc3b2c99", + "1324273995aa4d95684785b3b6668efa", "src/libGLESv2/entry_points_gl_2_autogen.h": "ff42b86b47d77aeb902b6f0f5bd31758", "src/libGLESv2/entry_points_gl_3_autogen.cpp": - "90d557220dc7d881ae3945afce85f133", + "d2992cb519a509c85b5a2b228d03fd49", "src/libGLESv2/entry_points_gl_3_autogen.h": "88fcf08e2c1aa73819067f28c0fd1eba", "src/libGLESv2/entry_points_gl_4_autogen.cpp": - "2bfc063e1f89f13cf732d5effe4281f5", + "c300f696b690c765e5a5b70e51b7c903", "src/libGLESv2/entry_points_gl_4_autogen.h": - "a01cc6c3e945efa8f4425145bbcbda71", + "ec1171de9a494598d53bce149ba7b26d", "src/libGLESv2/entry_points_gles_1_0_autogen.cpp": - "f816e20a12df8d0f3b1799f4f1398ec5", + "1a7033d224dea6b0dfd0666047fddd3d", "src/libGLESv2/entry_points_gles_1_0_autogen.h": "1d3aef77845a416497070985a8e9cb31", "src/libGLESv2/entry_points_gles_2_0_autogen.cpp": - "de4ea22d8653b48fba0c5cb177432d95", + "5eaacc9ffbb54776e81d30dfda871b27", "src/libGLESv2/entry_points_gles_2_0_autogen.h": - "e682cd8f55110969f68d6a59573e0312", + "691c60c2dfed9beca68aa1f32aa2c71b", "src/libGLESv2/entry_points_gles_3_0_autogen.cpp": - "9ac4df03430b165f84769a7769c1a263", + "060c0ad4c7171d1007b30fbfb51efcab", "src/libGLESv2/entry_points_gles_3_0_autogen.h": - "3ae6c2e3e9791a9c7491c1181a46abab", + "4ac2582759cdc6a30f78f83ab684d555", "src/libGLESv2/entry_points_gles_3_1_autogen.cpp": - "1434aa933531a26251810a68f1588eaa", + "ab4e5ea455970bb6d37d22329e540b65", "src/libGLESv2/entry_points_gles_3_1_autogen.h": - "0cadd684407fad3e288654da30527f78", + "5395fdadfa95f8f56ae56014a9efcd87", "src/libGLESv2/entry_points_gles_3_2_autogen.cpp": - "2ad4b69d88c394d2a3d5101da0d1d349", + "b0ce94f8cd83420c2cce210b7ac855f9", "src/libGLESv2/entry_points_gles_3_2_autogen.h": "647f932a299cdb4726b60bbba059f0d2", "src/libGLESv2/entry_points_gles_ext_autogen.cpp": - "99c152ed061390debbf5f2f56627edab", + "c82ec987907b3d332db85c385a0406f0", "src/libGLESv2/entry_points_gles_ext_autogen.h": - "79bbb465ad4e817b64c31870bb543e42", + "be7be07ca4823ac7dd94935a0b34dbcf", "src/libGLESv2/libGLESv2_autogen.cpp": - "1a05253a6036ecdf45b03c41f249f11b", + "e2bf311fd087c19571159181bcdcd8ad", "src/libGLESv2/libGLESv2_autogen.def": - "ba1feb26c667f8ce089714a701daae59", + "0384357f4e1dd82b649d52b366febd3c", "src/libGLESv2/libGLESv2_no_capture_autogen.def": - "1f2feeb5d072d0a014c4acf44006a18f", + "00c6b2dad3ac4999655f963b6de65177", "src/libGLESv2/libGLESv2_with_capture_autogen.def": - "8f4c18f6815ec736f16bed0d5f1f3cad", + "963b86e39ae8bb8d02bf635a18fee8f5", "src/libOpenCL/libOpenCL_autogen.cpp": "10849978c910dc1af5dd4f0c815d1581", "third_party/EGL-Registry/src/api/egl.xml": @@ -188,5 +188,5 @@ "third_party/OpenGL-Registry/src/xml/glx.xml": "94f3eee4b076801d117804eb466714b7", "third_party/OpenGL-Registry/src/xml/wgl.xml": - "b674e6e4ae71067341985e93b410b5f1" + "eae784bf4d1b983a42af5671b140b7c4" } \ No newline at end of file diff --git a/scripts/code_generation_hashes/GLenum_value_to_string_map.json b/scripts/code_generation_hashes/GLenum_value_to_string_map.json index 83c4a3ef8..059f6f17e 100644 --- a/scripts/code_generation_hashes/GLenum_value_to_string_map.json +++ b/scripts/code_generation_hashes/GLenum_value_to_string_map.json @@ -1,14 +1,14 @@ { "scripts/gen_gl_enum_utils.py": - "332cfb6f04242d18966445f70f0039b3", - "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", + "ed3a9b835c9d5f386869a7c3a20671b2", "scripts/gl_angle_ext.xml": - "37eebedc1153cd9d208efa469a10a7b2", + "07ce630bceb8d419943bfc8064e247b3", "scripts/registry_xml.py": - "4d162936baeb7e803561559e11b7fd89", + "b1150b94db620646a38156213cbba402", "src/libANGLE/capture/gl_enum_utils_autogen.cpp": - "6e6b08183c720c9f5521df6fdc7f2b70", + "97399091c2f00cf512e35f8ec5d53d4d", "src/libANGLE/capture/gl_enum_utils_autogen.h": - "fbd6fa7daa2e4cd6cc71db769517cd8b" + "0d304614c954f9fb62bb4bf656951666", + "third_party/OpenGL-Registry/src/xml/gl.xml": + "17dca5504997d75c0ea66759be34a594" } \ No newline at end of file diff --git a/scripts/code_generation_hashes/OpenGL_dispatch_table.json b/scripts/code_generation_hashes/OpenGL_dispatch_table.json index ab0e4e8fc..a983b1f1f 100644 --- a/scripts/code_generation_hashes/OpenGL_dispatch_table.json +++ b/scripts/code_generation_hashes/OpenGL_dispatch_table.json @@ -1,18 +1,18 @@ { - "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", "src/libANGLE/renderer/angle_format.py": "2f8fa768088e22b0963bbdf842d3e725", "src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp": - "b338e9792ef7eaecec15efa718d5a5b1", + "a41b6954cf2e24ced156bc7c562f70dd", "src/libANGLE/renderer/gl/DispatchTableGL_autogen.h": "3115c293d6612d10498a1063b8cebe1a", "src/libANGLE/renderer/gl/generate_gl_dispatch_table.py": - "e2c1365b130039bc3ab8ddf45ad5dbc2", + "2fb7f3906b4966b192c629228bc3e961", "src/libANGLE/renderer/gl/gl_bindings_data.json": "6aa7c139ca0717d08e46bf86e1bf85a2", "src/libANGLE/renderer/gl/null_functions.cpp": - "684b33717a2ac64b1fa415acc33896f9", + "3b385088fba2411f4159cad33bb949ee", "src/libANGLE/renderer/gl/null_functions.h": - "19352d6beb033161490c4b37918acf17" + "e9d36d68a9dcb9ed8c855c3bd93b70e0", + "third_party/OpenGL-Registry/src/xml/gl.xml": + "17dca5504997d75c0ea66759be34a594" } \ No newline at end of file diff --git a/scripts/code_generation_hashes/proc_table.json b/scripts/code_generation_hashes/proc_table.json index b5c4ef5a9..e398b02c7 100644 --- a/scripts/code_generation_hashes/proc_table.json +++ b/scripts/code_generation_hashes/proc_table.json @@ -4,11 +4,11 @@ "scripts/gen_proc_table.py": "101d1ce8880be0c061c05c20420d92f5", "scripts/gl.xml": - "4fbb3be5950ac486b9da7c830dff0dfe", + "c79f59912f42e96ea958dddb5e029d47", "scripts/gl_angle_ext.xml": - "37eebedc1153cd9d208efa469a10a7b2", + "07ce630bceb8d419943bfc8064e247b3", "scripts/registry_xml.py": - "4d162936baeb7e803561559e11b7fd89", + "b1150b94db620646a38156213cbba402", "src/libGLESv2/proc_table_cl_autogen.cpp": "ed003b0f041aaaa35b67d3fe07e61f91", "src/libGLESv2/proc_table_egl_autogen.cpp": @@ -26,5 +26,5 @@ "third_party/OpenGL-Registry/src/xml/glx.xml": "94f3eee4b076801d117804eb466714b7", "third_party/OpenGL-Registry/src/xml/wgl.xml": - "b674e6e4ae71067341985e93b410b5f1" + "eae784bf4d1b983a42af5671b140b7c4" } \ No newline at end of file diff --git a/scripts/gen_gl_enum_utils.py b/scripts/gen_gl_enum_utils.py index f849a7252..e8c2304dc 100755 --- a/scripts/gen_gl_enum_utils.py +++ b/scripts/gen_gl_enum_utils.py @@ -28,7 +28,12 @@ template_gl_enums_header = """// GENERATED FILE - DO NOT EDIT. namespace gl {{ -enum class GLenumGroup +enum class GLESEnum +{{ + {gles_enum_groups} +}}; + +enum class BigGLEnum {{ {gl_enum_groups} }}; @@ -55,7 +60,7 @@ namespace gl {{ namespace {{ -const char *UnknownGLenumToString(unsigned int value) +const char *UnknownEnumToString(unsigned int value) {{ constexpr size_t kBufferSize = 64; static thread_local char sBuffer[kBufferSize]; @@ -64,41 +69,52 @@ const char *UnknownGLenumToString(unsigned int value) }} }} // anonymous namespace -const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) +const char *GLenumToString(GLESEnum enumGroup, unsigned int value) +{{ + switch (enumGroup) + {{ + {gles_enums_value_to_string_table} + default: + return UnknownEnumToString(value); + }} +}} + +const char *GLenumToString(BigGLEnum enumGroup, unsigned int value) {{ switch (enumGroup) {{ {gl_enums_value_to_string_table} default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); }} }} }} // namespace gl """ -template_enum_group_case = """case GLenumGroup::{group_name}: {{ +template_enum_group_case = """case {api_enum}::{group_name}: {{ switch (value) {{ {inner_group_cases} default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); }} }} """ template_enum_value_to_string_case = """case {value}: return {name};""" +exclude_enum_groups = {'SpecialNumbers'} -exclude_gl_enums = { - 'GL_NO_ERROR', 'GL_TIMEOUT_IGNORED', 'GL_INVALID_INDEX', 'GL_VERSION_ES_CL_1_0', - 'GL_VERSION_ES_CM_1_1', 'GL_VERSION_ES_CL_1_1' -} -exclude_gl_enum_groups = {'SpecialNumbers'} +# Special enum groups that don't have any enum values. +# Add groups here if you get missing group compile errors. +empty_enum_groups = ['SemaphoreParameterName', 'ShaderBinaryFormat'] -def dump_value_to_string_mapping(gl_enum_in_groups, exporting_enums): +def dump_value_to_string_mapping(enum_groups, api_enum): exporting_groups = list() - for group_name, inner_mapping in gl_enum_in_groups.items(): - string_value_pairs = list(filter(lambda x: x[0] in exporting_enums, inner_mapping.items())) + for group_name, inner_mapping in enum_groups.items(): + # Convert to pairs and strip out-of-range values. + string_value_pairs = list( + filter(lambda x: x[1] >= 0 and x[1] <= 0xFFFFFFFFF, inner_mapping.items())) if not string_value_pairs: continue @@ -127,6 +143,7 @@ def dump_value_to_string_mapping(gl_enum_in_groups, exporting_enums): return "\n".join([ template_enum_group_case.format( + api_enum=api_enum, group_name=group_name, inner_group_cases=inner_code_block, ) for group_name, inner_code_block in sorted(exporting_groups, key=lambda x: x[0]) @@ -136,70 +153,91 @@ def dump_value_to_string_mapping(gl_enum_in_groups, exporting_enums): def main(header_output_path, source_output_path): xml = registry_xml.RegistryXML('gl.xml', 'gl_angle_ext.xml') - # build a map from GLenum name to its value - all_gl_enums = dict() + # Compute a list of all GLES enums. + gles_enums = set() + bigl_enums = set() + for feature in xml.root.findall('feature'): + for require in feature.findall('require'): + assert 'api' not in require.attrib + if 'gles' in feature.attrib['api']: + for enum in require.findall('enum'): + gles_enums.add(enum.attrib['name']) + if feature.attrib['api'] == 'gl': + for enum in require.findall('enum'): + bigl_enums.add(enum.attrib['name']) + + for extensions in xml.root.findall('extensions'): + for extension in extensions.findall('extension'): + if extension.attrib['name'] in registry_xml.supported_extensions: + for require in extension.findall('require'): + ext_apis = extension.attrib['supported'].split('|') + if ('api' not in require.attrib or 'gles' in require.attrib['api']) and ( + 'gles' in extension.attrib['supported']): + for enum in require.findall('enum'): + gles_enums.add(enum.attrib['name']) + if ('api' not in require.attrib or + feature.attrib['api'] == 'gl') and ('gl' in ext_apis): + for enum in require.findall('enum'): + bigl_enums.add(enum.attrib['name']) + + # Build a map from GLenum name to its value + gl_enum_groups = dict() + gles_enum_groups = dict() + + # Add all enums to default groups + gl_default_enums = dict() + gles_default_enums = dict() + gl_enum_groups[registry_xml.default_enum_group_name] = gl_default_enums + gles_enum_groups[registry_xml.default_enum_group_name] = gles_default_enums + for enums_node in xml.root.findall('enums'): for enum in enums_node.findall('enum'): - name = enum.attrib['name'] - value = int(enum.attrib['value'], base=16) - all_gl_enums[name] = value + enum_name = enum.attrib['name'] + enum_value = int(enum.attrib['value'], base=16) - # Parse groups of GLenums to build a {group, name} -> value mapping. - gl_enum_in_groups = dict() - enums_has_group = set() - for enums_group_node in xml.root.findall('groups/group'): - group_name = enums_group_node.attrib['name'] - if group_name in exclude_gl_enum_groups: - continue + if enum_name in gles_enums: + gles_default_enums[enum_name] = enum_value + if enum_name in bigl_enums: + gl_default_enums[enum_name] = enum_value - if group_name not in gl_enum_in_groups: - gl_enum_in_groups[group_name] = dict() + if 'group' in enum.attrib: + for enum_group in enum.attrib['group'].split(','): + if enum_group in exclude_enum_groups: + continue + if enum_name in gles_enums: + if enum_group not in gles_enum_groups: + gles_enum_groups[enum_group] = dict() + gles_enum_groups[enum_group][enum_name] = enum_value + if enum_name in bigl_enums: + if enum_group not in gl_enum_groups: + gl_enum_groups[enum_group] = dict() + gl_enum_groups[enum_group][enum_name] = enum_value - for enum_node in enums_group_node.findall('enum'): - enum_name = enum_node.attrib['name'] - enums_has_group.add(enum_name) - gl_enum_in_groups[group_name][enum_name] = all_gl_enums[enum_name] - - # Find relevant GLenums according to enabled APIs and extensions. - exporting_enums = set() - # export all the apis - xpath = "./feature[@api='gles2']/require/enum" - for enum_tag in xml.root.findall(xpath): - enum_name = enum_tag.attrib['name'] - if enum_name not in exclude_gl_enums: - exporting_enums.add(enum_name) - - for extension in registry_xml.supported_extensions: - xpath = "./extensions/extension[@name='%s']/require/enum" % extension - for enum_tag in xml.root.findall(xpath): - enum_name = enum_tag.attrib['name'] - if enum_name not in exclude_gl_enums: - exporting_enums.add(enum_name) - - # For enums that do not have a group, add them to a default group - default_group_name = registry_xml.default_enum_group_name - gl_enum_in_groups[default_group_name] = dict() - default_group = gl_enum_in_groups[default_group_name] - for enum_name in exporting_enums: - if enum_name not in enums_has_group: - default_group[enum_name] = all_gl_enums[enum_name] + for empty_group in empty_enum_groups: + assert not empty_group in gles_enum_groups or not empty_group in gl_enum_groups, 'Remove %s from the empty groups list, it has enums now.' % empty_group + if empty_group not in gles_enum_groups: + gles_enum_groups[empty_group] = dict() + if empty_group not in gl_enum_groups: + gl_enum_groups[empty_group] = dict() # Write GLenum groups into the header file. header_content = template_gl_enums_header.format( script_name=os.path.basename(sys.argv[0]), data_source_name="gl.xml and gl_angle_ext.xml", - gl_enum_groups=',\n'.join(sorted(gl_enum_in_groups.keys()))) + gles_enum_groups=',\n'.join(sorted(gles_enum_groups.keys())), + gl_enum_groups=',\n'.join(sorted(gl_enum_groups.keys()))) header_output_path = registry_xml.script_relative(header_output_path) with open(header_output_path, 'w') as f: f.write(header_content) # Write mapping to source file - gl_enums_value_to_string_table = dump_value_to_string_mapping(gl_enum_in_groups, - exporting_enums) + gles_enums_value_to_string_table = dump_value_to_string_mapping(gles_enum_groups, 'GLESEnum') + gl_enums_value_to_string_table = dump_value_to_string_mapping(gl_enum_groups, 'BigGLEnum') source_content = template_gl_enums_source.format( script_name=os.path.basename(sys.argv[0]), data_source_name="gl.xml and gl_angle_ext.xml", + gles_enums_value_to_string_table=gles_enums_value_to_string_table, gl_enums_value_to_string_table=gl_enums_value_to_string_table, ) @@ -212,7 +250,7 @@ def main(header_output_path, source_output_path): if __name__ == '__main__': inputs = [ - 'gl.xml', + '../third_party/OpenGL-Registry/src/xml/gl.xml', 'gl_angle_ext.xml', 'registry_xml.py', ] diff --git a/scripts/generate_entry_points.py b/scripts/generate_entry_points.py index d835dc88e..e05893d89 100755 --- a/scripts/generate_entry_points.py +++ b/scripts/generate_entry_points.py @@ -10,7 +10,7 @@ import sys, os, pprint, json import registry_xml -from registry_xml import apis, script_relative, strip_api_prefix +from registry_xml import apis, script_relative, strip_api_prefix, api_enums # Paths CL_STUBS_HEADER_PATH = "../src/libGLESv2/cl_stubs_autogen.h" @@ -597,7 +597,7 @@ CallCapture Capture{short_name}({params_with_type}) TEMPLATE_PARAMETER_CAPTURE_VALUE = """paramBuffer.addValueParam("{name}", ParamType::T{type}, {name});""" -TEMPLATE_PARAMETER_CAPTURE_GL_ENUM = """paramBuffer.addEnumParam("{name}", GLenumGroup::{group}, ParamType::T{type}, {name});""" +TEMPLATE_PARAMETER_CAPTURE_GL_ENUM = """paramBuffer.addEnumParam("{name}", {api_enum}::{group}, ParamType::T{type}, {name});""" TEMPLATE_PARAMETER_CAPTURE_POINTER = """ if (isCallValid) @@ -1389,7 +1389,7 @@ def is_unsigned_long_format(fmt): return fmt == UNSIGNED_LONG_LONG_FORMAT or fmt == HEX_LONG_LONG_FORMAT -def param_print_argument(command_node, param): +def param_print_argument(api, command_node, param): name_only = just_the_name(param) type_only = just_the_type(param) @@ -1409,11 +1409,11 @@ def param_print_argument(command_node, param): if type_only == "GLbitfield": group_name = find_gl_enum_group_in_command(command_node, name_only) - return "GLbitfieldToString(GLenumGroup::%s, %s).c_str()" % (group_name, name_only) + return "GLbitfieldToString(%s::%s, %s).c_str()" % (api_enums[api], group_name, name_only) if type_only == "GLenum": group_name = find_gl_enum_group_in_command(command_node, name_only) - return "GLenumToString(GLenumGroup::%s, %s)" % (group_name, name_only) + return "GLenumToString(%s::%s, %s)" % (api_enums[api], group_name, name_only) return name_only @@ -1553,7 +1553,7 @@ def format_entry_point_def(api, command_node, cmd_name, proto, params, cmd_packe internal_type + ">(" + name + ");" ] - pass_params = [param_print_argument(command_node, param) for param in params] + pass_params = [param_print_argument(api, command_node, param) for param in params] format_params = [param_format_string(param) for param in params] return_type = proto[:-len(cmd_name)].strip() initialization = "InitBackEnds(%s);\n" % INIT_DICT[cmd_name] if cmd_name in INIT_DICT else "" @@ -1673,7 +1673,10 @@ def format_capture_method(api, command, cmd_name, proto, params, all_param_types elif capture_param_type in ('GLenum', 'GLbitfield'): gl_enum_group = find_gl_enum_group_in_command(command, param_name) capture = TEMPLATE_PARAMETER_CAPTURE_GL_ENUM.format( - name=param_name, type=capture_param_type, group=gl_enum_group) + name=param_name, + type=capture_param_type, + api_enum=api_enums[api], + group=gl_enum_group) else: capture = TEMPLATE_PARAMETER_CAPTURE_VALUE.format( name=param_name, type=capture_param_type) diff --git a/scripts/gl.xml b/scripts/gl.xml index bfb74cd17..814402b09 100644 --- a/scripts/gl.xml +++ b/scripts/gl.xml @@ -1,86 +1,35 @@ -Copyright (c) 2013-2018 The Khronos Group Inc. - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. - ------------------------------------------------------------------------- +Copyright 2013-2020 The Khronos Group Inc. +SPDX-License-Identifier: Apache-2.0 This file, gl.xml, is the OpenGL and OpenGL API Registry. The canonical version of the registry, together with documentation, schema, and Python generator scripts used to generate C header files for OpenGL and OpenGL ES, can always be found in the Khronos Registry at - https://github.com/KhronosGroup/OpenGL-Registry +https://github.com/KhronosGroup/OpenGL-Registry - #include <stddef.h> #include <KHR/khrplatform.h> - #ifndef GLEXT_64_TYPES_DEFINED -/* This code block is duplicated in glxext.h, so must be protected */ -#define GLEXT_64_TYPES_DEFINED -/* Define int32_t, int64_t, and uint64_t types for UST/MSC */ -/* (as used in the GL_EXT_timer_query extension). */ -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L -#include <inttypes.h> -#elif defined(__sun__) || defined(__digital__) -#include <inttypes.h> -#if defined(__STDC__) -#if defined(__arch64__) || defined(_LP64) -typedef long int int64_t; -typedef unsigned long int uint64_t; -#else -typedef long long int int64_t; -typedef unsigned long long int uint64_t; -#endif /* __arch64__ */ -#endif /* __STDC__ */ -#elif defined( __VMS ) || defined(__sgi) -#include <inttypes.h> -#elif defined(__SCO__) || defined(__USLC__) -#include <stdint.h> -#elif defined(__UNIXOS2__) || defined(__SOL64__) -typedef long int int32_t; -typedef long long int int64_t; -typedef unsigned long long int uint64_t; -#elif defined(_WIN32) && defined(__GNUC__) -#include <stdint.h> -#elif defined(_WIN32) -typedef __int32 int32_t; -typedef __int64 int64_t; -typedef unsigned __int64 uint64_t; -#else -/* Fallback if nothing above works */ -#include <inttypes.h> -#endif -#endif typedef unsigned int GLenum; typedef unsigned char GLboolean; typedef unsigned int GLbitfield; typedef void GLvoid; - typedef signed char GLbyte; - typedef short GLshort; + typedef khronos_int8_t GLbyte; + typedef khronos_uint8_t GLubyte; + typedef khronos_int16_t GLshort; + typedef khronos_uint16_t GLushort; typedef int GLint; - typedef int GLclampx; - typedef unsigned char GLubyte; - typedef unsigned short GLushort; typedef unsigned int GLuint; + typedef khronos_int32_t GLclampx; typedef int GLsizei; - typedef float GLfloat; - typedef float GLclampf; + typedef khronos_float_t GLfloat; + typedef khronos_float_t GLclampf; typedef double GLdouble; typedef double GLclampd; typedef void *GLeglClientBufferEXT; @@ -92,53 +41,24 @@ typedef void *GLhandleARB; #else typedef unsigned int GLhandleARB; #endif - typedef unsigned short GLhalfARB; - typedef unsigned short GLhalf; - typedef GLint GLfixed; + typedef khronos_uint16_t GLhalf; + typedef khronos_uint16_t GLhalfARB; + typedef khronos_int32_t GLfixed; typedef khronos_intptr_t GLintptr; + typedef khronos_intptr_t GLintptrARB; typedef khronos_ssize_t GLsizeiptr; - typedef int64_t GLint64; - typedef uint64_t GLuint64; - typedef ptrdiff_t GLintptrARB; - typedef ptrdiff_t GLsizeiptrARB; - typedef int64_t GLint64EXT; - typedef uint64_t GLuint64EXT; + typedef khronos_ssize_t GLsizeiptrARB; + typedef khronos_int64_t GLint64; + typedef khronos_int64_t GLint64EXT; + typedef khronos_uint64_t GLuint64; + typedef khronos_uint64_t GLuint64EXT; typedef struct __GLsync *GLsync; struct _cl_context; struct _cl_event; typedef void ( *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); typedef void ( *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); typedef void ( *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); - - typedef khronos_int32_t GLclampx; - - typedef khronos_int8_t GLbyte; - typedef khronos_uint8_t GLubyte; - typedef khronos_float_t GLfloat; - typedef khronos_float_t GLclampf; - typedef khronos_int32_t GLfixed; - typedef khronos_int64_t GLint64; - typedef khronos_uint64_t GLuint64; - typedef khronos_intptr_t GLintptr; - typedef khronos_ssize_t GLsizeiptr; - - typedef khronos_int8_t GLbyte; - typedef khronos_uint8_t GLubyte; - typedef khronos_float_t GLfloat; - typedef khronos_float_t GLclampf; - typedef khronos_int32_t GLfixed; - typedef khronos_int64_t GLint64; - typedef khronos_uint64_t GLuint64; - typedef khronos_int64_t GLint64EXT; - typedef khronos_uint64_t GLuint64EXT; - typedef khronos_intptr_t GLintptr; - typedef khronos_ssize_t GLsizeiptr; - - - typedef khronos_uint8_t GLubyte; - typedef khronos_float_t GLfloat; - typedef khronos_intptr_t GLintptr; - typedef khronos_ssize_t GLsizeiptr; + typedef void ( *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); typedef unsigned short GLhalfNV; @@ -146,3686 +66,315 @@ typedef unsigned int GLhandleARB; typedef void ( *GLVULKANPROCNV)(void); - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + - + - - - + + + - - - - - - - - + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - + + + - - - - - - - + + + + + + + - - - + + + - - - - - - - + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + - - + + @@ -3833,96 +382,96 @@ typedef unsigned int GLhandleARB; used for indexed access. --> - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + - - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + - - - - - + + + + + - - - + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - - + + + + + - - - + + + - - - + + + - - - + + + - - + + - - - - - + + + + + - - - - - - - - + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - + + + + - + - - - - + + + + - - - - - + + + + + - - - - - - - - + + + + + + + + - - + + - - + + - - - + + + - - - - - - - - - - + + + + + + + + + + - - - - - - + + + + + + - - - - - - - - - + + + + + + + + + - - - - + + + + - + - - - - - - + + + + + + - - - - - - - - + + + + + + + + - - - - - - - + + + + + + + - - - - - + + + + + - + - - - - - - - - - + + + + + + + + + - - - - - + + + + + - + - - - + + + - + - + - - + + - - - - - - + + + + + + - + - - - + + + - - - - + + + + - - - - - - + + + + + + - - + + - - - - + + + + - - - - + + + + - + - - - - - + + + + + - - - - + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - - - + + + + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - - + + + - + - - - - + + + + - - + + - - - + + + - - - - - - - - - - - - + + + + + + + + + + + + - + - + - - - - - - - - - + + + + + + + + + - - - - - - - - - + + + + + + + + + - - - - + + + + - - + + - - - - - + + + + + - - - - - + + + + + - + - + - - - + + + - - - - - - - - - - + + + + + + + + + + - - + + - - - - - - - - + + + + + + + + - + - + - - - + + + - + - - - - + + + + - - - - - - - + + + + + + + - - - - - - - - - + + + + + + + + + - - - - + + + + - + - + - + - + - - - - - - + + + + + + - - - - - - + + + + + + - + - + - - - - - + + + + + - + - + - + - - + + - - - + + + - - + + - - - - + + + + - - - - + + + + - - - - + + + + - - + + - - + + - + - + - + - + - - - - + + + + - - + + - - - - + + + + - - - - + + + + - - + + - - + + - + - + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - - - - - - - + + + + + + + + @@ -4589,410 +1138,410 @@ typedef unsigned int GLhandleARB; - - + + - + - + - + - - - - + + + + - - - - - - - - + + + + + + + + - - + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - - - - - - - - - + + + + + + + + + - + - - + + - + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - + + + + + + - + - + - + - + - + - + - + - + - + - - + + - + - - + + - + - + - - + + - + - - + + - + - + - - + + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + - - + + - - + + - - + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + - - + + - - + + - - + + - + - - - - - + + + + + - + - + - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + - + - + - + - + @@ -5002,156 +1551,156 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - + @@ -5161,21 +1710,21 @@ typedef unsigned int GLhandleARB; - + - - - - - - - - - - + + + + + + + + + + - + @@ -5188,55 +1737,54 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + - - - - - - + + + + + + @@ -5245,23 +1793,23 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - + + + + + + + + + + + + - - + + @@ -5276,8 +1824,8 @@ typedef unsigned int GLhandleARB; - - + + @@ -5335,21 +1883,21 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + @@ -5359,138 +1907,138 @@ typedef unsigned int GLhandleARB; - + - - - - - - - - - - + + + + + + + + + + - + - - - - - - + + + + + + - + - - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -5498,28 +2046,28 @@ typedef unsigned int GLhandleARB; - - + + - + - + - + - + - + - + - + @@ -5531,99 +2079,99 @@ typedef unsigned int GLhandleARB; - - - - - - + + + + + + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - - + + + + + + @@ -5653,13 +2201,13 @@ typedef unsigned int GLhandleARB; - - - - - - - + + + + + + + @@ -5673,37 +2221,37 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + - + - + - + - + - + @@ -5739,7 +2287,7 @@ typedef unsigned int GLhandleARB; - + @@ -5750,9 +2298,9 @@ typedef unsigned int GLhandleARB; - - - + + + @@ -5760,22 +2308,22 @@ typedef unsigned int GLhandleARB; - + - - - + + + - - - - + + + + @@ -5795,21 +2343,21 @@ typedef unsigned int GLhandleARB; - - + + - - - + + + - - - + + + @@ -5817,31 +2365,31 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + @@ -5858,7 +2406,7 @@ typedef unsigned int GLhandleARB; conflicts. They have never reported using any values in this range. Lesson: assigned ranges belong to vendors, not engineers! --> - + @@ -5904,19 +2452,19 @@ typedef unsigned int GLhandleARB; - - + + - - - - - - + + + + + + @@ -5932,33 +2480,33 @@ typedef unsigned int GLhandleARB; - - - - - - + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - + + + - - + + @@ -6001,18 +2549,18 @@ typedef unsigned int GLhandleARB; - - - + + + - - - - - - + + + + + + @@ -6058,8 +2606,8 @@ typedef unsigned int GLhandleARB; - - + + @@ -6078,71 +2626,71 @@ typedef unsigned int GLhandleARB; - - - - - + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -6160,7 +2708,7 @@ typedef unsigned int GLhandleARB; - + @@ -6171,60 +2719,60 @@ typedef unsigned int GLhandleARB; - + - + - - + + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + - - - - + + + + - + - + - + - + - + @@ -6236,99 +2784,99 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - - - - - - - + + + + + + + - - - - - + + + + + - + - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + @@ -6340,14 +2888,14 @@ typedef unsigned int GLhandleARB; - - - - - - - - + + + + + + + + @@ -6372,94 +2920,94 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - + + + + + + + + + + + + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - + + + + + @@ -6470,17 +3018,17 @@ typedef unsigned int GLhandleARB; - + - + - - + + @@ -6492,10 +3040,10 @@ typedef unsigned int GLhandleARB; - + - - + + @@ -6563,26 +3111,26 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + @@ -6617,16 +3165,16 @@ typedef unsigned int GLhandleARB; - + - + - - + + @@ -6637,8 +3185,9 @@ typedef unsigned int GLhandleARB; - + + @@ -6697,11 +3246,11 @@ typedef unsigned int GLhandleARB; - + - + - + @@ -6736,11 +3285,11 @@ typedef unsigned int GLhandleARB; - - - - - + + + + + @@ -6876,7 +3425,7 @@ typedef unsigned int GLhandleARB; - + @@ -6890,12 +3439,12 @@ typedef unsigned int GLhandleARB; - + - + @@ -6917,35 +3466,35 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - + + + + + + + + + + - - - - - - - - + + + + + + + + - - - - + + + + @@ -6953,30 +3502,30 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + @@ -7013,13 +3562,13 @@ typedef unsigned int GLhandleARB; - - - - - - - + + + + + + + @@ -7036,26 +3585,26 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -7064,9 +3613,9 @@ typedef unsigned int GLhandleARB; - - - + + + @@ -7076,19 +3625,19 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + @@ -7102,14 +3651,14 @@ typedef unsigned int GLhandleARB; - - - + + + - - - + + + @@ -7127,14 +3676,14 @@ typedef unsigned int GLhandleARB; - - - + + + - - - + + + @@ -7157,7 +3706,7 @@ typedef unsigned int GLhandleARB; - + @@ -7246,7 +3795,7 @@ typedef unsigned int GLhandleARB; - + @@ -7276,18 +3825,18 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + @@ -7318,25 +3867,25 @@ typedef unsigned int GLhandleARB; - + - + - - + + - - + + - + - + @@ -7351,17 +3900,17 @@ typedef unsigned int GLhandleARB; - + - + - - + + @@ -7388,13 +3937,13 @@ typedef unsigned int GLhandleARB; - + - + - + - + @@ -7416,7 +3965,7 @@ typedef unsigned int GLhandleARB; - + @@ -7442,24 +3991,24 @@ typedef unsigned int GLhandleARB; - + - + - + - - + + - - + + - - + + - + @@ -7493,46 +4042,46 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + - + - + - + - + - + - + - - - + + + @@ -7542,28 +4091,28 @@ typedef unsigned int GLhandleARB; - + - + - + - + - - + + - + - + - + - + @@ -7574,109 +4123,109 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - - - - - - - + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -7685,10 +4234,10 @@ typedef unsigned int GLhandleARB; - - - - + + + + @@ -7699,8 +4248,8 @@ typedef unsigned int GLhandleARB; - - + + @@ -7732,15 +4281,15 @@ typedef unsigned int GLhandleARB; - - + + - + @@ -7755,41 +4304,41 @@ typedef unsigned int GLhandleARB; - - - - - + + + + + - - - - - - + + + + + + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -7816,128 +4365,128 @@ typedef unsigned int GLhandleARB; - - - - + + + + - - + + - + - + - - + + - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - - - - + + + + - + @@ -7953,9 +4502,9 @@ typedef unsigned int GLhandleARB; - + - + @@ -7980,6 +4529,8 @@ typedef unsigned int GLhandleARB; + + @@ -8024,7 +4575,7 @@ typedef unsigned int GLhandleARB; - + @@ -8046,38 +4597,38 @@ typedef unsigned int GLhandleARB; - + - - - + + + - - - + + + - + - + - + - + - + - + @@ -8087,40 +4638,40 @@ typedef unsigned int GLhandleARB; - + - + - - - - + + + + - - - + + + - - - - - - - - - + + + + + + + + + @@ -8133,22 +4684,22 @@ typedef unsigned int GLhandleARB; - + - + - - - - - - - - + + + + + + + + @@ -8156,7 +4707,7 @@ typedef unsigned int GLhandleARB; - + @@ -8166,7 +4717,7 @@ typedef unsigned int GLhandleARB; - + @@ -8174,24 +4725,24 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + @@ -8200,36 +4751,37 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + + - + - + - - - - + + + + @@ -8238,33 +4790,33 @@ typedef unsigned int GLhandleARB; - + - + - + - + - - - - - - - - + + + + + + + + @@ -8273,29 +4825,29 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + - + - + @@ -8305,140 +4857,140 @@ typedef unsigned int GLhandleARB; - + - + - + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - + + + - + - - + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - - + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + @@ -8452,93 +5004,93 @@ typedef unsigned int GLhandleARB; - + - - + + - + - - + + - - + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - + - + - + - + - + @@ -8546,11 +5098,11 @@ typedef unsigned int GLhandleARB; - - - - - + + + + + @@ -8558,80 +5110,80 @@ typedef unsigned int GLhandleARB; - - + + - + - - - - - - - - - + + + + + + + + + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + @@ -8645,7 +5197,7 @@ typedef unsigned int GLhandleARB; - + @@ -8660,8 +5212,8 @@ typedef unsigned int GLhandleARB; - - + + @@ -8673,39 +5225,39 @@ typedef unsigned int GLhandleARB; - - - - - - + + + + + + - - - - - - + + + + + + - + - + - + - + - + - - - - + + + + @@ -8717,21 +5269,21 @@ typedef unsigned int GLhandleARB; - + - + - + - - + + @@ -8740,36 +5292,36 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - - - - - + + + + + - + - + - + - + - + - + @@ -8779,7 +5331,7 @@ typedef unsigned int GLhandleARB; - + @@ -8800,15 +5352,30 @@ typedef unsigned int GLhandleARB; - + + + + + + + + + + + + + + + + - + - + - + @@ -8864,31 +5431,31 @@ typedef unsigned int GLhandleARB; - + - + - + - + - - - - - - - - - - - - + + + + + + + + + + + + @@ -8896,7 +5463,10 @@ typedef unsigned int GLhandleARB; - + + + + @@ -8949,10 +5519,10 @@ typedef unsigned int GLhandleARB; - + - + @@ -8970,30 +5540,30 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + - + - + - + @@ -9003,17 +5573,20 @@ typedef unsigned int GLhandleARB; - + - - + + - + + + + @@ -9029,41 +5602,42 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - + + + + + + + + + + + + - - + + - - + + + - - + + - + @@ -9075,11 +5649,11 @@ typedef unsigned int GLhandleARB; - + - + - + @@ -9089,21 +5663,21 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + @@ -9117,29 +5691,29 @@ typedef unsigned int GLhandleARB; - - - - + + + + - - - + + + - + - + - + @@ -9199,152 +5773,152 @@ typedef unsigned int GLhandleARB; - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - + - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + - - - - - - + + + + + + - + - + - + - - - - - - - - - + + + + + + + + + - - + + - - - + + + - + @@ -9352,12 +5926,12 @@ typedef unsigned int GLhandleARB; - + - + @@ -9374,36 +5948,36 @@ typedef unsigned int GLhandleARB; - - - - - - + + + + + + - + - + - - - - + + + + - + - - + + - - - - + + + + @@ -9411,72 +5985,72 @@ typedef unsigned int GLhandleARB; - + - - - + + + - - - + + + - - - - + + + + - + - + - - - - + + + + - + - + - + - + - + - + - + - + - + - - - - - + + + + + - + - - + + @@ -9492,7 +6066,7 @@ typedef unsigned int GLhandleARB; - + @@ -9504,7 +6078,7 @@ typedef unsigned int GLhandleARB; - + @@ -9521,15 +6095,15 @@ typedef unsigned int GLhandleARB; - + - + - + @@ -9552,11 +6126,11 @@ typedef unsigned int GLhandleARB; - + - + @@ -9584,7 +6158,7 @@ typedef unsigned int GLhandleARB; - + @@ -9608,14 +6182,20 @@ typedef unsigned int GLhandleARB; - - + + + + + + + + - - + + - - + + @@ -9640,7 +6220,7 @@ typedef unsigned int GLhandleARB; - + @@ -9648,31 +6228,31 @@ typedef unsigned int GLhandleARB; - + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -9769,18 +6349,18 @@ typedef unsigned int GLhandleARB; - - + + - - - - - - - - + + + + + + + + @@ -9793,97 +6373,97 @@ typedef unsigned int GLhandleARB; - - + + - + - + - - + + - - - + + + - - + + - - - - - - - + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + - - - - - - + + + + + + - - - + + + - - - - - + + + + + - + @@ -9911,7 +6491,7 @@ typedef unsigned int GLhandleARB; - + @@ -9923,9 +6503,9 @@ typedef unsigned int GLhandleARB; - - - + + + @@ -9945,12 +6525,12 @@ typedef unsigned int GLhandleARB; - + - + - + @@ -9975,16 +6555,45 @@ typedef unsigned int GLhandleARB; - + - + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -9999,85 +6608,85 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + @@ -10112,68 +6721,140 @@ typedef unsigned int GLhandleARB; - - - + + + + + + + + + + + + + + + + - + - + + - + - + + + - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + - + @@ -10195,22 +6876,80 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + @@ -10257,30 +6996,30 @@ typedef unsigned int GLhandleARB; - - - + + + - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + @@ -10300,17 +7039,17 @@ typedef unsigned int GLhandleARB; void glActiveProgramEXT - GLuint program + GLuint program void glActiveShaderProgram - GLuint pipeline - GLuint program + GLuint pipeline + GLuint program void glActiveShaderProgramEXT - GLuint pipeline - GLuint program + GLuint pipeline + GLuint program void glActiveStencilFaceEXT @@ -10330,44 +7069,44 @@ typedef unsigned int GLhandleARB; void glActiveVaryingNV - GLuint program + GLuint program const GLchar *name void glAlphaFragmentOp1ATI - GLenum op - GLuint dst - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod void glAlphaFragmentOp2ATI - GLenum op - GLuint dst - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod - GLuint arg2 - GLuint arg2Rep - GLuint arg2Mod + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod void glAlphaFragmentOp3ATI - GLenum op - GLuint dst - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod - GLuint arg2 - GLuint arg2Rep - GLuint arg2Mod - GLuint arg3 - GLuint arg3Rep - GLuint arg3Mod + GLenum op + GLuint dst + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + GLuint arg3 + GLuint arg3Rep + GLuint arg3Mod void glAlphaFunc @@ -10402,7 +7141,7 @@ typedef unsigned int GLhandleARB; GLenum mode - GLboolean glAcquireKeyedMutexWin32EXT + GLboolean glAcquireKeyedMutexWin32EXT GLuint memory GLuint64 key GLuint timeout @@ -10410,21 +7149,21 @@ typedef unsigned int GLhandleARB; GLboolean glAreProgramsResidentNV GLsizei n - const GLuint *programs + const GLuint *programs GLboolean *residences GLboolean glAreTexturesResident GLsizei n - const GLuint *textures + const GLuint *textures GLboolean *residences GLboolean glAreTexturesResidentEXT GLsizei n - const GLuint *textures + const GLuint *textures GLboolean *residences @@ -10443,9 +7182,51 @@ typedef unsigned int GLhandleARB; GLint size GLenum type GLsizei stride - GLuint buffer + GLuint buffer GLuint offset + + GLuint glAsyncCopyBufferSubDataNVX + GLsizei waitSemaphoreCount + const GLuint *waitSemaphoreArray + const GLuint64 *fenceValueArray + GLuint readGpu + GLbitfield writeGpuMask + GLuint readBuffer + GLuint writeBuffer + GLintptr readOffset + GLintptr writeOffset + GLsizeiptr size + GLsizei signalSemaphoreCount + const GLuint *signalSemaphoreArray + const GLuint64 *signalValueArray + + + GLuint glAsyncCopyImageSubDataNVX + GLsizei waitSemaphoreCount + const GLuint *waitSemaphoreArray + const GLuint64 *waitValueArray + GLuint srcGpu + GLbitfield dstGpuMask + GLuint srcName + GLenum srcTarget + GLint srcLevel + GLint srcX + GLint srcY + GLint srcZ + GLuint dstName + GLenum dstTarget + GLint dstLevel + GLint dstX + GLint dstY + GLint dstZ + GLsizei srcWidth + GLsizei srcHeight + GLsizei srcDepth + GLsizei signalSemaphoreCount + const GLuint *signalSemaphoreArray + const GLuint64 *signalValueArray + void glAsyncMarkerSGIX GLuint marker @@ -10458,8 +7239,8 @@ typedef unsigned int GLhandleARB; void glAttachShader - GLuint program - GLuint shader + GLuint program + GLuint shader void glBegin @@ -10469,12 +7250,12 @@ typedef unsigned int GLhandleARB; void glBeginConditionalRender GLuint id - GLenum mode + GLenum mode void glBeginConditionalRenderNV GLuint id - GLenum mode + GLenum mode @@ -10500,25 +7281,25 @@ typedef unsigned int GLhandleARB; void glBeginQuery GLenum target - GLuint id + GLuint id void glBeginQueryARB - GLenum target - GLuint id + GLenum target + GLuint id void glBeginQueryEXT GLenum target - GLuint id + GLuint id void glBeginQueryIndexed GLenum target GLuint index - GLuint id + GLuint id void glBeginTransformFeedback @@ -10544,7 +7325,7 @@ typedef unsigned int GLhandleARB; void glBindAttribLocation - GLuint program + GLuint program GLuint index const GLchar *name @@ -10558,47 +7339,47 @@ typedef unsigned int GLhandleARB; void glBindBuffer GLenum target - GLuint buffer + GLuint buffer void glBindBufferARB GLenum target - GLuint buffer + GLuint buffer void glBindBufferBase GLenum target GLuint index - GLuint buffer + GLuint buffer void glBindBufferBaseEXT GLenum target GLuint index - GLuint buffer + GLuint buffer void glBindBufferBaseNV GLenum target GLuint index - GLuint buffer + GLuint buffer void glBindBufferOffsetEXT GLenum target GLuint index - GLuint buffer + GLuint buffer GLintptr offset void glBindBufferOffsetNV GLenum target GLuint index - GLuint buffer + GLuint buffer GLintptr offset @@ -10606,7 +7387,7 @@ typedef unsigned int GLhandleARB; void glBindBufferRange GLenum target GLuint index - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size @@ -10615,7 +7396,7 @@ typedef unsigned int GLhandleARB; void glBindBufferRangeEXT GLenum target GLuint index - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size @@ -10624,7 +7405,7 @@ typedef unsigned int GLhandleARB; void glBindBufferRangeNV GLenum target GLuint index - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size @@ -10634,40 +7415,40 @@ typedef unsigned int GLhandleARB; GLenum target GLuint first GLsizei count - const GLuint *buffers + const GLuint *buffers void glBindBuffersRange GLenum target GLuint first GLsizei count - const GLuint *buffers + const GLuint *buffers const GLintptr *offsets const GLsizeiptr *sizes void glBindFragDataLocation - GLuint program + GLuint program GLuint color const GLchar *name void glBindFragDataLocationEXT - GLuint program + GLuint program GLuint color const GLchar *name void glBindFragDataLocationIndexed - GLuint program + GLuint program GLuint colorNumber GLuint index const GLchar *name void glBindFragDataLocationIndexedEXT - GLuint program + GLuint program GLuint colorNumber GLuint index const GLchar *name @@ -10680,24 +7461,24 @@ typedef unsigned int GLhandleARB; void glBindFramebuffer GLenum target - GLuint framebuffer + GLuint framebuffer void glBindFramebufferEXT GLenum target - GLuint framebuffer + GLuint framebuffer void glBindFramebufferOES GLenum target - GLuint framebuffer + GLuint framebuffer void glBindImageTexture GLuint unit - GLuint texture + GLuint texture GLint level GLboolean layered GLint layer @@ -10707,7 +7488,7 @@ typedef unsigned int GLhandleARB; void glBindImageTextureEXT GLuint index - GLuint texture + GLuint texture GLint level GLboolean layered GLint layer @@ -10718,7 +7499,7 @@ typedef unsigned int GLhandleARB; void glBindImageTextures GLuint first GLsizei count - const GLuint *textures + const GLuint *textures GLuint glBindLightParameterEXT @@ -10734,7 +7515,7 @@ typedef unsigned int GLhandleARB; void glBindMultiTextureEXT GLenum texunit GLenum target - GLuint texture + GLuint texture GLuint glBindParameterEXT @@ -10742,52 +7523,56 @@ typedef unsigned int GLhandleARB; void glBindProgramARB - GLenum target - GLuint program + GLenum target + GLuint program void glBindProgramNV GLenum target - GLuint id + GLuint id void glBindProgramPipeline - GLuint pipeline + GLuint pipeline void glBindProgramPipelineEXT - GLuint pipeline + GLuint pipeline void glBindRenderbuffer GLenum target - GLuint renderbuffer + GLuint renderbuffer void glBindRenderbufferEXT GLenum target - GLuint renderbuffer + GLuint renderbuffer void glBindRenderbufferOES GLenum target - GLuint renderbuffer + GLuint renderbuffer void glBindSampler GLuint unit - GLuint sampler + GLuint sampler void glBindSamplers GLuint first GLsizei count - const GLuint *samplers + const GLuint *samplers + + + void glBindShadingRateImageNV + GLuint texture GLuint glBindTexGenParameterEXT @@ -10798,20 +7583,20 @@ typedef unsigned int GLhandleARB; void glBindTexture GLenum target - GLuint texture + GLuint texture void glBindTextureEXT GLenum target - GLuint texture + GLuint texture void glBindTextureUnit GLuint unit - GLuint texture + GLuint texture GLuint glBindTextureUnitParameterEXT @@ -10822,36 +7607,36 @@ typedef unsigned int GLhandleARB; void glBindTextures GLuint first GLsizei count - const GLuint *textures + const GLuint *textures void glBindTransformFeedback GLenum target - GLuint id + GLuint id void glBindTransformFeedbackNV GLenum target - GLuint id + GLuint id void glBindVertexArray - GLuint array + GLuint array void glBindVertexArrayAPPLE - GLuint array + GLuint array void glBindVertexArrayOES - GLuint array + GLuint array void glBindVertexBuffer GLuint bindingindex - GLuint buffer + GLuint buffer GLintptr offset GLsizei stride @@ -10859,7 +7644,7 @@ typedef unsigned int GLhandleARB; void glBindVertexBuffers GLuint first GLsizei count - const GLuint *buffers + const GLuint *buffers const GLintptr *offsets const GLsizei *strides @@ -10880,7 +7665,7 @@ typedef unsigned int GLhandleARB; GLuint stream GLenum frame_region GLenum target - GLuint texture + GLuint texture void glBinormal3bEXT @@ -11276,8 +8061,8 @@ typedef unsigned int GLhandleARB; void glBlitNamedFramebuffer - GLuint readFramebuffer - GLuint drawFramebuffer + GLuint readFramebuffer + GLuint drawFramebuffer GLint srcX0 GLint srcY0 GLint srcX1 @@ -11296,6 +8081,12 @@ typedef unsigned int GLhandleARB; GLuint64EXT address GLsizeiptr length + + void glBufferAttachMemoryNV + GLenum target + GLuint memory + GLuint64 offset + void glBufferData GLenum target @@ -11316,7 +8107,16 @@ typedef unsigned int GLhandleARB; GLenum target GLintptr offset GLsizeiptr size - GLboolean commit + GLboolean commit + + + void glBufferPageCommitmentMemNV + GLenum target + GLintptr offset + GLsizeiptr size + GLuint memory + GLuint64 memOffset + GLboolean commit void glBufferParameteriAPPLE @@ -11329,14 +8129,14 @@ typedef unsigned int GLhandleARB; GLenum target GLsizeiptr size const void *data - GLbitfield flags + GLbitfield flags void glBufferStorageEXT GLenum target GLsizeiptr size const void *data - GLbitfield flags + GLbitfield flags @@ -11345,7 +8145,7 @@ typedef unsigned int GLhandleARB; GLintptr offset GLsizeiptr size GLeglClientBufferEXT clientBuffer - GLbitfield flags + GLbitfield flags void glBufferStorageMemEXT @@ -11402,12 +8202,12 @@ typedef unsigned int GLhandleARB; GLenum glCheckNamedFramebufferStatus - GLuint framebuffer + GLuint framebuffer GLenum target GLenum glCheckNamedFramebufferStatusEXT - GLuint framebuffer + GLuint framebuffer GLenum target @@ -11446,15 +8246,15 @@ typedef unsigned int GLhandleARB; void glClearBufferData GLenum target - GLenum internalformat + GLenum internalformat GLenum format GLenum type const void *data void glClearBufferSubData - GLenum target - GLenum internalformat + GLenum target + GLenum internalformat GLintptr offset GLsizeiptr size GLenum format @@ -11563,24 +8363,24 @@ typedef unsigned int GLhandleARB; void glClearNamedBufferData - GLuint buffer - GLenum internalformat + GLuint buffer + GLenum internalformat GLenum format GLenum type const void *data void glClearNamedBufferDataEXT - GLuint buffer - GLenum internalformat + GLuint buffer + GLenum internalformat GLenum format GLenum type const void *data void glClearNamedBufferSubData - GLuint buffer - GLenum internalformat + GLuint buffer + GLenum internalformat GLintptr offset GLsizeiptr size GLenum format @@ -11589,8 +8389,8 @@ typedef unsigned int GLhandleARB; void glClearNamedBufferSubDataEXT - GLuint buffer - GLenum internalformat + GLuint buffer + GLenum internalformat GLsizeiptr offset GLsizeiptr size GLenum format @@ -11599,7 +8399,7 @@ typedef unsigned int GLhandleARB; void glClearNamedFramebufferfi - GLuint framebuffer + GLuint framebuffer GLenum buffer GLint drawbuffer GLfloat depth @@ -11607,24 +8407,24 @@ typedef unsigned int GLhandleARB; void glClearNamedFramebufferfv - GLuint framebuffer + GLuint framebuffer GLenum buffer GLint drawbuffer - const GLfloat *value + const GLfloat *value void glClearNamedFramebufferiv - GLuint framebuffer + GLuint framebuffer GLenum buffer GLint drawbuffer - const GLint *value + const GLint *value void glClearNamedFramebufferuiv - GLuint framebuffer + GLuint framebuffer GLenum buffer GLint drawbuffer - const GLuint *value + const GLuint *value void glClearPixelLocalStorageuiEXT @@ -11639,7 +8439,7 @@ typedef unsigned int GLhandleARB; void glClearTexImage - GLuint texture + GLuint texture GLint level GLenum format GLenum type @@ -11647,7 +8447,7 @@ typedef unsigned int GLhandleARB; void glClearTexImageEXT - GLuint texture + GLuint texture GLint level GLenum format GLenum type @@ -11656,7 +8456,7 @@ typedef unsigned int GLhandleARB; void glClearTexSubImage - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -11670,7 +8470,7 @@ typedef unsigned int GLhandleARB; void glClearTexSubImageEXT - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -11700,15 +8500,21 @@ typedef unsigned int GLhandleARB; void glClientAttribDefaultEXT GLbitfield mask + + void glClientWaitSemaphoreui64NVX + GLsizei fenceObjectCount + const GLuint *semaphoreArray + const GLuint64 *fenceValueArray + GLenum glClientWaitSync - GLsync sync + GLsync sync GLbitfield flags GLuint64 timeout GLenum glClientWaitSyncAPPLE - GLsync sync + GLsync sync GLbitfield flags GLuint64 timeout @@ -12084,42 +8890,42 @@ typedef unsigned int GLhandleARB; void glColorFragmentOp1ATI - GLenum op - GLuint dst - GLuint dstMask - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod void glColorFragmentOp2ATI - GLenum op - GLuint dst - GLuint dstMask - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod - GLuint arg2 - GLuint arg2Rep - GLuint arg2Mod + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod void glColorFragmentOp3ATI - GLenum op - GLuint dst - GLuint dstMask - GLuint dstMod - GLuint arg1 - GLuint arg1Rep - GLuint arg1Mod - GLuint arg2 - GLuint arg2Rep - GLuint arg2Mod - GLuint arg3 - GLuint arg3Rep - GLuint arg3Mod + GLenum op + GLuint dst + GLuint dstMask + GLuint dstMod + GLuint arg1 + GLuint arg1Rep + GLuint arg1Mod + GLuint arg2 + GLuint arg2Rep + GLuint arg2Mod + GLuint arg3 + GLuint arg3Rep + GLuint arg3Mod void glColorMask @@ -12368,7 +9174,7 @@ typedef unsigned int GLhandleARB; void glCompileShader - GLuint shader + GLuint shader void glCompileShaderARB @@ -12377,7 +9183,7 @@ typedef unsigned int GLhandleARB; void glCompileShaderIncludeARB - GLuint shader + GLuint shader GLsizei count const GLchar *const*path const GLint *length @@ -12425,7 +9231,7 @@ typedef unsigned int GLhandleARB; GLint level GLint xoffset GLsizei width - GLenum format + GLenum format GLsizei imageSize const void *bits @@ -12438,7 +9244,7 @@ typedef unsigned int GLhandleARB; GLint yoffset GLsizei width GLsizei height - GLenum format + GLenum format GLsizei imageSize const void *bits @@ -12453,7 +9259,7 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *bits @@ -12553,7 +9359,7 @@ typedef unsigned int GLhandleARB; GLint level GLint xoffset GLsizei width - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12565,7 +9371,7 @@ typedef unsigned int GLhandleARB; GLint level GLint xoffset GLsizei width - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12579,7 +9385,7 @@ typedef unsigned int GLhandleARB; GLint yoffset GLsizei width GLsizei height - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12593,7 +9399,7 @@ typedef unsigned int GLhandleARB; GLint yoffset GLsizei width GLsizei height - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12609,7 +9415,7 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12625,7 +9431,7 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *data @@ -12641,13 +9447,13 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *data void glCompressedTextureImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum internalformat @@ -12658,7 +9464,7 @@ typedef unsigned int GLhandleARB; void glCompressedTextureImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum internalformat @@ -12670,7 +9476,7 @@ typedef unsigned int GLhandleARB; void glCompressedTextureImage3DEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum internalformat @@ -12683,53 +9489,53 @@ typedef unsigned int GLhandleARB; void glCompressedTextureSubImage1D - GLuint texture + GLuint texture GLint level GLint xoffset GLsizei width - GLenum format + GLenum format GLsizei imageSize const void *data void glCompressedTextureSubImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset GLsizei width - GLenum format + GLenum format GLsizei imageSize const void *bits void glCompressedTextureSubImage2D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset GLsizei width GLsizei height - GLenum format + GLenum format GLsizei imageSize const void *data void glCompressedTextureSubImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset GLint yoffset GLsizei width GLsizei height - GLenum format + GLenum format GLsizei imageSize const void *bits void glCompressedTextureSubImage3D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -12737,13 +9543,13 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *data void glCompressedTextureSubImage3DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -12752,7 +9558,7 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLenum format + GLenum format GLsizei imageSize const void *bits @@ -12982,13 +9788,13 @@ typedef unsigned int GLhandleARB; void glCopyImageSubData GLuint srcName - GLenum srcTarget + GLenum srcTarget GLint srcLevel GLint srcX GLint srcY GLint srcZ GLuint dstName - GLenum dstTarget + GLenum dstTarget GLint dstLevel GLint dstX GLint dstY @@ -13114,8 +9920,8 @@ typedef unsigned int GLhandleARB; void glCopyNamedBufferSubData - GLuint readBuffer - GLuint writeBuffer + GLuint readBuffer + GLuint writeBuffer GLintptr readOffset GLintptr writeOffset GLsizeiptr size @@ -13269,7 +10075,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum internalformat @@ -13280,7 +10086,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum internalformat @@ -13299,7 +10105,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage1D - GLuint texture + GLuint texture GLint level GLint xoffset GLint x @@ -13308,7 +10114,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -13318,7 +10124,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage2D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -13329,7 +10135,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -13341,7 +10147,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage3D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -13353,7 +10159,7 @@ typedef unsigned int GLhandleARB; void glCopyTextureSubImage3DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -13396,7 +10202,7 @@ typedef unsigned int GLhandleARB; void glCoverageMaskNV - GLboolean mask + GLboolean mask void glCoverageModulationNV @@ -13414,7 +10220,7 @@ typedef unsigned int GLhandleARB; void glCreateBuffers GLsizei n - GLuint *buffers + GLuint *buffers void glCreateCommandListsNV @@ -13424,7 +10230,7 @@ typedef unsigned int GLhandleARB; void glCreateFramebuffers GLsizei n - GLuint *framebuffers + GLuint *framebuffers void glCreateMemoryObjectsEXT @@ -13437,7 +10243,7 @@ typedef unsigned int GLhandleARB; GLuint *queryHandle - GLuint glCreateProgram + GLuint glCreateProgram GLhandleARB glCreateProgramObjectARB @@ -13446,26 +10252,34 @@ typedef unsigned int GLhandleARB; void glCreateProgramPipelines GLsizei n - GLuint *pipelines + GLuint *pipelines + + + GLuint glCreateProgressFenceNVX void glCreateQueries GLenum target GLsizei n - GLuint *ids + GLuint *ids void glCreateRenderbuffers GLsizei n - GLuint *renderbuffers + GLuint *renderbuffers void glCreateSamplers GLsizei n - GLuint *samplers + GLuint *samplers - GLuint glCreateShader + void glCreateSemaphoresNV + GLsizei n + GLuint *semaphores + + + GLuint glCreateShader GLenum type @@ -13474,18 +10288,18 @@ typedef unsigned int GLhandleARB; - GLuint glCreateShaderProgramEXT + GLuint glCreateShaderProgramEXT GLenum type const GLchar *string - GLuint glCreateShaderProgramv + GLuint glCreateShaderProgramv GLenum type GLsizei count const GLchar *const*strings - GLuint glCreateShaderProgramvEXT + GLuint glCreateShaderProgramvEXT GLenum type GLsizei count const GLchar **strings @@ -13496,7 +10310,7 @@ typedef unsigned int GLhandleARB; GLuint *states - GLsync glCreateSyncFromCLeventARB + GLsync glCreateSyncFromCLeventARB struct _cl_context *context struct _cl_event *event GLbitfield flags @@ -13505,17 +10319,17 @@ typedef unsigned int GLhandleARB; void glCreateTextures GLenum target GLsizei n - GLuint *textures + GLuint *textures void glCreateTransformFeedbacks GLsizei n - GLuint *ids + GLuint *ids void glCreateVertexArrays GLsizei n - GLuint *arrays + GLuint *arrays void glCullFace @@ -13589,7 +10403,7 @@ typedef unsigned int GLhandleARB; GLenum severity GLsizei count const GLuint *ids - GLboolean enabled + GLboolean enabled @@ -13686,12 +10500,12 @@ typedef unsigned int GLhandleARB; void glDeleteBuffers GLsizei n - const GLuint *buffers + const GLuint *buffers void glDeleteBuffersARB GLsizei n - const GLuint *buffers + const GLuint *buffers @@ -13717,24 +10531,24 @@ typedef unsigned int GLhandleARB; void glDeleteFramebuffers GLsizei n - const GLuint *framebuffers + const GLuint *framebuffers void glDeleteFramebuffersEXT GLsizei n - const GLuint *framebuffers + const GLuint *framebuffers void glDeleteFramebuffersOES GLsizei n - const GLuint *framebuffers + const GLuint *framebuffers void glDeleteLists - GLuint list + GLuint list GLsizei range @@ -13779,48 +10593,48 @@ typedef unsigned int GLhandleARB; void glDeleteProgram - GLuint program + GLuint program void glDeleteProgramPipelines GLsizei n - const GLuint *pipelines + const GLuint *pipelines void glDeleteProgramPipelinesEXT GLsizei n - const GLuint *pipelines + const GLuint *pipelines void glDeleteProgramsARB GLsizei n - const GLuint *programs + const GLuint *programs void glDeleteProgramsNV GLsizei n - const GLuint *programs + const GLuint *programs void glDeleteQueries GLsizei n - const GLuint *ids + const GLuint *ids void glDeleteQueriesARB GLsizei n - const GLuint *ids + const GLuint *ids void glDeleteQueriesEXT GLsizei n - const GLuint *ids + const GLuint *ids void glDeleteQueryResourceTagNV @@ -13830,25 +10644,25 @@ typedef unsigned int GLhandleARB; void glDeleteRenderbuffers GLsizei n - const GLuint *renderbuffers + const GLuint *renderbuffers void glDeleteRenderbuffersEXT GLsizei n - const GLuint *renderbuffers + const GLuint *renderbuffers void glDeleteRenderbuffersOES GLsizei n - const GLuint *renderbuffers + const GLuint *renderbuffers void glDeleteSamplers GLsizei count - const GLuint *samplers + const GLuint *samplers void glDeleteSemaphoresEXT @@ -13857,7 +10671,7 @@ typedef unsigned int GLhandleARB; void glDeleteShader - GLuint shader + GLuint shader @@ -13867,52 +10681,52 @@ typedef unsigned int GLhandleARB; void glDeleteSync - GLsync sync + GLsync sync void glDeleteSyncAPPLE - GLsync sync + GLsync sync void glDeleteTextures GLsizei n - const GLuint *textures + const GLuint *textures void glDeleteTexturesEXT GLsizei n - const GLuint *textures + const GLuint *textures void glDeleteTransformFeedbacks GLsizei n - const GLuint *ids + const GLuint *ids void glDeleteTransformFeedbacksNV GLsizei n - const GLuint *ids + const GLuint *ids void glDeleteVertexArrays GLsizei n - const GLuint *arrays + const GLuint *arrays void glDeleteVertexArraysAPPLE GLsizei n - const GLuint *arrays + const GLuint *arrays void glDeleteVertexArraysOES GLsizei n - const GLuint *arrays + const GLuint *arrays @@ -13947,6 +10761,12 @@ typedef unsigned int GLhandleARB; GLdouble f + + void glDepthRangeArraydvNV + GLuint first + GLsizei count + const GLdouble *v + void glDepthRangeArrayfvNV GLuint first @@ -13971,6 +10791,12 @@ typedef unsigned int GLhandleARB; GLdouble n GLdouble f + + void glDepthRangeIndexeddNV + GLuint index + GLdouble n + GLdouble f + void glDepthRangeIndexedfNV GLuint index @@ -14019,8 +10845,8 @@ typedef unsigned int GLhandleARB; void glDetachShader - GLuint program - GLuint shader + GLuint program + GLuint shader void glDetailTexFuncSGIS @@ -14065,17 +10891,17 @@ typedef unsigned int GLhandleARB; void glDisableVertexArrayAttrib - GLuint vaobj + GLuint vaobj GLuint index void glDisableVertexArrayAttribEXT - GLuint vaobj + GLuint vaobj GLuint index void glDisableVertexArrayEXT - GLuint vaobj + GLuint vaobj GLenum array @@ -14119,7 +10945,7 @@ typedef unsigned int GLhandleARB; void glDiscardFramebufferEXT GLenum target GLsizei numAttachments - const GLenum *attachments + const GLenum *attachments void glDispatchCompute @@ -14224,19 +11050,19 @@ typedef unsigned int GLhandleARB; void glDrawBuffers GLsizei n - const GLenum *bufs + const GLenum *bufs void glDrawBuffersARB GLsizei n - const GLenum *bufs + const GLenum *bufs void glDrawBuffersATI GLsizei n - const GLenum *bufs + const GLenum *bufs @@ -14282,7 +11108,7 @@ typedef unsigned int GLhandleARB; void glDrawCommandsStatesNV - GLuint buffer + GLuint buffer const GLintptr *indirects const GLsizei *sizes const GLuint *states @@ -14397,7 +11223,7 @@ typedef unsigned int GLhandleARB; void glDrawElementsInstancedBaseVertexBaseInstance GLenum mode GLsizei count - GLenum type + GLenum type const void *indices GLsizei instancecount GLint basevertex @@ -14407,7 +11233,7 @@ typedef unsigned int GLhandleARB; void glDrawElementsInstancedBaseVertexBaseInstanceEXT GLenum mode GLsizei count - GLenum type + GLenum type const void *indices GLsizei instancecount GLint basevertex @@ -14459,6 +11285,15 @@ typedef unsigned int GLhandleARB; GLsizei count GLsizei width + + void glDrawMeshTasksNV + GLuint first + GLuint count + + + void glDrawMeshTasksIndirectNV + GLintptr indirect + void glDrawPixels GLsizei width @@ -14576,8 +11411,8 @@ typedef unsigned int GLhandleARB; void glDrawTextureNV - GLuint texture - GLuint sampler + GLuint texture + GLuint sampler GLfloat x0 GLfloat y0 GLfloat x1 @@ -14604,43 +11439,43 @@ typedef unsigned int GLhandleARB; void glDrawTransformFeedback GLenum mode - GLuint id + GLuint id void glDrawTransformFeedbackEXT GLenum mode - GLuint id + GLuint id void glDrawTransformFeedbackInstanced GLenum mode - GLuint id + GLuint id GLsizei instancecount void glDrawTransformFeedbackInstancedEXT GLenum mode - GLuint id + GLuint id GLsizei instancecount void glDrawTransformFeedbackNV GLenum mode - GLuint id + GLuint id void glDrawTransformFeedbackStream GLenum mode - GLuint id + GLuint id GLuint stream void glDrawTransformFeedbackStreamInstanced GLenum mode - GLuint id + GLuint id GLuint stream GLsizei instancecount @@ -14662,7 +11497,7 @@ typedef unsigned int GLhandleARB; void glEGLImageTargetTextureStorageEXT - GLuint texture + GLuint texture GLeglImageOES image const GLint* attrib_list @@ -14743,17 +11578,17 @@ typedef unsigned int GLhandleARB; void glEnableVertexArrayAttrib - GLuint vaobj + GLuint vaobj GLuint index void glEnableVertexArrayAttribEXT - GLuint vaobj + GLuint vaobj GLuint index void glEnableVertexArrayEXT - GLuint vaobj + GLuint vaobj GLenum array @@ -14973,48 +11808,48 @@ typedef unsigned int GLhandleARB; void glExtGetBufferPointervQCOM GLenum target - void **params + void **params void glExtGetBuffersQCOM - GLuint *buffers + GLuint *buffers GLint maxBuffers GLint *numBuffers void glExtGetFramebuffersQCOM - GLuint *framebuffers + GLuint *framebuffers GLint maxFramebuffers GLint *numFramebuffers void glExtGetProgramBinarySourceQCOM - GLuint program + GLuint program GLenum shadertype - GLchar *source + GLchar *source GLint *length void glExtGetProgramsQCOM - GLuint *programs + GLuint *programs GLint maxPrograms GLint *numPrograms void glExtGetRenderbuffersQCOM - GLuint *renderbuffers + GLuint *renderbuffers GLint maxRenderbuffers GLint *numRenderbuffers void glExtGetShadersQCOM - GLuint *shaders + GLuint *shaders GLint maxShaders GLint *numShaders void glExtGetTexLevelParameterivQCOM - GLuint texture + GLuint texture GLenum face GLint level GLenum pname @@ -15036,13 +11871,13 @@ typedef unsigned int GLhandleARB; void glExtGetTexturesQCOM - GLuint *textures + GLuint *textures GLint maxTextures GLint *numTextures - GLboolean glExtIsProgramBinaryQCOM - GLuint program + GLboolean glExtIsProgramBinaryQCOM + GLuint program void glExtTexObjectStateOverrideiQCOM @@ -15070,14 +11905,14 @@ typedef unsigned int GLhandleARB; const GLfixed *buffer - GLsync glFenceSync + GLsync glFenceSync GLenum condition - GLbitfield flags + GLbitfield flags - GLsync glFenceSyncAPPLE + GLsync glFenceSyncAPPLE GLenum condition - GLbitfield flags + GLbitfield flags @@ -15139,13 +11974,13 @@ typedef unsigned int GLhandleARB; void glFlushMappedNamedBufferRange - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr length void glFlushMappedNamedBufferRangeEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr length @@ -15385,12 +12220,12 @@ typedef unsigned int GLhandleARB; void glFramebufferDrawBufferEXT - GLuint framebuffer + GLuint framebuffer GLenum mode void glFramebufferDrawBuffersEXT - GLuint framebuffer + GLuint framebuffer GLsizei n const GLenum *bufs @@ -15402,7 +12237,7 @@ typedef unsigned int GLhandleARB; void glFramebufferFoveationConfigQCOM - GLuint framebuffer + GLuint framebuffer GLuint numLayers GLuint focalPointsPerLayer GLuint requestedFeatures @@ -15410,7 +12245,7 @@ typedef unsigned int GLhandleARB; void glFramebufferFoveationParametersQCOM - GLuint framebuffer + GLuint framebuffer GLuint layer GLuint focalPoint GLfloat focalX @@ -15425,12 +12260,6 @@ typedef unsigned int GLhandleARB; GLenum pname GLint param - - void glFramebufferParameteriMESA - GLenum target - GLenum pname - GLint param - void glFramebufferPixelLocalStorageSizeEXT GLuint target @@ -15438,7 +12267,7 @@ typedef unsigned int GLhandleARB; void glFramebufferReadBufferEXT - GLuint framebuffer + GLuint framebuffer GLenum mode @@ -15446,7 +12275,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum renderbuffertarget - GLuint renderbuffer + GLuint renderbuffer @@ -15454,7 +12283,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum renderbuffertarget - GLuint renderbuffer + GLuint renderbuffer @@ -15463,7 +12292,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum renderbuffertarget - GLuint renderbuffer + GLuint renderbuffer void glFramebufferSampleLocationsfvARB @@ -15486,11 +12315,21 @@ typedef unsigned int GLhandleARB; GLuint pixelindex const GLfloat *values + + void glFramebufferShadingRateEXT + GLenum target + GLenum attachment + GLuint texture + GLint baseLayer + GLsizei numLayers + GLsizei texelWidth + GLsizei texelHeight + void glFramebufferTexture GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level @@ -15498,7 +12337,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level @@ -15507,7 +12346,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level @@ -15517,7 +12356,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level @@ -15526,7 +12365,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level @@ -15536,7 +12375,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLint xscale GLint yscale @@ -15546,7 +12385,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLsizei samples @@ -15555,7 +12394,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLsizei samples @@ -15564,7 +12403,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level @@ -15572,7 +12411,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLint zoffset @@ -15582,7 +12421,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLint zoffset @@ -15593,7 +12432,7 @@ typedef unsigned int GLhandleARB; GLenum target GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLint zoffset @@ -15601,7 +12440,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureARB GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level @@ -15609,7 +12448,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureEXT GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level @@ -15617,7 +12456,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureFaceARB GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLenum face @@ -15625,7 +12464,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureFaceEXT GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLenum face @@ -15634,7 +12473,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureLayer GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer @@ -15643,7 +12482,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureLayerARB GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer @@ -15652,7 +12491,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureLayerEXT GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer @@ -15661,7 +12500,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureLayerDownsampleIMG GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer GLint xscale @@ -15671,7 +12510,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureMultisampleMultiviewOVR GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLsizei samples GLint baseViewIndex @@ -15681,7 +12520,7 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureMultiviewOVR GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level GLint baseViewIndex GLsizei numViews @@ -15690,13 +12529,13 @@ typedef unsigned int GLhandleARB; void glFramebufferTextureOES GLenum target GLenum attachment - GLuint texture + GLuint texture GLint level void glFreeObjectBufferATI - GLuint buffer + GLuint buffer void glFrontFace @@ -15757,12 +12596,12 @@ typedef unsigned int GLhandleARB; void glGenBuffers GLsizei n - GLuint *buffers + GLuint *buffers void glGenBuffersARB GLsizei n - GLuint *buffers + GLuint *buffers @@ -15783,23 +12622,23 @@ typedef unsigned int GLhandleARB; void glGenFramebuffers GLsizei n - GLuint *framebuffers + GLuint *framebuffers void glGenFramebuffersEXT GLsizei n - GLuint *framebuffers + GLuint *framebuffers void glGenFramebuffersOES GLsizei n - GLuint *framebuffers + GLuint *framebuffers - GLuint glGenLists + GLuint glGenLists GLsizei range @@ -15826,42 +12665,42 @@ typedef unsigned int GLhandleARB; void glGenProgramPipelines GLsizei n - GLuint *pipelines + GLuint *pipelines void glGenProgramPipelinesEXT GLsizei n - GLuint *pipelines + GLuint *pipelines void glGenProgramsARB GLsizei n - GLuint *programs + GLuint *programs void glGenProgramsNV GLsizei n - GLuint *programs + GLuint *programs void glGenQueries GLsizei n - GLuint *ids + GLuint *ids void glGenQueriesARB GLsizei n - GLuint *ids + GLuint *ids void glGenQueriesEXT GLsizei n - GLuint *ids + GLuint *ids void glGenQueryResourceTagNV @@ -15871,25 +12710,25 @@ typedef unsigned int GLhandleARB; void glGenRenderbuffers GLsizei n - GLuint *renderbuffers + GLuint *renderbuffers void glGenRenderbuffersEXT GLsizei n - GLuint *renderbuffers + GLuint *renderbuffers void glGenRenderbuffersOES GLsizei n - GLuint *renderbuffers + GLuint *renderbuffers void glGenSamplers GLsizei count - GLuint *samplers + GLuint *samplers void glGenSemaphoresEXT @@ -15906,42 +12745,42 @@ typedef unsigned int GLhandleARB; void glGenTextures GLsizei n - GLuint *textures + GLuint *textures void glGenTexturesEXT GLsizei n - GLuint *textures + GLuint *textures void glGenTransformFeedbacks GLsizei n - GLuint *ids + GLuint *ids void glGenTransformFeedbacksNV GLsizei n - GLuint *ids + GLuint *ids void glGenVertexArrays GLsizei n - GLuint *arrays + GLuint *arrays void glGenVertexArraysAPPLE GLsizei n - GLuint *arrays + GLuint *arrays void glGenVertexArraysOES GLsizei n - GLuint *arrays + GLuint *arrays @@ -15970,23 +12809,23 @@ typedef unsigned int GLhandleARB; void glGenerateTextureMipmap - GLuint texture + GLuint texture void glGenerateTextureMipmapEXT - GLuint texture + GLuint texture GLenum target void glGetActiveAtomicCounterBufferiv - GLuint program + GLuint program GLuint bufferIndex GLenum pname GLint *params void glGetActiveAttrib - GLuint program + GLuint program GLuint index GLsizei bufSize GLsizei *length @@ -16007,25 +12846,25 @@ typedef unsigned int GLhandleARB; void glGetActiveSubroutineName - GLuint program + GLuint program GLenum shadertype GLuint index - GLsizei bufsize + GLsizei bufSize GLsizei *length - GLchar *name + GLchar *name void glGetActiveSubroutineUniformName - GLuint program + GLuint program GLenum shadertype GLuint index - GLsizei bufsize + GLsizei bufSize GLsizei *length - GLchar *name + GLchar *name void glGetActiveSubroutineUniformiv - GLuint program + GLuint program GLenum shadertype GLuint index GLenum pname @@ -16033,12 +12872,12 @@ typedef unsigned int GLhandleARB; void glGetActiveUniform - GLuint program + GLuint program GLuint index GLsizei bufSize GLsizei *length GLint *size - GLenum *type + GLenum *type GLchar *name @@ -16048,13 +12887,13 @@ typedef unsigned int GLhandleARB; GLsizei maxLength GLsizei *length GLint *size - GLenum *type + GLenum *type GLcharARB *name void glGetActiveUniformBlockName - GLuint program + GLuint program GLuint uniformBlockIndex GLsizei bufSize GLsizei *length @@ -16063,7 +12902,7 @@ typedef unsigned int GLhandleARB; void glGetActiveUniformBlockiv - GLuint program + GLuint program GLuint uniformBlockIndex GLenum pname GLint *params @@ -16071,7 +12910,7 @@ typedef unsigned int GLhandleARB; void glGetActiveUniformName - GLuint program + GLuint program GLuint uniformIndex GLsizei bufSize GLsizei *length @@ -16080,7 +12919,7 @@ typedef unsigned int GLhandleARB; void glGetActiveUniformsiv - GLuint program + GLuint program GLsizei uniformCount const GLuint *uniformIndices GLenum pname @@ -16089,13 +12928,13 @@ typedef unsigned int GLhandleARB; void glGetActiveVaryingNV - GLuint program + GLuint program GLuint index GLsizei bufSize GLsizei *length GLsizei *size GLenum *type - GLchar *name + GLchar *name void glGetArrayObjectfvATI @@ -16118,14 +12957,14 @@ typedef unsigned int GLhandleARB; void glGetAttachedShaders - GLuint program + GLuint program GLsizei maxCount GLsizei *count - GLuint *shaders + GLuint *shaders GLint glGetAttribLocation - GLuint program + GLuint program const GLchar *name @@ -16196,7 +13035,7 @@ typedef unsigned int GLhandleARB; void glGetBufferPointervOES GLenum target GLenum pname - void **params + void **params @@ -16378,21 +13217,21 @@ typedef unsigned int GLhandleARB; void glGetCompressedTextureImage - GLuint texture + GLuint texture GLint level GLsizei bufSize - void *pixels + void *pixels void glGetCompressedTextureImageEXT - GLuint texture + GLuint texture GLenum target GLint lod void *img void glGetCompressedTextureSubImage - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -16401,7 +13240,7 @@ typedef unsigned int GLhandleARB; GLsizei height GLsizei depth GLsizei bufSize - void *pixels + void *pixels void glGetConvolutionFilter @@ -16456,7 +13295,7 @@ typedef unsigned int GLhandleARB; void glGetCoverageModulationTableNV - GLsizei bufsize + GLsizei bufSize GLfloat *v @@ -16473,12 +13312,12 @@ typedef unsigned int GLhandleARB; GLuint glGetDebugMessageLogAMD GLuint count - GLsizei bufsize + GLsizei bufSize GLenum *categories - GLuint *severities + GLenum *severities GLuint *ids GLsizei *lengths - GLchar *message + GLchar *message GLuint glGetDebugMessageLogARB @@ -16512,20 +13351,20 @@ typedef unsigned int GLhandleARB; void glGetDoubleIndexedvEXT - GLenum target + GLenum target GLuint index GLdouble *data void glGetDoublei_v - GLenum target + GLenum target GLuint index GLdouble *data void glGetDoublei_vEXT - GLenum pname + GLenum pname GLuint index GLdouble *params @@ -16590,34 +13429,34 @@ typedef unsigned int GLhandleARB; void glGetFloatIndexedvEXT - GLenum target + GLenum target GLuint index GLfloat *data void glGetFloati_v - GLenum target + GLenum target GLuint index GLfloat *data void glGetFloati_vEXT - GLenum pname + GLenum pname GLuint index GLfloat *params void glGetFloati_vNV - GLenum target + GLenum target GLuint index GLfloat *data void glGetFloati_vOES - GLenum target + GLenum target GLuint index GLfloat *data @@ -16634,23 +13473,23 @@ typedef unsigned int GLhandleARB; GLint glGetFragDataIndex - GLuint program + GLuint program const GLchar *name GLint glGetFragDataIndexEXT - GLuint program + GLuint program const GLchar *name GLint glGetFragDataLocation - GLuint program + GLuint program const GLchar *name GLint glGetFragDataLocationEXT - GLuint program + GLuint program const GLchar *name @@ -16678,6 +13517,13 @@ typedef unsigned int GLhandleARB; GLenum pname GLint *params + + void glGetFragmentShadingRatesEXT + GLsizei samples + GLsizei maxCount + GLsizei *count + GLenum *shadingRates + void glGetFramebufferAttachmentParameteriv GLenum target @@ -16717,15 +13563,9 @@ typedef unsigned int GLhandleARB; GLenum pname GLint *params - - void glGetFramebufferParameterivMESA - GLenum target - GLenum pname - GLint *params - void glGetFramebufferParameterivEXT - GLuint framebuffer + GLuint framebuffer GLenum pname GLint *params @@ -16741,6 +13581,7 @@ typedef unsigned int GLhandleARB; GLenum glGetGraphicsResetStatusEXT + GLenum glGetGraphicsResetStatusKHR @@ -16805,15 +13646,15 @@ typedef unsigned int GLhandleARB; GLuint64 glGetImageHandleARB - GLuint texture + GLuint texture GLint level - GLboolean layered + GLboolean layered GLint layer GLenum format GLuint64 glGetImageHandleNV - GLuint texture + GLuint texture GLint level GLboolean layered GLint layer @@ -16844,7 +13685,7 @@ typedef unsigned int GLhandleARB; void glGetInteger64i_v - GLenum target + GLenum target GLuint index GLint64 *data @@ -16859,29 +13700,29 @@ typedef unsigned int GLhandleARB; GLint64 *params - - void glGetIntegerIndexedvEXT - GLenum target - GLuint index - GLint *data - - - void glGetInteger64vEXT GLenum pname GLint64 *data + + void glGetIntegerIndexedvEXT + GLenum target + GLuint index + GLint *data + + + void glGetIntegeri_v - GLenum target + GLenum target GLuint index GLint *data void glGetIntegeri_vEXT - GLenum target + GLenum target GLuint index GLint *data @@ -16908,24 +13749,24 @@ typedef unsigned int GLhandleARB; GLenum internalformat GLsizei samples GLenum pname - GLsizei bufSize - GLint *params + GLsizei count + GLint *params void glGetInternalformati64v GLenum target GLenum internalformat GLenum pname - GLsizei bufSize - GLint64 *params + GLsizei count + GLint64 *params void glGetInternalformativ GLenum target GLenum internalformat GLenum pname - GLsizei bufSize - GLint *params + GLsizei count + GLint *params void glGetInvariantBooleanvEXT @@ -17102,6 +13943,14 @@ typedef unsigned int GLhandleARB; GLenum pname GLfixed *params + + void glGetMemoryObjectDetachedResourcesuivNV + GLuint memory + GLenum pname + GLint first + GLsizei count + GLuint *params + void glGetMemoryObjectParameterivEXT GLuint memoryObject @@ -17258,57 +14107,57 @@ typedef unsigned int GLhandleARB; void glGetNamedBufferParameteri64v - GLuint buffer - GLenum pname + GLuint buffer + GLenum pname GLint64 *params void glGetNamedBufferParameteriv - GLuint buffer - GLenum pname + GLuint buffer + GLenum pname GLint *params void glGetNamedBufferParameterivEXT - GLuint buffer - GLenum pname + GLuint buffer + GLenum pname GLint *params void glGetNamedBufferParameterui64vNV - GLuint buffer - GLenum pname + GLuint buffer + GLenum pname GLuint64EXT *params void glGetNamedBufferPointerv - GLuint buffer - GLenum pname - void **params + GLuint buffer + GLenum pname + void **params void glGetNamedBufferPointervEXT - GLuint buffer - GLenum pname + GLuint buffer + GLenum pname void **params void glGetNamedBufferSubData - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size void *data void glGetNamedBufferSubDataEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size void *data void glGetNamedFramebufferParameterfvAMD - GLuint framebuffer + GLuint framebuffer GLenum pname GLuint numsamples GLuint pixelindex @@ -17317,81 +14166,81 @@ typedef unsigned int GLhandleARB; void glGetNamedFramebufferAttachmentParameteriv - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum pname GLint *params void glGetNamedFramebufferAttachmentParameterivEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum pname GLint *params void glGetNamedFramebufferParameteriv - GLuint framebuffer + GLuint framebuffer GLenum pname GLint *param void glGetNamedFramebufferParameterivEXT - GLuint framebuffer + GLuint framebuffer GLenum pname GLint *params void glGetNamedProgramLocalParameterIivEXT - GLuint program + GLuint program GLenum target GLuint index GLint *params void glGetNamedProgramLocalParameterIuivEXT - GLuint program + GLuint program GLenum target GLuint index GLuint *params void glGetNamedProgramLocalParameterdvEXT - GLuint program + GLuint program GLenum target GLuint index GLdouble *params void glGetNamedProgramLocalParameterfvEXT - GLuint program + GLuint program GLenum target GLuint index GLfloat *params void glGetNamedProgramStringEXT - GLuint program + GLuint program GLenum target GLenum pname void *string void glGetNamedProgramivEXT - GLuint program + GLuint program GLenum target GLenum pname GLint *params void glGetNamedRenderbufferParameteriv - GLuint renderbuffer + GLuint renderbuffer GLenum pname GLint *params void glGetNamedRenderbufferParameterivEXT - GLuint renderbuffer + GLuint renderbuffer GLenum pname GLint *params @@ -17417,19 +14266,19 @@ typedef unsigned int GLhandleARB; void glGetObjectBufferfvATI - GLuint buffer + GLuint buffer GLenum pname GLfloat *params void glGetObjectBufferivATI - GLuint buffer + GLuint buffer GLenum pname GLint *params void glGetObjectLabel - GLenum identifier + GLenum identifier GLuint name GLsizei bufSize GLsizei *length @@ -17590,9 +14439,9 @@ typedef unsigned int GLhandleARB; GLuint queryId GLuint counterId GLuint counterNameLength - GLchar *counterName + GLchar *counterName GLuint counterDescLength - GLchar *counterDesc + GLchar *counterDesc GLuint *counterOffset GLuint *counterDataSize GLuint *counterTypeEnum @@ -17604,7 +14453,7 @@ typedef unsigned int GLhandleARB; GLuint monitor GLenum pname GLsizei dataSize - GLuint *data + GLuint *data GLint *bytesWritten @@ -17660,7 +14509,7 @@ typedef unsigned int GLhandleARB; void glGetPerfQueryInfoINTEL GLuint queryId GLuint queryNameLength - GLchar *queryName + GLchar *queryName GLuint *dataSize GLuint *noCounters GLuint *noInstances @@ -17705,27 +14554,27 @@ typedef unsigned int GLhandleARB; void glGetPixelTransformParameterfvEXT - GLenum target + GLenum target GLenum pname GLfloat *params void glGetPixelTransformParameterivEXT - GLenum target + GLenum target GLenum pname GLint *params void glGetPointerIndexedvEXT - GLenum target + GLenum target GLuint index void **data void glGetPointeri_vEXT - GLenum pname + GLenum pname GLuint index void **params @@ -17744,7 +14593,7 @@ typedef unsigned int GLhandleARB; void glGetPointervKHR GLenum pname - void **params + void **params @@ -17755,7 +14604,7 @@ typedef unsigned int GLhandleARB; void glGetProgramBinary - GLuint program + GLuint program GLsizei bufSize GLsizei *length GLenum *binaryFormat @@ -17763,7 +14612,7 @@ typedef unsigned int GLhandleARB; void glGetProgramBinaryOES - GLuint program + GLuint program GLsizei bufSize GLsizei *length GLenum *binaryFormat @@ -17784,19 +14633,19 @@ typedef unsigned int GLhandleARB; void glGetProgramEnvParameterdvARB - GLenum target + GLenum target GLuint index GLdouble *params void glGetProgramEnvParameterfvARB - GLenum target + GLenum target GLuint index GLfloat *params void glGetProgramInfoLog - GLuint program + GLuint program GLsizei bufSize GLsizei *length GLchar *infoLog @@ -17804,7 +14653,7 @@ typedef unsigned int GLhandleARB; void glGetProgramInterfaceiv - GLuint program + GLuint program GLenum programInterface GLenum pname GLint *params @@ -17823,19 +14672,19 @@ typedef unsigned int GLhandleARB; void glGetProgramLocalParameterdvARB - GLenum target + GLenum target GLuint index GLdouble *params void glGetProgramLocalParameterfvARB - GLenum target + GLenum target GLuint index GLfloat *params void glGetProgramNamedParameterdvNV - GLuint id + GLuint id GLsizei len const GLubyte *name GLdouble *params @@ -17843,7 +14692,7 @@ typedef unsigned int GLhandleARB; void glGetProgramNamedParameterfvNV - GLuint id + GLuint id GLsizei len const GLubyte *name GLfloat *params @@ -17867,57 +14716,57 @@ typedef unsigned int GLhandleARB; void glGetProgramPipelineInfoLog - GLuint pipeline + GLuint pipeline GLsizei bufSize GLsizei *length GLchar *infoLog void glGetProgramPipelineInfoLogEXT - GLuint pipeline + GLuint pipeline GLsizei bufSize GLsizei *length GLchar *infoLog void glGetProgramPipelineiv - GLuint pipeline + GLuint pipeline GLenum pname GLint *params void glGetProgramPipelineivEXT - GLuint pipeline + GLuint pipeline GLenum pname GLint *params GLuint glGetProgramResourceIndex - GLuint program + GLuint program GLenum programInterface const GLchar *name GLint glGetProgramResourceLocation - GLuint program + GLuint program GLenum programInterface const GLchar *name GLint glGetProgramResourceLocationIndex - GLuint program + GLuint program GLenum programInterface const GLchar *name GLint glGetProgramResourceLocationIndexEXT - GLuint program + GLuint program GLenum programInterface const GLchar *name void glGetProgramResourceName - GLuint program + GLuint program GLenum programInterface GLuint index GLsizei bufSize @@ -17926,42 +14775,42 @@ typedef unsigned int GLhandleARB; void glGetProgramResourcefvNV - GLuint program + GLuint program GLenum programInterface GLuint index GLsizei propCount const GLenum *props - GLsizei bufSize - GLsizei *length - GLfloat *params + GLsizei count + GLsizei *length + GLfloat *params void glGetProgramResourceiv - GLuint program + GLuint program GLenum programInterface GLuint index GLsizei propCount - const GLenum *props - GLsizei bufSize + const GLenum *props + GLsizei count GLsizei *length - GLint *params + GLint *params void glGetProgramStageiv - GLuint program + GLuint program GLenum shadertype GLenum pname GLint *values void glGetProgramStringARB - GLenum target - GLenum pname + GLenum target + GLenum pname void *string void glGetProgramStringNV - GLuint id + GLuint id GLenum pname GLubyte *program @@ -17974,68 +14823,68 @@ typedef unsigned int GLhandleARB; void glGetProgramiv - GLuint program + GLuint program GLenum pname GLint *params void glGetProgramivARB - GLenum target + GLenum target GLenum pname GLint *params void glGetProgramivNV - GLuint id + GLuint id GLenum pname GLint *params void glGetQueryBufferObjecti64v - GLuint id - GLuint buffer + GLuint id + GLuint buffer GLenum pname GLintptr offset void glGetQueryBufferObjectiv - GLuint id - GLuint buffer + GLuint id + GLuint buffer GLenum pname GLintptr offset void glGetQueryBufferObjectui64v - GLuint id - GLuint buffer + GLuint id + GLuint buffer GLenum pname GLintptr offset void glGetQueryBufferObjectuiv - GLuint id - GLuint buffer + GLuint id + GLuint buffer GLenum pname GLintptr offset void glGetQueryIndexediv - GLenum target + GLenum target GLuint index GLenum pname GLint *params void glGetQueryObjecti64v - GLuint id + GLuint id GLenum pname GLint64 *params void glGetQueryObjecti64vEXT - GLuint id + GLuint id GLenum pname GLint64 *params @@ -18043,34 +14892,34 @@ typedef unsigned int GLhandleARB; void glGetQueryObjectiv - GLuint id + GLuint id GLenum pname GLint *params void glGetQueryObjectivARB - GLuint id + GLuint id GLenum pname GLint *params void glGetQueryObjectivEXT - GLuint id + GLuint id GLenum pname GLint *params void glGetQueryObjectui64v - GLuint id + GLuint id GLenum pname GLuint64 *params void glGetQueryObjectui64vEXT - GLuint id + GLuint id GLenum pname GLuint64 *params @@ -18078,21 +14927,21 @@ typedef unsigned int GLhandleARB; void glGetQueryObjectuiv - GLuint id + GLuint id GLenum pname GLuint *params void glGetQueryObjectuivARB - GLuint id + GLuint id GLenum pname GLuint *params void glGetQueryObjectuivEXT - GLuint id + GLuint id GLenum pname GLuint *params @@ -18139,56 +14988,62 @@ typedef unsigned int GLhandleARB; void glGetSamplerParameterIiv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLint *params void glGetSamplerParameterIivEXT - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLint *params void glGetSamplerParameterIivOES - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLint *params void glGetSamplerParameterIuiv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLuint *params void glGetSamplerParameterIuivEXT - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLuint *params void glGetSamplerParameterIuivOES - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLuint *params void glGetSamplerParameterfv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLfloat *params void glGetSamplerParameteriv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLint *params + + void glGetSemaphoreParameterivNV + GLuint semaphore + GLenum pname + GLint *params + void glGetSemaphoreParameterui64vEXT GLuint semaphore @@ -18218,7 +15073,7 @@ typedef unsigned int GLhandleARB; void glGetShaderInfoLog - GLuint shader + GLuint shader GLsizei bufSize GLsizei *length GLchar *infoLog @@ -18233,7 +15088,7 @@ typedef unsigned int GLhandleARB; void glGetShaderSource - GLuint shader + GLuint shader GLsizei bufSize GLsizei *length GLchar *source @@ -18248,11 +15103,24 @@ typedef unsigned int GLhandleARB; void glGetShaderiv - GLuint shader + GLuint shader GLenum pname GLint *params + + void glGetShadingRateImagePaletteNV + GLuint viewport + GLuint entry + GLenum *rate + + + void glGetShadingRateSampleLocationivNV + GLenum rate + GLuint samples + GLuint index + GLint *location + void glGetSharpenTexFuncSGIS GLenum target @@ -18263,6 +15131,11 @@ typedef unsigned int GLhandleARB; GLushort glGetStageIndexNV GLenum shadertype + const GLubyte *glGetString GLenum name @@ -18276,31 +15149,31 @@ typedef unsigned int GLhandleARB; GLuint glGetSubroutineIndex - GLuint program + GLuint program GLenum shadertype const GLchar *name GLint glGetSubroutineUniformLocation - GLuint program + GLuint program GLenum shadertype const GLchar *name void glGetSynciv - GLsync sync + GLsync sync GLenum pname - GLsizei bufSize + GLsizei count GLsizei *length - GLint *values + GLint *values void glGetSyncivAPPLE - GLsync sync + GLsync sync GLenum pname - GLsizei bufSize + GLsizei count GLsizei *length - GLint *values + GLint *values @@ -18494,29 +15367,29 @@ typedef unsigned int GLhandleARB; GLuint64 glGetTextureHandleARB - GLuint texture + GLuint texture GLuint64 glGetTextureHandleIMG - GLuint texture + GLuint texture GLuint64 glGetTextureHandleNV - GLuint texture + GLuint texture void glGetTextureImage - GLuint texture + GLuint texture GLint level GLenum format GLenum type GLsizei bufSize - void *pixels + void *pixels void glGetTextureImageEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum format @@ -18525,14 +15398,14 @@ typedef unsigned int GLhandleARB; void glGetTextureLevelParameterfv - GLuint texture + GLuint texture GLint level GLenum pname GLfloat *params void glGetTextureLevelParameterfvEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum pname @@ -18540,14 +15413,14 @@ typedef unsigned int GLhandleARB; void glGetTextureLevelParameteriv - GLuint texture + GLuint texture GLint level GLenum pname GLint *params void glGetTextureLevelParameterivEXT - GLuint texture + GLuint texture GLenum target GLint level GLenum pname @@ -18555,75 +15428,75 @@ typedef unsigned int GLhandleARB; void glGetTextureParameterIiv - GLuint texture + GLuint texture GLenum pname GLint *params void glGetTextureParameterIivEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLint *params void glGetTextureParameterIuiv - GLuint texture + GLuint texture GLenum pname GLuint *params void glGetTextureParameterIuivEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLuint *params void glGetTextureParameterfv - GLuint texture + GLuint texture GLenum pname GLfloat *params void glGetTextureParameterfvEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLfloat *params void glGetTextureParameteriv - GLuint texture + GLuint texture GLenum pname GLint *params void glGetTextureParameterivEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLint *params GLuint64 glGetTextureSamplerHandleARB - GLuint texture - GLuint sampler + GLuint texture + GLuint sampler GLuint64 glGetTextureSamplerHandleIMG - GLuint texture - GLuint sampler + GLuint texture + GLuint sampler GLuint64 glGetTextureSamplerHandleNV - GLuint texture - GLuint sampler + GLuint texture + GLuint sampler void glGetTextureSubImage - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -18634,7 +15507,7 @@ typedef unsigned int GLhandleARB; GLenum format GLenum type GLsizei bufSize - void *pixels + void *pixels void glGetTrackMatrixivNV @@ -18646,73 +15519,73 @@ typedef unsigned int GLhandleARB; void glGetTransformFeedbackVarying - GLuint program + GLuint program GLuint index GLsizei bufSize GLsizei *length GLsizei *size - GLenum *type + GLenum *type GLchar *name void glGetTransformFeedbackVaryingEXT - GLuint program + GLuint program GLuint index GLsizei bufSize GLsizei *length GLsizei *size - GLenum *type + GLenum *type GLchar *name void glGetTransformFeedbackVaryingNV - GLuint program + GLuint program GLuint index GLint *location void glGetTransformFeedbacki64_v - GLuint xfb + GLuint xfb GLenum pname GLuint index GLint64 *param void glGetTransformFeedbacki_v - GLuint xfb + GLuint xfb GLenum pname GLuint index GLint *param void glGetTransformFeedbackiv - GLuint xfb + GLuint xfb GLenum pname GLint *param void glGetTranslatedShaderSourceANGLE - GLuint shader - GLsizei bufsize + GLuint shader + GLsizei bufSize GLsizei *length - GLchar *source + GLchar *source GLuint glGetUniformBlockIndex - GLuint program + GLuint program const GLchar *uniformBlockName GLint glGetUniformBufferSizeEXT - GLuint program + GLuint program GLint location void glGetUniformIndices - GLuint program + GLuint program GLsizei uniformCount const GLchar *const*uniformNames GLuint *uniformIndices @@ -18720,7 +15593,7 @@ typedef unsigned int GLhandleARB; GLint glGetUniformLocation - GLuint program + GLuint program const GLchar *name @@ -18731,7 +15604,7 @@ typedef unsigned int GLhandleARB; GLintptr glGetUniformOffsetEXT - GLuint program + GLuint program GLint location @@ -18742,13 +15615,13 @@ typedef unsigned int GLhandleARB; void glGetUniformdv - GLuint program + GLuint program GLint location GLdouble *params void glGetUniformfv - GLuint program + GLuint program GLint location GLfloat *params @@ -18761,19 +15634,19 @@ typedef unsigned int GLhandleARB; void glGetUniformi64vARB - GLuint program + GLuint program GLint location GLint64 *params void glGetUniformi64vNV - GLuint program + GLuint program GLint location GLint64EXT *params void glGetUniformiv - GLuint program + GLuint program GLint location GLint *params @@ -18786,25 +15659,25 @@ typedef unsigned int GLhandleARB; void glGetUniformui64vARB - GLuint program + GLuint program GLint location GLuint64 *params void glGetUniformui64vNV - GLuint program + GLuint program GLint location GLuint64EXT *params void glGetUniformuiv - GLuint program + GLuint program GLint location GLuint *params void glGetUniformuivEXT - GLuint program + GLuint program GLint location GLuint *params @@ -18858,52 +15731,52 @@ typedef unsigned int GLhandleARB; GLint glGetVaryingLocationNV - GLuint program + GLuint program const GLchar *name void glGetVertexArrayIndexed64iv - GLuint vaobj + GLuint vaobj GLuint index GLenum pname GLint64 *param void glGetVertexArrayIndexediv - GLuint vaobj + GLuint vaobj GLuint index GLenum pname GLint *param void glGetVertexArrayIntegeri_vEXT - GLuint vaobj + GLuint vaobj GLuint index GLenum pname GLint *param void glGetVertexArrayIntegervEXT - GLuint vaobj + GLuint vaobj GLenum pname GLint *param void glGetVertexArrayPointeri_vEXT - GLuint vaobj + GLuint vaobj GLuint index GLenum pname - void **param + void **param void glGetVertexArrayPointervEXT - GLuint vaobj + GLuint vaobj GLenum pname void **param void glGetVertexArrayiv - GLuint vaobj + GLuint vaobj GLenum pname GLint *param @@ -19123,7 +15996,7 @@ typedef unsigned int GLhandleARB; GLenum format GLenum type GLsizei bufSize - void *table + void *table void glGetnColorTableARB @@ -19138,7 +16011,7 @@ typedef unsigned int GLhandleARB; GLenum target GLint lod GLsizei bufSize - void *pixels + void *pixels void glGetnCompressedTexImageARB @@ -19153,7 +16026,7 @@ typedef unsigned int GLhandleARB; GLenum format GLenum type GLsizei bufSize - void *image + void *image void glGetnConvolutionFilterARB @@ -19165,12 +16038,12 @@ typedef unsigned int GLhandleARB; void glGetnHistogram - GLenum target - GLboolean reset + GLenum target + GLboolean reset GLenum format GLenum type GLsizei bufSize - void *values + void *values void glGetnHistogramARB @@ -19186,14 +16059,14 @@ typedef unsigned int GLhandleARB; GLenum target GLenum query GLsizei bufSize - GLdouble *v + GLdouble *v void glGetnMapdvARB GLenum target GLenum query GLsizei bufSize - GLdouble *v + GLdouble *v void glGetnMapfv @@ -19225,12 +16098,12 @@ typedef unsigned int GLhandleARB; void glGetnMinmax - GLenum target - GLboolean reset + GLenum target + GLboolean reset GLenum format GLenum type GLsizei bufSize - void *values + void *values void glGetnMinmaxARB @@ -19245,13 +16118,13 @@ typedef unsigned int GLhandleARB; void glGetnPixelMapfv GLenum map GLsizei bufSize - GLfloat *values + GLfloat *values void glGetnPixelMapfvARB GLenum map GLsizei bufSize - GLfloat *values + GLfloat *values void glGetnPixelMapuiv @@ -19280,7 +16153,7 @@ typedef unsigned int GLhandleARB; void glGetnPolygonStipple GLsizei bufSize - GLubyte *pattern + GLubyte *pattern void glGetnPolygonStippleARB @@ -19289,14 +16162,14 @@ typedef unsigned int GLhandleARB; void glGetnSeparableFilter - GLenum target + GLenum target GLenum format GLenum type GLsizei rowBufSize - void *row + void *row GLsizei columnBufSize - void *column - void *span + void *column + void *span void glGetnSeparableFilterARB @@ -19329,112 +16202,112 @@ typedef unsigned int GLhandleARB; void glGetnUniformdv - GLuint program + GLuint program GLint location GLsizei bufSize - GLdouble *params + GLdouble *params void glGetnUniformdvARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLdouble *params + GLdouble *params void glGetnUniformfv - GLuint program + GLuint program GLint location GLsizei bufSize - GLfloat *params + GLfloat *params void glGetnUniformfvARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLfloat *params + GLfloat *params void glGetnUniformfvEXT - GLuint program + GLuint program GLint location GLsizei bufSize - GLfloat *params + GLfloat *params void glGetnUniformfvKHR - GLuint program + GLuint program GLint location GLsizei bufSize - GLfloat *params + GLfloat *params void glGetnUniformi64vARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLint64 *params + GLint64 *params void glGetnUniformiv - GLuint program + GLuint program GLint location GLsizei bufSize - GLint *params + GLint *params void glGetnUniformivARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLint *params + GLint *params void glGetnUniformivEXT - GLuint program + GLuint program GLint location GLsizei bufSize - GLint *params + GLint *params void glGetnUniformivKHR - GLuint program + GLuint program GLint location GLsizei bufSize - GLint *params + GLint *params void glGetnUniformui64vARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLuint64 *params + GLuint64 *params void glGetnUniformuiv - GLuint program + GLuint program GLint location GLsizei bufSize - GLuint *params + GLuint *params void glGetnUniformuivARB - GLuint program + GLuint program GLint location GLsizei bufSize - GLuint *params + GLuint *params void glGetnUniformuivKHR - GLuint program + GLuint program GLint location GLsizei bufSize - GLuint *params + GLuint *params @@ -19499,8 +16372,8 @@ typedef unsigned int GLhandleARB; void glIglooInterfaceSGIX - GLenum pname - const void *params + GLenum pname + const void *params @@ -19567,7 +16440,7 @@ typedef unsigned int GLhandleARB; const void *name - GLsync glImportSyncEXT + GLsync glImportSyncEXT GLenum external_sync_type GLintptr external_sync GLbitfield flags @@ -19706,11 +16579,11 @@ typedef unsigned int GLhandleARB; void glInvalidateBufferData - GLuint buffer + GLuint buffer void glInvalidateBufferSubData - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr length @@ -19718,19 +16591,19 @@ typedef unsigned int GLhandleARB; void glInvalidateFramebuffer GLenum target GLsizei numAttachments - const GLenum *attachments + const GLenum *attachments void glInvalidateNamedFramebufferData - GLuint framebuffer + GLuint framebuffer GLsizei numAttachments - const GLenum *attachments + const GLenum *attachments void glInvalidateNamedFramebufferSubData - GLuint framebuffer + GLuint framebuffer GLsizei numAttachments - const GLenum *attachments + const GLenum *attachments GLint x GLint y GLsizei width @@ -19738,9 +16611,9 @@ typedef unsigned int GLhandleARB; void glInvalidateSubFramebuffer - GLenum target + GLenum target GLsizei numAttachments - const GLenum *attachments + const GLenum *attachments GLint x GLint y GLsizei width @@ -19748,12 +16621,12 @@ typedef unsigned int GLhandleARB; void glInvalidateTexImage - GLuint texture + GLuint texture GLint level void glInvalidateTexSubImage - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -19768,11 +16641,11 @@ typedef unsigned int GLhandleARB; GLboolean glIsBuffer - GLuint buffer + GLuint buffer GLboolean glIsBufferARB - GLuint buffer + GLuint buffer @@ -19780,7 +16653,7 @@ typedef unsigned int GLhandleARB; GLenum target - GLboolean glIsCommandListNV + GLboolean glIsCommandListNV GLuint list @@ -19829,21 +16702,21 @@ typedef unsigned int GLhandleARB; GLboolean glIsFramebuffer - GLuint framebuffer + GLuint framebuffer GLboolean glIsFramebufferEXT - GLuint framebuffer + GLuint framebuffer - GLboolean glIsFramebufferOES - GLuint framebuffer + GLboolean glIsFramebufferOES + GLuint framebuffer - GLboolean glIsImageHandleResidentARB + GLboolean glIsImageHandleResidentARB GLuint64 handle @@ -19852,7 +16725,7 @@ typedef unsigned int GLhandleARB; GLboolean glIsList - GLuint list + GLuint list @@ -19866,7 +16739,7 @@ typedef unsigned int GLhandleARB; GLboolean glIsNamedBufferResidentNV - GLuint buffer + GLuint buffer GLboolean glIsNamedStringARB @@ -19875,7 +16748,7 @@ typedef unsigned int GLhandleARB; GLboolean glIsObjectBufferATI - GLuint buffer + GLuint buffer GLboolean glIsOcclusionQueryNV @@ -19900,56 +16773,56 @@ typedef unsigned int GLhandleARB; GLboolean glIsProgram - GLuint program + GLuint program GLboolean glIsProgramARB - GLuint program + GLuint program GLboolean glIsProgramNV - GLuint id + GLuint id GLboolean glIsProgramPipeline - GLuint pipeline + GLuint pipeline - GLboolean glIsProgramPipelineEXT - GLuint pipeline + GLboolean glIsProgramPipelineEXT + GLuint pipeline GLboolean glIsQuery - GLuint id + GLuint id GLboolean glIsQueryARB - GLuint id + GLuint id - GLboolean glIsQueryEXT - GLuint id + GLboolean glIsQueryEXT + GLuint id GLboolean glIsRenderbuffer - GLuint renderbuffer + GLuint renderbuffer GLboolean glIsRenderbufferEXT - GLuint renderbuffer + GLuint renderbuffer - GLboolean glIsRenderbufferOES - GLuint renderbuffer + GLboolean glIsRenderbufferOES + GLuint renderbuffer GLboolean glIsSemaphoreEXT @@ -19957,38 +16830,38 @@ typedef unsigned int GLhandleARB; GLboolean glIsSampler - GLuint sampler + GLuint sampler GLboolean glIsShader - GLuint shader + GLuint shader - GLboolean glIsStateNV + GLboolean glIsStateNV GLuint state GLboolean glIsSync - GLsync sync + GLsync sync - GLboolean glIsSyncAPPLE - GLsync sync + GLboolean glIsSyncAPPLE + GLsync sync GLboolean glIsTexture - GLuint texture + GLuint texture GLboolean glIsTextureEXT - GLuint texture + GLuint texture - GLboolean glIsTextureHandleResidentARB + GLboolean glIsTextureHandleResidentARB GLuint64 handle @@ -19997,11 +16870,11 @@ typedef unsigned int GLhandleARB; GLboolean glIsTransformFeedback - GLuint id + GLuint id GLboolean glIsTransformFeedbackNV - GLuint id + GLuint id @@ -20011,17 +16884,17 @@ typedef unsigned int GLhandleARB; GLboolean glIsVertexArray - GLuint array + GLuint array GLboolean glIsVertexArrayAPPLE - GLuint array + GLuint array - GLboolean glIsVertexArrayOES - GLuint array + GLboolean glIsVertexArrayOES + GLuint array @@ -20055,7 +16928,7 @@ typedef unsigned int GLhandleARB; void glLGPUNamedBufferSubDataNVX GLbitfield gpuMask - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size const void *data @@ -20189,7 +17062,7 @@ typedef unsigned int GLhandleARB; void glLinkProgram - GLuint program + GLuint program void glLinkProgramARB @@ -20205,10 +17078,10 @@ typedef unsigned int GLhandleARB; void glListDrawCommandsStatesClientNV GLuint list GLuint segment - const void **indirects - const GLsizei *sizes - const GLuint *states - const GLuint *fbos + const void **indirects + const GLsizei *sizes + const GLuint *states + const GLuint *fbos GLuint count @@ -20343,11 +17216,11 @@ typedef unsigned int GLhandleARB; void glMakeNamedBufferNonResidentNV - GLuint buffer + GLuint buffer void glMakeNamedBufferResidentNV - GLuint buffer + GLuint buffer GLenum access @@ -20458,7 +17331,7 @@ typedef unsigned int GLhandleARB; GLenum target GLintptr offset GLsizeiptr length - GLbitfield access + GLbitfield access @@ -20466,7 +17339,7 @@ typedef unsigned int GLhandleARB; GLenum target GLintptr offset GLsizeiptr length - GLbitfield access + GLbitfield access @@ -20531,31 +17404,31 @@ typedef unsigned int GLhandleARB; void *glMapNamedBuffer - GLuint buffer + GLuint buffer GLenum access void *glMapNamedBufferEXT - GLuint buffer + GLuint buffer GLenum access void *glMapNamedBufferRange - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr length - GLbitfield access + GLbitfield access void *glMapNamedBufferRangeEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr length - GLbitfield access + GLbitfield access void *glMapObjectBufferATI - GLuint buffer + GLuint buffer void glMapParameterfvNV @@ -20571,7 +17444,7 @@ typedef unsigned int GLhandleARB; void *glMapTexture2DINTEL - GLuint texture + GLuint texture GLint level GLbitfield access GLint *stride @@ -20960,15 +17833,15 @@ typedef unsigned int GLhandleARB; void glMultiDrawArrays GLenum mode - const GLint *first - const GLsizei *count + const GLint *first + const GLsizei *count GLsizei drawcount void glMultiDrawArraysEXT GLenum mode - const GLint *first - const GLsizei *count + const GLint *first + const GLsizei *count GLsizei primcount @@ -20982,7 +17855,7 @@ typedef unsigned int GLhandleARB; void glMultiDrawArraysIndirectAMD GLenum mode - const void *indirect + const void *indirect GLsizei primcount GLsizei stride @@ -21039,36 +17912,36 @@ typedef unsigned int GLhandleARB; void glMultiDrawElements GLenum mode - const GLsizei *count + const GLsizei *count GLenum type - const void *const*indices + const void *const*indices GLsizei drawcount void glMultiDrawElementsBaseVertex GLenum mode - const GLsizei *count + const GLsizei *count GLenum type - const void *const*indices + const void *const*indices GLsizei drawcount - const GLint *basevertex + const GLint *basevertex void glMultiDrawElementsBaseVertexEXT GLenum mode - const GLsizei *count + const GLsizei *count GLenum type - const void *const*indices - GLsizei primcount - const GLint *basevertex + const void *const*indices + GLsizei drawcount + const GLint *basevertex void glMultiDrawElementsEXT GLenum mode - const GLsizei *count + const GLsizei *count GLenum type - const void *const*indices + const void *const*indices GLsizei primcount @@ -21084,7 +17957,7 @@ typedef unsigned int GLhandleARB; void glMultiDrawElementsIndirectAMD GLenum mode GLenum type - const void *indirect + const void *indirect GLsizei primcount GLsizei stride @@ -21111,7 +17984,7 @@ typedef unsigned int GLhandleARB; void glMultiDrawElementsIndirectCount GLenum mode - GLenum type + GLenum type const void *indirect GLintptr drawcount GLsizei maxdrawcount @@ -21136,6 +18009,19 @@ typedef unsigned int GLhandleARB; GLsizei stride + + void glMultiDrawMeshTasksIndirectNV + GLintptr indirect + GLsizei drawcount + GLsizei stride + + + void glMultiDrawMeshTasksIndirectCountNV + GLintptr indirect + GLintptr drawcount + GLsizei maxdrawcount + GLsizei stride + void glMultiDrawRangeElementArrayAPPLE GLenum mode @@ -21147,18 +18033,18 @@ typedef unsigned int GLhandleARB; void glMultiModeDrawArraysIBM - const GLenum *mode - const GLint *first - const GLsizei *count + const GLenum *mode + const GLint *first + const GLsizei *count GLsizei primcount GLint modestride void glMultiModeDrawElementsIBM - const GLenum *mode - const GLsizei *count + const GLenum *mode + const GLsizei *count GLenum type - const void *const*indices + const void *const*indices GLsizei primcount GLint modestride @@ -21166,8 +18052,8 @@ typedef unsigned int GLhandleARB; void glMultiTexBufferEXT GLenum texunit GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glMultiTexCoord1bOES @@ -22005,7 +18891,7 @@ typedef unsigned int GLhandleARB; void glMultiTexRenderbufferEXT GLenum texunit GLenum target - GLuint renderbuffer + GLuint renderbuffer void glMultiTexSubImage1DEXT @@ -22067,7 +18953,7 @@ typedef unsigned int GLhandleARB; void glMulticastBufferSubDataNV GLbitfield gpuMask - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size const void *data @@ -22076,8 +18962,8 @@ typedef unsigned int GLhandleARB; void glMulticastCopyBufferSubDataNV GLuint readGpu GLbitfield writeGpuMask - GLuint readBuffer - GLuint writeBuffer + GLuint readBuffer + GLuint writeBuffer GLintptr readOffset GLintptr writeOffset GLsizeiptr size @@ -22105,7 +18991,7 @@ typedef unsigned int GLhandleARB; void glMulticastFramebufferSampleLocationsfvNV GLuint gpu - GLuint framebuffer + GLuint framebuffer GLuint start GLsizei count const GLfloat *v @@ -22138,79 +19024,115 @@ typedef unsigned int GLhandleARB; GLenum pname GLuint *params + + void glMulticastScissorArrayvNVX + GLuint gpu + GLuint first + GLsizei count + const GLint *v + + + void glMulticastViewportArrayvNVX + GLuint gpu + GLuint first + GLsizei count + const GLfloat *v + + + void glMulticastViewportPositionWScaleNVX + GLuint gpu + GLuint index + GLfloat xcoeff + GLfloat ycoeff + void glMulticastWaitSyncNV GLuint signalGpu GLbitfield waitGpuMask + + void glNamedBufferAttachMemoryNV + GLuint buffer + GLuint memory + GLuint64 offset + void glNamedBufferData - GLuint buffer + GLuint buffer GLsizeiptr size - const void *data + const void *data GLenum usage void glNamedBufferDataEXT - GLuint buffer + GLuint buffer GLsizeiptr size const void *data GLenum usage void glNamedBufferPageCommitmentARB - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size - GLboolean commit + GLboolean commit void glNamedBufferPageCommitmentEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size - GLboolean commit + GLboolean commit + + + void glNamedBufferPageCommitmentMemNV + GLuint buffer + GLintptr offset + GLsizeiptr size + GLuint memory + GLuint64 memOffset + GLboolean commit void glNamedBufferStorage - GLuint buffer + GLuint buffer GLsizeiptr size const void *data - GLbitfield flags + GLbitfield flags void glNamedBufferStorageExternalEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size GLeglClientBufferEXT clientBuffer - GLbitfield flags + GLbitfield flags void glNamedBufferStorageEXT - GLuint buffer + GLuint buffer GLsizeiptr size const void *data - GLbitfield flags + GLbitfield flags void glNamedBufferStorageMemEXT - GLuint buffer + GLuint buffer GLsizeiptr size GLuint memory GLuint64 offset void glNamedBufferSubData - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size - const void *data + const void *data void glNamedBufferSubDataEXT - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size const void *data @@ -22218,141 +19140,141 @@ typedef unsigned int GLhandleARB; void glNamedCopyBufferSubDataEXT - GLuint readBuffer - GLuint writeBuffer + GLuint readBuffer + GLuint writeBuffer GLintptr readOffset GLintptr writeOffset GLsizeiptr size void glNamedFramebufferDrawBuffer - GLuint framebuffer + GLuint framebuffer GLenum buf void glNamedFramebufferDrawBuffers - GLuint framebuffer + GLuint framebuffer GLsizei n - const GLenum *bufs + const GLenum *bufs void glNamedFramebufferParameteri - GLuint framebuffer + GLuint framebuffer GLenum pname GLint param void glNamedFramebufferParameteriEXT - GLuint framebuffer + GLuint framebuffer GLenum pname GLint param void glNamedFramebufferReadBuffer - GLuint framebuffer + GLuint framebuffer GLenum src void glNamedFramebufferRenderbuffer - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum renderbuffertarget - GLuint renderbuffer + GLuint renderbuffer void glNamedFramebufferRenderbufferEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum renderbuffertarget - GLuint renderbuffer + GLuint renderbuffer void glNamedFramebufferSampleLocationsfvARB - GLuint framebuffer + GLuint framebuffer GLuint start GLsizei count const GLfloat *v void glNamedFramebufferSampleLocationsfvNV - GLuint framebuffer + GLuint framebuffer GLuint start GLsizei count const GLfloat *v void glNamedFramebufferTexture - GLuint framebuffer + GLuint framebuffer GLenum attachment - GLuint texture + GLuint texture GLint level void glNamedFramebufferSamplePositionsfvAMD - GLuint framebuffer + GLuint framebuffer GLuint numsamples GLuint pixelindex const GLfloat *values void glNamedFramebufferTexture1DEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level void glNamedFramebufferTexture2DEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level void glNamedFramebufferTexture3DEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment GLenum textarget - GLuint texture + GLuint texture GLint level GLint zoffset void glNamedFramebufferTextureEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment - GLuint texture + GLuint texture GLint level void glNamedFramebufferTextureFaceEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment - GLuint texture + GLuint texture GLint level GLenum face void glNamedFramebufferTextureLayer - GLuint framebuffer + GLuint framebuffer GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer void glNamedFramebufferTextureLayerEXT - GLuint framebuffer + GLuint framebuffer GLenum attachment - GLuint texture + GLuint texture GLint level GLint layer void glNamedProgramLocalParameter4dEXT - GLuint program + GLuint program GLenum target GLuint index GLdouble x @@ -22363,14 +19285,14 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParameter4dvEXT - GLuint program + GLuint program GLenum target GLuint index const GLdouble *params void glNamedProgramLocalParameter4fEXT - GLuint program + GLuint program GLenum target GLuint index GLfloat x @@ -22381,14 +19303,14 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParameter4fvEXT - GLuint program + GLuint program GLenum target GLuint index const GLfloat *params void glNamedProgramLocalParameterI4iEXT - GLuint program + GLuint program GLenum target GLuint index GLint x @@ -22399,14 +19321,14 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParameterI4ivEXT - GLuint program + GLuint program GLenum target GLuint index const GLint *params void glNamedProgramLocalParameterI4uiEXT - GLuint program + GLuint program GLenum target GLuint index GLuint x @@ -22417,14 +19339,14 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParameterI4uivEXT - GLuint program + GLuint program GLenum target GLuint index const GLuint *params void glNamedProgramLocalParameters4fvEXT - GLuint program + GLuint program GLenum target GLuint index GLsizei count @@ -22432,7 +19354,7 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParametersI4ivEXT - GLuint program + GLuint program GLenum target GLuint index GLsizei count @@ -22440,7 +19362,7 @@ typedef unsigned int GLhandleARB; void glNamedProgramLocalParametersI4uivEXT - GLuint program + GLuint program GLenum target GLuint index GLsizei count @@ -22448,7 +19370,7 @@ typedef unsigned int GLhandleARB; void glNamedProgramStringEXT - GLuint program + GLuint program GLenum target GLenum format GLsizei len @@ -22456,29 +19378,38 @@ typedef unsigned int GLhandleARB; void glNamedRenderbufferStorage - GLuint renderbuffer + GLuint renderbuffer GLenum internalformat GLsizei width GLsizei height void glNamedRenderbufferStorageEXT - GLuint renderbuffer + GLuint renderbuffer GLenum internalformat GLsizei width GLsizei height void glNamedRenderbufferStorageMultisample - GLuint renderbuffer + GLuint renderbuffer GLsizei samples GLenum internalformat GLsizei width GLsizei height + + void glNamedRenderbufferStorageMultisampleAdvancedAMD + GLuint renderbuffer + GLsizei samples + GLsizei storageSamples + GLenum internalformat + GLsizei width + GLsizei height + void glNamedRenderbufferStorageMultisampleCoverageEXT - GLuint renderbuffer + GLuint renderbuffer GLsizei coverageSamples GLsizei colorSamples GLenum internalformat @@ -22487,7 +19418,7 @@ typedef unsigned int GLhandleARB; void glNamedRenderbufferStorageMultisampleEXT - GLuint renderbuffer + GLuint renderbuffer GLsizei samples GLenum internalformat GLsizei width @@ -22814,8 +19745,8 @@ typedef unsigned int GLhandleARB; void glPassTexCoordATI - GLuint dst - GLuint coord + GLuint dst + GLuint coord GLenum swizzle @@ -22904,7 +19835,7 @@ typedef unsigned int GLhandleARB; GLbitfield fontStyle GLuint pathParameterTemplate GLfloat emScale - GLuint baseAndCount[2] + GLuint *baseAndCount void glPathGlyphRangeNV @@ -23457,14 +20388,14 @@ typedef unsigned int GLhandleARB; void glPrioritizeTextures GLsizei n - const GLuint *textures + const GLuint *textures const GLfloat *priorities void glPrioritizeTexturesEXT GLsizei n - const GLuint *textures + const GLuint *textures const GLclampf *priorities @@ -23472,19 +20403,19 @@ typedef unsigned int GLhandleARB; void glPrioritizeTexturesxOES GLsizei n - const GLuint *textures + const GLuint *textures const GLfixed *priorities void glProgramBinary - GLuint program + GLuint program GLenum binaryFormat const void *binary GLsizei length void glProgramBinaryOES - GLuint program + GLuint program GLenum binaryFormat const void *binary GLint length @@ -23516,7 +20447,7 @@ typedef unsigned int GLhandleARB; void glProgramEnvParameter4dARB - GLenum target + GLenum target GLuint index GLdouble x GLdouble y @@ -23526,13 +20457,13 @@ typedef unsigned int GLhandleARB; void glProgramEnvParameter4dvARB - GLenum target + GLenum target GLuint index const GLdouble *params void glProgramEnvParameter4fARB - GLenum target + GLenum target GLuint index GLfloat x GLfloat y @@ -23542,7 +20473,7 @@ typedef unsigned int GLhandleARB; void glProgramEnvParameter4fvARB - GLenum target + GLenum target GLuint index const GLfloat *params @@ -23580,7 +20511,7 @@ typedef unsigned int GLhandleARB; void glProgramEnvParameters4fvEXT - GLenum target + GLenum target GLuint index GLsizei count const GLfloat *params @@ -23602,7 +20533,7 @@ typedef unsigned int GLhandleARB; void glProgramLocalParameter4dARB - GLenum target + GLenum target GLuint index GLdouble x GLdouble y @@ -23612,13 +20543,13 @@ typedef unsigned int GLhandleARB; void glProgramLocalParameter4dvARB - GLenum target + GLenum target GLuint index const GLdouble *params void glProgramLocalParameter4fARB - GLenum target + GLenum target GLuint index GLfloat x GLfloat y @@ -23628,7 +20559,7 @@ typedef unsigned int GLhandleARB; void glProgramLocalParameter4fvARB - GLenum target + GLenum target GLuint index const GLfloat *params @@ -23666,7 +20597,7 @@ typedef unsigned int GLhandleARB; void glProgramLocalParameters4fvEXT - GLenum target + GLenum target GLuint index GLsizei count const GLfloat *params @@ -23688,7 +20619,7 @@ typedef unsigned int GLhandleARB; void glProgramNamedParameter4dNV - GLuint id + GLuint id GLsizei len const GLubyte *name GLdouble x @@ -23699,7 +20630,7 @@ typedef unsigned int GLhandleARB; void glProgramNamedParameter4dvNV - GLuint id + GLuint id GLsizei len const GLubyte *name const GLdouble *v @@ -23707,7 +20638,7 @@ typedef unsigned int GLhandleARB; void glProgramNamedParameter4fNV - GLuint id + GLuint id GLsizei len const GLubyte *name GLfloat x @@ -23718,7 +20649,7 @@ typedef unsigned int GLhandleARB; void glProgramNamedParameter4fvNV - GLuint id + GLuint id GLsizei len const GLubyte *name const GLfloat *v @@ -23760,20 +20691,20 @@ typedef unsigned int GLhandleARB; void glProgramParameteri - GLuint program + GLuint program GLenum pname GLint value void glProgramParameteriARB - GLuint program + GLuint program GLenum pname GLint value void glProgramParameteriEXT - GLuint program + GLuint program GLenum pname GLint value @@ -23796,7 +20727,7 @@ typedef unsigned int GLhandleARB; void glProgramPathFragmentInputGenNV - GLuint program + GLuint program GLint location GLenum genMode GLint components @@ -23804,8 +20735,8 @@ typedef unsigned int GLhandleARB; void glProgramStringARB - GLenum target - GLenum format + GLenum target + GLenum format GLsizei len const void *string @@ -23817,53 +20748,53 @@ typedef unsigned int GLhandleARB; void glProgramUniform1d - GLuint program + GLuint program GLint location GLdouble v0 void glProgramUniform1dEXT - GLuint program + GLuint program GLint location GLdouble x void glProgramUniform1dv - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform1dvEXT - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform1f - GLuint program + GLuint program GLint location GLfloat v0 void glProgramUniform1fEXT - GLuint program + GLuint program GLint location GLfloat v0 void glProgramUniform1fv - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value void glProgramUniform1fvEXT - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value @@ -23871,53 +20802,53 @@ typedef unsigned int GLhandleARB; void glProgramUniform1i - GLuint program + GLuint program GLint location GLint v0 void glProgramUniform1i64ARB - GLuint program + GLuint program GLint location GLint64 x void glProgramUniform1i64NV - GLuint program + GLuint program GLint location GLint64EXT x void glProgramUniform1i64vARB - GLuint program + GLuint program GLint location GLsizei count const GLint64 *value void glProgramUniform1i64vNV - GLuint program + GLuint program GLint location GLsizei count const GLint64EXT *value void glProgramUniform1iEXT - GLuint program + GLuint program GLint location GLint v0 void glProgramUniform1iv - GLuint program + GLuint program GLint location GLsizei count const GLint *value void glProgramUniform1ivEXT - GLuint program + GLuint program GLint location GLsizei count const GLint *value @@ -23925,53 +20856,53 @@ typedef unsigned int GLhandleARB; void glProgramUniform1ui - GLuint program + GLuint program GLint location GLuint v0 void glProgramUniform1ui64ARB - GLuint program + GLuint program GLint location GLuint64 x void glProgramUniform1ui64NV - GLuint program + GLuint program GLint location GLuint64EXT x void glProgramUniform1ui64vARB - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *value void glProgramUniform1ui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64EXT *value void glProgramUniform1uiEXT - GLuint program + GLuint program GLint location GLuint v0 void glProgramUniform1uiv - GLuint program + GLuint program GLint location GLsizei count const GLuint *value void glProgramUniform1uivEXT - GLuint program + GLuint program GLint location GLsizei count const GLuint *value @@ -23979,42 +20910,42 @@ typedef unsigned int GLhandleARB; void glProgramUniform2d - GLuint program + GLuint program GLint location GLdouble v0 GLdouble v1 void glProgramUniform2dEXT - GLuint program + GLuint program GLint location GLdouble x GLdouble y void glProgramUniform2dv - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform2dvEXT - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform2f - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 void glProgramUniform2fEXT - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 @@ -24022,14 +20953,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform2fv - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value void glProgramUniform2fvEXT - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value @@ -24037,42 +20968,42 @@ typedef unsigned int GLhandleARB; void glProgramUniform2i - GLuint program + GLuint program GLint location GLint v0 GLint v1 void glProgramUniform2i64ARB - GLuint program + GLuint program GLint location GLint64 x GLint64 y void glProgramUniform2i64NV - GLuint program + GLuint program GLint location GLint64EXT x GLint64EXT y void glProgramUniform2i64vARB - GLuint program + GLuint program GLint location GLsizei count const GLint64 *value void glProgramUniform2i64vNV - GLuint program + GLuint program GLint location GLsizei count const GLint64EXT *value void glProgramUniform2iEXT - GLuint program + GLuint program GLint location GLint v0 GLint v1 @@ -24080,14 +21011,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform2iv - GLuint program + GLuint program GLint location GLsizei count const GLint *value void glProgramUniform2ivEXT - GLuint program + GLuint program GLint location GLsizei count const GLint *value @@ -24095,42 +21026,42 @@ typedef unsigned int GLhandleARB; void glProgramUniform2ui - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 void glProgramUniform2ui64ARB - GLuint program + GLuint program GLint location GLuint64 x GLuint64 y void glProgramUniform2ui64NV - GLuint program + GLuint program GLint location GLuint64EXT x GLuint64EXT y void glProgramUniform2ui64vARB - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *value void glProgramUniform2ui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64EXT *value void glProgramUniform2uiEXT - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 @@ -24138,14 +21069,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform2uiv - GLuint program + GLuint program GLint location GLsizei count const GLuint *value void glProgramUniform2uivEXT - GLuint program + GLuint program GLint location GLsizei count const GLuint *value @@ -24153,7 +21084,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3d - GLuint program + GLuint program GLint location GLdouble v0 GLdouble v1 @@ -24161,7 +21092,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3dEXT - GLuint program + GLuint program GLint location GLdouble x GLdouble y @@ -24169,21 +21100,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform3dv - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform3dvEXT - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform3f - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 @@ -24191,7 +21122,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3fEXT - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 @@ -24200,14 +21131,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform3fv - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value void glProgramUniform3fvEXT - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value @@ -24215,7 +21146,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3i - GLuint program + GLuint program GLint location GLint v0 GLint v1 @@ -24223,7 +21154,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3i64ARB - GLuint program + GLuint program GLint location GLint64 x GLint64 y @@ -24231,7 +21162,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3i64NV - GLuint program + GLuint program GLint location GLint64EXT x GLint64EXT y @@ -24239,21 +21170,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform3i64vARB - GLuint program + GLuint program GLint location GLsizei count const GLint64 *value void glProgramUniform3i64vNV - GLuint program + GLuint program GLint location GLsizei count const GLint64EXT *value void glProgramUniform3iEXT - GLuint program + GLuint program GLint location GLint v0 GLint v1 @@ -24262,14 +21193,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform3iv - GLuint program + GLuint program GLint location GLsizei count const GLint *value void glProgramUniform3ivEXT - GLuint program + GLuint program GLint location GLsizei count const GLint *value @@ -24277,7 +21208,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3ui - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 @@ -24285,7 +21216,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3ui64ARB - GLuint program + GLuint program GLint location GLuint64 x GLuint64 y @@ -24293,7 +21224,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform3ui64NV - GLuint program + GLuint program GLint location GLuint64EXT x GLuint64EXT y @@ -24301,21 +21232,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform3ui64vARB - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *value void glProgramUniform3ui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64EXT *value void glProgramUniform3uiEXT - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 @@ -24324,14 +21255,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform3uiv - GLuint program + GLuint program GLint location GLsizei count const GLuint *value void glProgramUniform3uivEXT - GLuint program + GLuint program GLint location GLsizei count const GLuint *value @@ -24339,7 +21270,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4d - GLuint program + GLuint program GLint location GLdouble v0 GLdouble v1 @@ -24348,7 +21279,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4dEXT - GLuint program + GLuint program GLint location GLdouble x GLdouble y @@ -24357,21 +21288,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform4dv - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform4dvEXT - GLuint program + GLuint program GLint location GLsizei count const GLdouble *value void glProgramUniform4f - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 @@ -24380,7 +21311,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4fEXT - GLuint program + GLuint program GLint location GLfloat v0 GLfloat v1 @@ -24390,14 +21321,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform4fv - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value void glProgramUniform4fvEXT - GLuint program + GLuint program GLint location GLsizei count const GLfloat *value @@ -24405,7 +21336,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4i - GLuint program + GLuint program GLint location GLint v0 GLint v1 @@ -24414,7 +21345,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4i64ARB - GLuint program + GLuint program GLint location GLint64 x GLint64 y @@ -24423,7 +21354,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4i64NV - GLuint program + GLuint program GLint location GLint64EXT x GLint64EXT y @@ -24432,21 +21363,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform4i64vARB - GLuint program + GLuint program GLint location GLsizei count const GLint64 *value void glProgramUniform4i64vNV - GLuint program + GLuint program GLint location GLsizei count const GLint64EXT *value void glProgramUniform4iEXT - GLuint program + GLuint program GLint location GLint v0 GLint v1 @@ -24456,14 +21387,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform4iv - GLuint program + GLuint program GLint location GLsizei count const GLint *value void glProgramUniform4ivEXT - GLuint program + GLuint program GLint location GLsizei count const GLint *value @@ -24471,7 +21402,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4ui - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 @@ -24480,7 +21411,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4ui64ARB - GLuint program + GLuint program GLint location GLuint64 x GLuint64 y @@ -24489,7 +21420,7 @@ typedef unsigned int GLhandleARB; void glProgramUniform4ui64NV - GLuint program + GLuint program GLint location GLuint64EXT x GLuint64EXT y @@ -24498,21 +21429,21 @@ typedef unsigned int GLhandleARB; void glProgramUniform4ui64vARB - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *value void glProgramUniform4ui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64EXT *value void glProgramUniform4uiEXT - GLuint program + GLuint program GLint location GLuint v0 GLuint v1 @@ -24522,14 +21453,14 @@ typedef unsigned int GLhandleARB; void glProgramUniform4uiv - GLuint program + GLuint program GLint location GLsizei count const GLuint *value void glProgramUniform4uivEXT - GLuint program + GLuint program GLint location GLsizei count const GLuint *value @@ -24537,33 +21468,33 @@ typedef unsigned int GLhandleARB; void glProgramUniformHandleui64ARB - GLuint program + GLuint program GLint location GLuint64 value void glProgramUniformHandleui64IMG - GLuint program + GLuint program GLint location GLuint64 value void glProgramUniformHandleui64NV - GLuint program + GLuint program GLint location GLuint64 value void glProgramUniformHandleui64vARB - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *values void glProgramUniformHandleui64vIMG - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *values @@ -24571,14 +21502,14 @@ typedef unsigned int GLhandleARB; void glProgramUniformHandleui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64 *values void glProgramUniformMatrix2dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24586,7 +21517,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24594,7 +21525,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24602,7 +21533,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24611,7 +21542,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x3dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24619,7 +21550,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x3dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24627,7 +21558,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x3fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24635,7 +21566,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x3fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24644,7 +21575,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x4dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24652,7 +21583,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x4dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24660,7 +21591,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x4fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24668,7 +21599,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix2x4fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24677,7 +21608,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24685,7 +21616,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24693,7 +21624,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24701,7 +21632,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24710,7 +21641,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x2dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24718,7 +21649,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x2dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24726,7 +21657,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x2fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24734,7 +21665,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x2fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24743,7 +21674,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x4dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24751,7 +21682,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x4dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24759,7 +21690,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x4fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24767,7 +21698,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix3x4fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24776,7 +21707,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24784,7 +21715,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24792,7 +21723,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24800,7 +21731,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24809,7 +21740,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x2dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24817,7 +21748,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x2dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24825,7 +21756,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x2fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24833,7 +21764,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x2fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24842,7 +21773,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x3dv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24850,7 +21781,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x3dvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24858,7 +21789,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x3fv - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24866,7 +21797,7 @@ typedef unsigned int GLhandleARB; void glProgramUniformMatrix4x3fvEXT - GLuint program + GLuint program GLint location GLsizei count GLboolean transpose @@ -24875,13 +21806,13 @@ typedef unsigned int GLhandleARB; void glProgramUniformui64NV - GLuint program + GLuint program GLint location GLuint64EXT value void glProgramUniformui64vNV - GLuint program + GLuint program GLint location GLsizei count const GLuint64EXT *value @@ -24944,13 +21875,13 @@ typedef unsigned int GLhandleARB; void glQueryCounter - GLuint id - GLenum target + GLuint id + GLenum target void glQueryCounterEXT - GLuint id - GLenum target + GLuint id + GLenum target @@ -24961,7 +21892,7 @@ typedef unsigned int GLhandleARB; void glQueryObjectParameteruiAMD GLenum target - GLuint id + GLuint id GLenum pname GLuint param @@ -24969,8 +21900,8 @@ typedef unsigned int GLhandleARB; GLint glQueryResourceNV GLenum queryType GLint tagId - GLuint bufSize - GLint *buffer + GLuint count + GLint *buffer void glQueryResourceTagNV @@ -25154,7 +22085,7 @@ typedef unsigned int GLhandleARB; void glRasterSamplesEXT GLuint samples - GLboolean fixedsamplelocations + GLboolean fixedsamplelocations void glReadBuffer @@ -25235,7 +22166,7 @@ typedef unsigned int GLhandleARB; - GLboolean glReleaseKeyedMutexWin32EXT + GLboolean glReleaseKeyedMutexWin32EXT GLuint memory GLuint64 key @@ -25366,6 +22297,15 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height + + void glRenderbufferStorageMultisampleAdvancedAMD + GLenum target + GLsizei samples + GLsizei storageSamples + GLenum internalformat + GLsizei width + GLsizei height + void glRenderbufferStorageMultisampleCoverageNV GLenum target @@ -25582,7 +22522,7 @@ typedef unsigned int GLhandleARB; void glRequestResidentProgramsNV GLsizei n - const GLuint *programs + const GLuint *programs @@ -25596,6 +22536,11 @@ typedef unsigned int GLhandleARB; + + void glResetMemoryObjectParameterNV + GLuint memory + GLenum pname + void glResetMinmax GLenum target @@ -25668,17 +22613,17 @@ typedef unsigned int GLhandleARB; void glSampleCoveragex GLclampx value - GLboolean invert + GLboolean invert void glSampleCoveragexOES GLclampx value - GLboolean invert + GLboolean invert void glSampleMapATI - GLuint dst - GLuint interp + GLuint dst + GLuint interp GLenum swizzle @@ -25715,66 +22660,66 @@ typedef unsigned int GLhandleARB; void glSamplerParameterIiv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLint *param void glSamplerParameterIivEXT - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLint *param void glSamplerParameterIivOES - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLint *param void glSamplerParameterIuiv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLuint *param void glSamplerParameterIuivEXT - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLuint *param void glSamplerParameterIuivOES - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLuint *param void glSamplerParameterf - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLfloat param void glSamplerParameterfv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLfloat *param void glSamplerParameteri - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname GLint param void glSamplerParameteriv - GLuint sampler - GLenum pname + GLuint sampler + GLenum pname const GLint *param @@ -25831,6 +22776,19 @@ typedef unsigned int GLhandleARB; const GLint *v + + void glScissorExclusiveArrayvNV + GLuint first + GLsizei count + const GLint *v + + + void glScissorExclusiveNV + GLint x + GLint y + GLsizei width + GLsizei height + void glScissorIndexed GLuint index @@ -26147,6 +23105,12 @@ typedef unsigned int GLhandleARB; GLint numCounters GLuint *counterList + + void glSemaphoreParameterivNV + GLuint semaphore + GLenum pname + const GLint *params + void glSemaphoreParameterui64vEXT GLuint semaphore @@ -26190,7 +23154,7 @@ typedef unsigned int GLhandleARB; void glSetFragmentShaderConstantATI - GLuint dst + GLuint dst const GLfloat *value @@ -26219,8 +23183,8 @@ typedef unsigned int GLhandleARB; void glShaderBinary GLsizei count - const GLuint *shaders - GLenum binaryformat + const GLuint *shaders + GLenum binaryFormat const void *binary GLsizei length @@ -26247,7 +23211,7 @@ typedef unsigned int GLhandleARB; void glShaderSource - GLuint shader + GLuint shader GLsizei count const GLchar *const*string const GLint *length @@ -26262,14 +23226,44 @@ typedef unsigned int GLhandleARB; void glShaderStorageBlockBinding - GLuint program + GLuint program GLuint storageBlockIndex GLuint storageBlockBinding - void glShadingRateQCOM + void glShadingRateEXT GLenum rate + + void glShadingRateCombinerOpsEXT + GLenum combinerOp0 + GLenum combinerOp1 + + + void glShadingRateImageBarrierNV + GLboolean synchronize + + + void glShadingRateQCOM + GLenum rate + + + void glShadingRateImagePaletteNV + GLuint viewport + GLuint first + GLsizei count + const GLenum *rates + + + void glShadingRateSampleOrderNV + GLenum order + + + void glShadingRateSampleOrderCustomNV + GLenum rate + GLuint samples + const GLint *locations + void glSharpenTexFuncSGIS GLenum target @@ -26281,22 +23275,29 @@ typedef unsigned int GLhandleARB; void glSignalSemaphoreEXT GLuint semaphore GLuint numBufferBarriers - const GLuint *buffers + const GLuint *buffers GLuint numTextureBarriers - const GLuint *textures + const GLuint *textures const GLenum *dstLayouts + + void glSignalSemaphoreui64NVX + GLuint signalGpu + GLsizei fenceObjectCount + const GLuint *semaphoreArray + const GLuint64 *fenceValueArray + void glSpecializeShader - GLuint shader + GLuint shader const GLchar *pEntryPoint GLuint numSpecializationConstants - const GLuint *pConstantIndex - const GLuint *pConstantValue + const GLuint *pConstantIndex + const GLuint *pConstantValue void glSpecializeShaderARB - GLuint shader + GLuint shader const GLchar *pEntryPoint GLuint numSpecializationConstants const GLuint *pConstantIndex @@ -26506,7 +23507,7 @@ typedef unsigned int GLhandleARB; void glSyncTextureINTEL - GLuint texture + GLuint texture void glTagSampleBufferSGIX @@ -26599,47 +23600,53 @@ typedef unsigned int GLhandleARB; GLenum object GLuint name + + void glTexAttachMemoryNV + GLenum target + GLuint memory + GLuint64 offset + void glTexBuffer GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glTexBufferARB GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glTexBufferEXT GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glTexBufferOES GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glTexBufferRange GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer GLintptr offset GLsizeiptr size void glTexBufferRangeEXT GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer GLintptr offset GLsizeiptr size @@ -26647,8 +23654,8 @@ typedef unsigned int GLhandleARB; void glTexBufferRangeOES GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer GLintptr offset GLsizeiptr size @@ -27224,6 +24231,26 @@ typedef unsigned int GLhandleARB; GLenum pname const GLfixed *params + + void glTexEstimateMotionQCOM + GLuint ref + GLuint target + GLuint output + + + void glTexEstimateMotionRegionsQCOM + GLuint ref + GLuint target + GLuint output + GLuint mask + + + void glExtrapolateTex2DQCOM + GLuint src1 + GLuint src2 + GLuint output + GLfloat scaleFactor + void glTexFilterFuncSGIS GLenum target @@ -27351,7 +24378,7 @@ typedef unsigned int GLhandleARB; GLenum target GLsizei coverageSamples GLsizei colorSamples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLboolean fixedSampleLocations @@ -27401,7 +24428,7 @@ typedef unsigned int GLhandleARB; GLenum target GLsizei coverageSamples GLsizei colorSamples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLsizei depth @@ -27445,7 +24472,7 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLboolean commit + GLboolean commit void glTexPageCommitmentEXT @@ -27457,9 +24484,24 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLboolean commit + GLboolean commit + + void glTexPageCommitmentMemNV + GLenum target + GLint layer + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLuint memory + GLuint64 offset + GLboolean commit + void glTexParameterIiv GLenum target @@ -27557,20 +24599,20 @@ typedef unsigned int GLhandleARB; void glTexRenderbufferNV GLenum target - GLuint renderbuffer + GLuint renderbuffer void glTexStorage1D GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width void glTexStorage1DEXT GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width @@ -27578,7 +24620,7 @@ typedef unsigned int GLhandleARB; void glTexStorage2D GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height @@ -27586,7 +24628,7 @@ typedef unsigned int GLhandleARB; void glTexStorage2DEXT GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height @@ -27595,7 +24637,7 @@ typedef unsigned int GLhandleARB; void glTexStorage2DMultisample GLenum target GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLboolean fixedsamplelocations @@ -27604,7 +24646,7 @@ typedef unsigned int GLhandleARB; void glTexStorage3D GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth @@ -27613,7 +24655,7 @@ typedef unsigned int GLhandleARB; void glTexStorage3DEXT GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth @@ -27623,7 +24665,7 @@ typedef unsigned int GLhandleARB; void glTexStorage3DMultisample GLenum target GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth @@ -27633,18 +24675,37 @@ typedef unsigned int GLhandleARB; void glTexStorage3DMultisampleOES GLenum target GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth GLboolean fixedsamplelocations + + void glTexStorageAttribs2DEXT + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + const GLint* attrib_list + + + void glTexStorageAttribs3DEXT + GLenum target + GLsizei levels + GLenum internalformat + GLsizei width + GLsizei height + GLsizei depth + const GLint* attrib_list + void glTexStorageMem1DEXT GLenum target GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLuint memory GLuint64 offset @@ -27653,7 +24714,7 @@ typedef unsigned int GLhandleARB; void glTexStorageMem2DEXT GLenum target GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLuint memory @@ -27663,10 +24724,10 @@ typedef unsigned int GLhandleARB; void glTexStorageMem2DMultisampleEXT GLenum target GLsizei samples - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height - GLboolean fixedSampleLocations + GLboolean fixedSampleLocations GLuint memory GLuint64 offset @@ -27674,7 +24735,7 @@ typedef unsigned int GLhandleARB; void glTexStorageMem3DEXT GLenum target GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth @@ -27685,18 +24746,18 @@ typedef unsigned int GLhandleARB; void glTexStorageMem3DMultisampleEXT GLenum target GLsizei samples - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth - GLboolean fixedSampleLocations + GLboolean fixedSampleLocations GLuint memory GLuint64 offset void glTexStorageSparseAMD GLenum target - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth @@ -27818,6 +24879,12 @@ typedef unsigned int GLhandleARB; const void *pixels + + void glTextureAttachMemoryNV + GLuint texture + GLuint memory + GLuint64 offset + void glTextureBarrier @@ -27827,31 +24894,31 @@ typedef unsigned int GLhandleARB; void glTextureBuffer - GLuint texture - GLenum internalformat - GLuint buffer + GLuint texture + GLenum internalformat + GLuint buffer void glTextureBufferEXT - GLuint texture + GLuint texture GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer void glTextureBufferRange - GLuint texture - GLenum internalformat - GLuint buffer + GLuint texture + GLenum internalformat + GLuint buffer GLintptr offset GLsizeiptr size void glTextureBufferRangeEXT - GLuint texture + GLuint texture GLenum target - GLenum internalformat - GLuint buffer + GLenum internalformat + GLuint buffer GLintptr offset GLsizeiptr size @@ -27865,7 +24932,7 @@ typedef unsigned int GLhandleARB; void glTextureFoveationParametersQCOM - GLuint texture + GLuint texture GLuint layer GLuint focalPoint GLfloat focalX @@ -27876,7 +24943,7 @@ typedef unsigned int GLhandleARB; void glTextureImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint internalformat @@ -27888,7 +24955,7 @@ typedef unsigned int GLhandleARB; void glTextureImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint internalformat @@ -27901,28 +24968,28 @@ typedef unsigned int GLhandleARB; void glTextureImage2DMultisampleCoverageNV - GLuint texture + GLuint texture GLenum target GLsizei coverageSamples GLsizei colorSamples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLboolean fixedSampleLocations void glTextureImage2DMultisampleNV - GLuint texture + GLuint texture GLenum target GLsizei samples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLboolean fixedSampleLocations void glTextureImage3DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint internalformat @@ -27936,11 +25003,11 @@ typedef unsigned int GLhandleARB; void glTextureImage3DMultisampleCoverageNV - GLuint texture + GLuint texture GLenum target GLsizei coverageSamples GLsizei colorSamples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLsizei depth @@ -27948,10 +25015,10 @@ typedef unsigned int GLhandleARB; void glTextureImage3DMultisampleNV - GLuint texture + GLuint texture GLenum target GLsizei samples - GLint internalFormat + GLint internalFormat GLsizei width GLsizei height GLsizei depth @@ -27972,7 +25039,7 @@ typedef unsigned int GLhandleARB; void glTexturePageCommitmentEXT - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -27980,43 +25047,58 @@ typedef unsigned int GLhandleARB; GLsizei width GLsizei height GLsizei depth - GLboolean commit + GLboolean commit + + + void glTexturePageCommitmentMemNV + GLuint texture + GLint layer + GLint level + GLint xoffset + GLint yoffset + GLint zoffset + GLsizei width + GLsizei height + GLsizei depth + GLuint memory + GLuint64 offset + GLboolean commit void glTextureParameterIiv - GLuint texture + GLuint texture GLenum pname - const GLint *params + const GLint *params void glTextureParameterIivEXT - GLuint texture + GLuint texture GLenum target GLenum pname const GLint *params void glTextureParameterIuiv - GLuint texture + GLuint texture GLenum pname - const GLuint *params + const GLuint *params void glTextureParameterIuivEXT - GLuint texture + GLuint texture GLenum target GLenum pname const GLuint *params void glTextureParameterf - GLuint texture + GLuint texture GLenum pname GLfloat param void glTextureParameterfEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLfloat param @@ -28024,26 +25106,26 @@ typedef unsigned int GLhandleARB; void glTextureParameterfv - GLuint texture + GLuint texture GLenum pname - const GLfloat *param + const GLfloat *param void glTextureParameterfvEXT - GLuint texture + GLuint texture GLenum target GLenum pname const GLfloat *params void glTextureParameteri - GLuint texture + GLuint texture GLenum pname GLint param void glTextureParameteriEXT - GLuint texture + GLuint texture GLenum target GLenum pname GLint param @@ -28051,13 +25133,13 @@ typedef unsigned int GLhandleARB; void glTextureParameteriv - GLuint texture + GLuint texture GLenum pname - const GLint *param + const GLint *param void glTextureParameterivEXT - GLuint texture + GLuint texture GLenum target GLenum pname const GLint *params @@ -28070,96 +25152,96 @@ typedef unsigned int GLhandleARB; void glTextureRenderbufferEXT - GLuint texture + GLuint texture GLenum target - GLuint renderbuffer + GLuint renderbuffer void glTextureStorage1D - GLuint texture + GLuint texture GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width void glTextureStorage1DEXT - GLuint texture + GLuint texture GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width void glTextureStorage2D - GLuint texture + GLuint texture GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height void glTextureStorage2DEXT - GLuint texture + GLuint texture GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height void glTextureStorage2DMultisample - GLuint texture + GLuint texture GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height - GLboolean fixedsamplelocations + GLboolean fixedsamplelocations void glTextureStorage2DMultisampleEXT - GLuint texture + GLuint texture GLenum target GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLboolean fixedsamplelocations void glTextureStorage3D - GLuint texture + GLuint texture GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth void glTextureStorage3DEXT - GLuint texture + GLuint texture GLenum target GLsizei levels - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth void glTextureStorage3DMultisample - GLuint texture + GLuint texture GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth - GLboolean fixedsamplelocations + GLboolean fixedsamplelocations void glTextureStorage3DMultisampleEXT - GLuint texture + GLuint texture GLenum target GLsizei samples - GLenum internalformat + GLenum internalformat GLsizei width GLsizei height GLsizei depth @@ -28167,18 +25249,18 @@ typedef unsigned int GLhandleARB; void glTextureStorageMem1DEXT - GLuint texture + GLuint texture GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLuint memory GLuint64 offset void glTextureStorageMem2DEXT - GLuint texture + GLuint texture GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLuint memory @@ -28186,20 +25268,20 @@ typedef unsigned int GLhandleARB; void glTextureStorageMem2DMultisampleEXT - GLuint texture + GLuint texture GLsizei samples - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height - GLboolean fixedSampleLocations + GLboolean fixedSampleLocations GLuint memory GLuint64 offset void glTextureStorageMem3DEXT - GLuint texture + GLuint texture GLsizei levels - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth @@ -28208,21 +25290,21 @@ typedef unsigned int GLhandleARB; void glTextureStorageMem3DMultisampleEXT - GLuint texture + GLuint texture GLsizei samples - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth - GLboolean fixedSampleLocations + GLboolean fixedSampleLocations GLuint memory GLuint64 offset void glTextureStorageSparseAMD - GLuint texture + GLuint texture GLenum target - GLenum internalFormat + GLenum internalFormat GLsizei width GLsizei height GLsizei depth @@ -28231,7 +25313,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage1D - GLuint texture + GLuint texture GLint level GLint xoffset GLsizei width @@ -28241,7 +25323,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage1DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -28252,7 +25334,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage2D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -28264,7 +25346,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage2DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -28277,7 +25359,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage3D - GLuint texture + GLuint texture GLint level GLint xoffset GLint yoffset @@ -28291,7 +25373,7 @@ typedef unsigned int GLhandleARB; void glTextureSubImage3DEXT - GLuint texture + GLuint texture GLenum target GLint level GLint xoffset @@ -28306,10 +25388,10 @@ typedef unsigned int GLhandleARB; void glTextureView - GLuint texture + GLuint texture GLenum target - GLuint origtexture - GLenum internalformat + GLuint origtexture + GLenum internalformat GLuint minlevel GLuint numlevels GLuint minlayer @@ -28317,10 +25399,10 @@ typedef unsigned int GLhandleARB; void glTextureViewEXT - GLuint texture + GLuint texture GLenum target - GLuint origtexture - GLenum internalformat + GLuint origtexture + GLenum internalformat GLuint minlevel GLuint numlevels GLuint minlayer @@ -28329,10 +25411,10 @@ typedef unsigned int GLhandleARB; void glTextureViewOES - GLuint texture + GLuint texture GLenum target - GLuint origtexture - GLenum internalformat + GLuint origtexture + GLenum internalformat GLuint minlevel GLuint numlevels GLuint minlayer @@ -28355,15 +25437,15 @@ typedef unsigned int GLhandleARB; void glTransformFeedbackBufferBase - GLuint xfb + GLuint xfb GLuint index - GLuint buffer + GLuint buffer void glTransformFeedbackBufferRange - GLuint xfb + GLuint xfb GLuint index - GLuint buffer + GLuint buffer GLintptr offset GLsizeiptr size @@ -28377,15 +25459,15 @@ typedef unsigned int GLhandleARB; void glTransformFeedbackVaryings - GLuint program + GLuint program GLsizei count const GLchar *const*varyings - GLenum bufferMode + GLenum bufferMode void glTransformFeedbackVaryingsEXT - GLuint program + GLuint program GLsizei count const GLchar *const*varyings GLenum bufferMode @@ -28393,7 +25475,7 @@ typedef unsigned int GLhandleARB; void glTransformFeedbackVaryingsNV - GLuint program + GLuint program GLsizei count const GLint *locations GLenum bufferMode @@ -29007,16 +26089,16 @@ typedef unsigned int GLhandleARB; void glUniformBlockBinding - GLuint program + GLuint program GLuint uniformBlockIndex GLuint uniformBlockBinding void glUniformBufferEXT - GLuint program + GLuint program GLint location - GLuint buffer + GLuint buffer void glUniformHandleui64ARB @@ -29287,38 +26369,42 @@ typedef unsigned int GLhandleARB; - GLboolean glUnmapBufferOES + GLboolean glUnmapBufferOES GLenum target - GLboolean glUnmapNamedBuffer - GLuint buffer + GLboolean glUnmapNamedBuffer + GLuint buffer GLboolean glUnmapNamedBufferEXT - GLuint buffer + GLuint buffer void glUnmapObjectBufferATI - GLuint buffer + GLuint buffer void glUnmapTexture2DINTEL - GLuint texture + GLuint texture GLint level void glUpdateObjectBufferATI - GLuint buffer + GLuint buffer GLuint offset GLsizei size const void *pointer GLenum preserve + + void glUploadGpuMaskNVX + GLbitfield mask + void glUseProgram - GLuint program + GLuint program void glUseProgramObjectARB @@ -29327,20 +26413,20 @@ typedef unsigned int GLhandleARB; void glUseProgramStages - GLuint pipeline + GLuint pipeline GLbitfield stages - GLuint program + GLuint program void glUseProgramStagesEXT - GLuint pipeline + GLuint pipeline GLbitfield stages - GLuint program + GLuint program void glUseShaderProgramEXT GLenum type - GLuint program + GLuint program void glVDPAUFiniNV @@ -29349,9 +26435,9 @@ typedef unsigned int GLhandleARB; void glVDPAUGetSurfaceivNV GLvdpauSurfaceNV surface GLenum pname - GLsizei bufSize + GLsizei count GLsizei *length - GLint *values + GLint *values void glVDPAUInitNV @@ -29359,7 +26445,7 @@ typedef unsigned int GLhandleARB; const void *getProcAddress - GLboolean glVDPAUIsSurfaceNV + GLboolean glVDPAUIsSurfaceNV GLvdpauSurfaceNV surface @@ -29381,6 +26467,14 @@ typedef unsigned int GLhandleARB; GLsizei numTextureNames const GLuint *textureNames + + GLvdpauSurfaceNV glVDPAURegisterVideoSurfaceWithPictureStructureNV + const void *vdpSurface + GLenum target + GLsizei numTextureNames + const GLuint *textureNames + GLboolean isFrameStructure + void glVDPAUSurfaceAccessNV GLvdpauSurfaceNV surface @@ -29397,7 +26491,7 @@ typedef unsigned int GLhandleARB; void glValidateProgram - GLuint program + GLuint program void glValidateProgramARB @@ -29406,18 +26500,18 @@ typedef unsigned int GLhandleARB; void glValidateProgramPipeline - GLuint pipeline + GLuint pipeline void glValidateProgramPipelineEXT - GLuint pipeline + GLuint pipeline void glVariantArrayObjectATI GLuint id GLenum type GLsizei stride - GLuint buffer + GLuint buffer GLuint offset @@ -29706,53 +26800,53 @@ typedef unsigned int GLhandleARB; void glVertexArrayAttribBinding - GLuint vaobj + GLuint vaobj GLuint attribindex GLuint bindingindex void glVertexArrayAttribFormat - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size GLenum type - GLboolean normalized + GLboolean normalized GLuint relativeoffset void glVertexArrayAttribIFormat - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexArrayAttribLFormat - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexArrayBindVertexBufferEXT - GLuint vaobj + GLuint vaobj GLuint bindingindex - GLuint buffer + GLuint buffer GLintptr offset GLsizei stride void glVertexArrayBindingDivisor - GLuint vaobj + GLuint vaobj GLuint bindingindex GLuint divisor void glVertexArrayColorOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLint size GLenum type GLsizei stride @@ -29760,36 +26854,36 @@ typedef unsigned int GLhandleARB; void glVertexArrayEdgeFlagOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLsizei stride GLintptr offset void glVertexArrayElementBuffer - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer void glVertexArrayFogCoordOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLenum type GLsizei stride GLintptr offset void glVertexArrayIndexOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLenum type GLsizei stride GLintptr offset void glVertexArrayMultiTexCoordOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLenum texunit GLint size GLenum type @@ -29798,8 +26892,8 @@ typedef unsigned int GLhandleARB; void glVertexArrayNormalOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLenum type GLsizei stride GLintptr offset @@ -29821,8 +26915,8 @@ typedef unsigned int GLhandleARB; void glVertexArraySecondaryColorOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLint size GLenum type GLsizei stride @@ -29830,8 +26924,8 @@ typedef unsigned int GLhandleARB; void glVertexArrayTexCoordOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLint size GLenum type GLsizei stride @@ -29839,99 +26933,99 @@ typedef unsigned int GLhandleARB; void glVertexArrayVertexAttribBindingEXT - GLuint vaobj + GLuint vaobj GLuint attribindex GLuint bindingindex void glVertexArrayVertexAttribDivisorEXT - GLuint vaobj + GLuint vaobj GLuint index GLuint divisor void glVertexArrayVertexAttribFormatEXT - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size - GLenum type + GLenum type GLboolean normalized GLuint relativeoffset void glVertexArrayVertexAttribIFormatEXT - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexArrayVertexAttribIOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLuint index GLint size - GLenum type + GLenum type GLsizei stride GLintptr offset void glVertexArrayVertexAttribLFormatEXT - GLuint vaobj + GLuint vaobj GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexArrayVertexAttribLOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLuint index GLint size - GLenum type + GLenum type GLsizei stride GLintptr offset void glVertexArrayVertexAttribOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLuint index GLint size GLenum type - GLboolean normalized + GLboolean normalized GLsizei stride GLintptr offset void glVertexArrayVertexBindingDivisorEXT - GLuint vaobj + GLuint vaobj GLuint bindingindex GLuint divisor void glVertexArrayVertexBuffer - GLuint vaobj + GLuint vaobj GLuint bindingindex - GLuint buffer + GLuint buffer GLintptr offset GLsizei stride void glVertexArrayVertexBuffers - GLuint vaobj + GLuint vaobj GLuint first GLsizei count - const GLuint *buffers - const GLintptr *offsets - const GLsizei *strides + const GLuint *buffers + const GLintptr *offsets + const GLsizei *strides void glVertexArrayVertexOffsetEXT - GLuint vaobj - GLuint buffer + GLuint vaobj + GLuint buffer GLint size GLenum type GLsizei stride @@ -30689,7 +27783,7 @@ typedef unsigned int GLhandleARB; GLenum type GLboolean normalized GLsizei stride - GLuint buffer + GLuint buffer GLuint offset @@ -30730,7 +27824,7 @@ typedef unsigned int GLhandleARB; void glVertexAttribFormat GLuint attribindex GLint size - GLenum type + GLenum type GLboolean normalized GLuint relativeoffset @@ -30738,7 +27832,7 @@ typedef unsigned int GLhandleARB; void glVertexAttribFormatNV GLuint index GLint size - GLenum type + GLenum type GLboolean normalized GLsizei stride @@ -31006,21 +28100,21 @@ typedef unsigned int GLhandleARB; void glVertexAttribIFormat GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexAttribIFormatNV GLuint index GLint size - GLenum type + GLenum type GLsizei stride void glVertexAttribIPointer GLuint index GLint size - GLenum type + GLenum type GLsizei stride const void *pointer @@ -31028,7 +28122,7 @@ typedef unsigned int GLhandleARB; void glVertexAttribIPointerEXT GLuint index GLint size - GLenum type + GLenum type GLsizei stride const void *pointer @@ -31239,21 +28333,21 @@ typedef unsigned int GLhandleARB; void glVertexAttribLFormat GLuint attribindex GLint size - GLenum type + GLenum type GLuint relativeoffset void glVertexAttribLFormatNV GLuint index GLint size - GLenum type + GLenum type GLsizei stride void glVertexAttribLPointer GLuint index GLint size - GLenum type + GLenum type GLsizei stride const void *pointer @@ -31261,7 +28355,7 @@ typedef unsigned int GLhandleARB; void glVertexAttribLPointerEXT GLuint index GLint size - GLenum type + GLenum type GLsizei stride const void *pointer @@ -31886,21 +28980,28 @@ typedef unsigned int GLhandleARB; void glWaitSemaphoreEXT GLuint semaphore GLuint numBufferBarriers - const GLuint *buffers + const GLuint *buffers GLuint numTextureBarriers - const GLuint *textures + const GLuint *textures const GLenum *srcLayouts + + void glWaitSemaphoreui64NVX + GLuint waitGpu + GLsizei fenceObjectCount + const GLuint *semaphoreArray + const GLuint64 *fenceValueArray + void glWaitSync - GLsync sync - GLbitfield flags + GLsync sync + GLbitfield flags GLuint64 timeout void glWaitSyncAPPLE - GLsync sync - GLbitfield flags + GLsync sync + GLbitfield flags GLuint64 timeout @@ -32339,7 +29440,7 @@ typedef unsigned int GLhandleARB; void glDrawVkImageNV GLuint64 vkImage - GLuint sampler + GLuint sampler GLfloat x0 GLfloat y0 GLfloat x1 @@ -32366,6 +29467,18 @@ typedef unsigned int GLhandleARB; void glSignalVkFenceNV GLuint64 vkFence + + void glFramebufferParameteriMESA + GLenum target + GLenum pname + GLint param + + + void glGetFramebufferParameterivMESA + GLenum target + GLenum pname + GLint *params + @@ -34090,6 +31203,7 @@ typedef unsigned int GLhandleARB; + @@ -34111,8 +31225,7 @@ typedef unsigned int GLhandleARB; - - + @@ -35160,6 +32273,7 @@ typedef unsigned int GLhandleARB; + @@ -36392,6 +33506,20 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + @@ -38734,7 +35862,6 @@ typedef unsigned int GLhandleARB; - @@ -38932,6 +36059,18 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + @@ -40637,6 +37776,29 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + + @@ -41381,7 +38543,7 @@ typedef unsigned int GLhandleARB; - + @@ -42343,6 +39505,10 @@ typedef unsigned int GLhandleARB; + + + + @@ -42382,6 +39548,11 @@ typedef unsigned int GLhandleARB; + + + + + @@ -42751,6 +39922,14 @@ typedef unsigned int GLhandleARB; + + + + + + + + @@ -43065,6 +40244,11 @@ typedef unsigned int GLhandleARB; + + + + + @@ -43590,6 +40774,40 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -43763,7 +40981,6 @@ typedef unsigned int GLhandleARB; - @@ -43803,6 +41020,32 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -44012,6 +41255,10 @@ typedef unsigned int GLhandleARB; + + + + @@ -44024,6 +41271,9 @@ typedef unsigned int GLhandleARB; + + + @@ -44300,6 +41550,7 @@ typedef unsigned int GLhandleARB; + @@ -44464,6 +41715,7 @@ typedef unsigned int GLhandleARB; + @@ -44945,6 +42197,7 @@ typedef unsigned int GLhandleARB; + @@ -44973,12 +42226,12 @@ typedef unsigned int GLhandleARB; - + - + @@ -45026,7 +42279,7 @@ typedef unsigned int GLhandleARB; - + @@ -45061,6 +42314,28 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + @@ -45085,6 +42360,18 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + @@ -45609,6 +42896,13 @@ typedef unsigned int GLhandleARB; + + + + + + + @@ -45893,6 +43187,22 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + @@ -45975,6 +43285,18 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + @@ -45982,6 +43304,11 @@ typedef unsigned int GLhandleARB; + + + + + @@ -46231,6 +43558,7 @@ typedef unsigned int GLhandleARB; + @@ -46268,7 +43596,6 @@ typedef unsigned int GLhandleARB; - @@ -46312,7 +43639,7 @@ typedef unsigned int GLhandleARB; - + @@ -46549,6 +43876,7 @@ typedef unsigned int GLhandleARB; + @@ -46833,6 +44161,115 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -47222,6 +44659,12 @@ typedef unsigned int GLhandleARB; + + + + + + @@ -47330,6 +44773,11 @@ typedef unsigned int GLhandleARB; + + + + + @@ -47365,6 +44813,14 @@ typedef unsigned int GLhandleARB; + + + + + + + + @@ -47400,6 +44856,12 @@ typedef unsigned int GLhandleARB; + + + + + + @@ -47408,6 +44870,38 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -47684,6 +45178,11 @@ typedef unsigned int GLhandleARB; + + + + + @@ -47931,7 +45430,7 @@ typedef unsigned int GLhandleARB; - + @@ -49049,6 +46548,22 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + + @@ -49061,6 +46576,17 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + @@ -49072,6 +46598,21 @@ typedef unsigned int GLhandleARB; + + + + + + + + + + + + + + + @@ -49115,18 +46656,7 @@ typedef unsigned int GLhandleARB; - - - - - - - - - - - - + @@ -49802,5 +47332,6 @@ typedef unsigned int GLhandleARB; + diff --git a/scripts/gl_angle_ext.xml b/scripts/gl_angle_ext.xml index ae05b414a..62a582db4 100644 --- a/scripts/gl_angle_ext.xml +++ b/scripts/gl_angle_ext.xml @@ -1147,13 +1147,13 @@ - + - + diff --git a/scripts/registry_xml.py b/scripts/registry_xml.py index 9cb7dfaca..ffb6deeb3 100644 --- a/scripts/registry_xml.py +++ b/scripts/registry_xml.py @@ -384,9 +384,6 @@ check_sorted('strip_suffixes', strip_suffixes) # Toggle generation here. support_EGL_ANGLE_explicit_context = True -# For ungrouped GLenum types -default_enum_group_name = "DefaultGroup" - # Group names that appear in command/param, but not present in groups/group unsupported_enum_group_names = { 'GetMultisamplePNameNV', @@ -423,6 +420,10 @@ class apis: EGL = 'EGL' CL = 'CL' +# For GLenum types +api_enums = {apis.GL: 'BigGLEnum', apis.GLES: 'GLESEnum'} +default_enum_group_name = 'AllEnums' + def script_relative(path): return os.path.join(os.path.dirname(sys.argv[0]), path) diff --git a/src/libANGLE/Context_gl_4_autogen.h b/src/libANGLE/Context_gl_4_autogen.h index 536763b42..2c5570149 100644 --- a/src/libANGLE/Context_gl_4_autogen.h +++ b/src/libANGLE/Context_gl_4_autogen.h @@ -16,9 +16,9 @@ void drawTransformFeedbackStream(GLenum mode, TransformFeedbackID idPacked, GLuint stream); \ void endQueryIndexed(GLenum target, GLuint index); \ void getActiveSubroutineName(ShaderProgramID programPacked, GLenum shadertype, GLuint index, \ - GLsizei bufsize, GLsizei *length, GLchar *name); \ + GLsizei bufSize, GLsizei *length, GLchar *name); \ void getActiveSubroutineUniformName(ShaderProgramID programPacked, GLenum shadertype, \ - GLuint index, GLsizei bufsize, GLsizei *length, \ + GLuint index, GLsizei bufSize, GLsizei *length, \ GLchar *name); \ void getActiveSubroutineUniformiv(ShaderProgramID programPacked, GLenum shadertype, \ GLuint index, GLenum pname, GLint *values); \ @@ -126,8 +126,8 @@ const void *data); \ void clearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, \ GLsizeiptr size, GLenum format, GLenum type, const void *data); \ - void getInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, \ - GLsizei bufSize, GLint64 *params); \ + void getInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, \ + GLint64 *params); \ void invalidateBufferData(BufferID bufferPacked); \ void invalidateBufferSubData(BufferID bufferPacked, GLintptr offset, GLsizeiptr length); \ void invalidateTexImage(TextureID texturePacked, GLint level); \ diff --git a/src/libANGLE/Context_gles_2_0_autogen.h b/src/libANGLE/Context_gles_2_0_autogen.h index 5336adb9c..1c0501eaf 100644 --- a/src/libANGLE/Context_gles_2_0_autogen.h +++ b/src/libANGLE/Context_gles_2_0_autogen.h @@ -131,7 +131,7 @@ void renderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); \ void sampleCoverage(GLfloat value, GLboolean invert); \ void scissor(GLint x, GLint y, GLsizei width, GLsizei height); \ - void shaderBinary(GLsizei count, const ShaderProgramID *shadersPacked, GLenum binaryformat, \ + void shaderBinary(GLsizei count, const ShaderProgramID *shadersPacked, GLenum binaryFormat, \ const void *binary, GLsizei length); \ void shaderSource(ShaderProgramID shaderPacked, GLsizei count, const GLchar *const *string, \ const GLint *length); \ diff --git a/src/libANGLE/Context_gles_3_0_autogen.h b/src/libANGLE/Context_gles_3_0_autogen.h index 32095f300..f87f49f43 100644 --- a/src/libANGLE/Context_gles_3_0_autogen.h +++ b/src/libANGLE/Context_gles_3_0_autogen.h @@ -74,7 +74,7 @@ void getInteger64i_v(GLenum target, GLuint index, GLint64 *data); \ void getInteger64v(GLenum pname, GLint64 *data); \ void getIntegeri_v(GLenum target, GLuint index, GLint *data); \ - void getInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, \ + void getInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei count, \ GLint *params); \ void getProgramBinary(ShaderProgramID programPacked, GLsizei bufSize, GLsizei *length, \ GLenum *binaryFormat, void *binary); \ @@ -83,7 +83,7 @@ void getSamplerParameterfv(SamplerID samplerPacked, GLenum pname, GLfloat *params); \ void getSamplerParameteriv(SamplerID samplerPacked, GLenum pname, GLint *params); \ const GLubyte *getStringi(GLenum name, GLuint index); \ - void getSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); \ + void getSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); \ void getTransformFeedbackVarying(ShaderProgramID programPacked, GLuint index, GLsizei bufSize, \ GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); \ GLuint getUniformBlockIndex(ShaderProgramID programPacked, const GLchar *uniformBlockName); \ diff --git a/src/libANGLE/Context_gles_3_1_autogen.h b/src/libANGLE/Context_gles_3_1_autogen.h index 3f6ede4a4..0d8c5dcab 100644 --- a/src/libANGLE/Context_gles_3_1_autogen.h +++ b/src/libANGLE/Context_gles_3_1_autogen.h @@ -42,8 +42,8 @@ void getProgramResourceName(ShaderProgramID programPacked, GLenum programInterface, \ GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name); \ void getProgramResourceiv(ShaderProgramID programPacked, GLenum programInterface, \ - GLuint index, GLsizei propCount, const GLenum *props, \ - GLsizei bufSize, GLsizei *length, GLint *params); \ + GLuint index, GLsizei propCount, const GLenum *props, GLsizei count, \ + GLsizei *length, GLint *params); \ void getTexLevelParameterfv(TextureTarget targetPacked, GLint level, GLenum pname, \ GLfloat *params); \ void getTexLevelParameteriv(TextureTarget targetPacked, GLint level, GLenum pname, \ diff --git a/src/libANGLE/Context_gles_ext_autogen.h b/src/libANGLE/Context_gles_ext_autogen.h index 64d298f74..e5446e8e5 100644 --- a/src/libANGLE/Context_gles_ext_autogen.h +++ b/src/libANGLE/Context_gles_ext_autogen.h @@ -71,7 +71,7 @@ /* GL_ANGLE_pack_reverse_row_order */ \ /* GL_ANGLE_texture_usage */ \ /* GL_ANGLE_translated_shader_source */ \ - void getTranslatedShaderSource(ShaderProgramID shaderPacked, GLsizei bufsize, GLsizei *length, \ + void getTranslatedShaderSource(ShaderProgramID shaderPacked, GLsizei bufSize, GLsizei *length, \ GLchar *source); \ /* GL_APPLE_clip_distance */ \ /* GL_ARB_sync */ \ @@ -127,7 +127,7 @@ /* GL_EXT_draw_elements_base_vertex */ \ void multiDrawElementsBaseVertex(PrimitiveMode modePacked, const GLsizei *count, \ DrawElementsType typePacked, const void *const *indices, \ - GLsizei primcount, const GLint *basevertex); \ + GLsizei drawcount, const GLint *basevertex); \ /* GL_EXT_external_buffer */ \ void bufferStorageExternal(BufferBinding targetPacked, GLintptr offset, GLsizeiptr size, \ GLeglClientBufferEXT clientBuffer, GLbitfield flags); \ diff --git a/src/libANGLE/capture/FrameCapture.cpp b/src/libANGLE/capture/FrameCapture.cpp index 14507cb47..7e613d11b 100644 --- a/src/libANGLE/capture/FrameCapture.cpp +++ b/src/libANGLE/capture/FrameCapture.cpp @@ -4973,16 +4973,21 @@ struct ParamValueTrait } // namespace -ParamCapture::ParamCapture() : type(ParamType::TGLenum), enumGroup(gl::GLenumGroup::DefaultGroup) {} +ParamCapture::ParamCapture() : type(ParamType::TGLenum), enumGroup(gl::GLESEnum::AllEnums) {} ParamCapture::ParamCapture(const char *nameIn, ParamType typeIn) - : name(nameIn), type(typeIn), enumGroup(gl::GLenumGroup::DefaultGroup) + : name(nameIn), + type(typeIn), + enumGroup(gl::GLESEnum::AllEnums), + bigGLEnum(gl::BigGLEnum::AllEnums) {} ParamCapture::~ParamCapture() = default; ParamCapture::ParamCapture(ParamCapture &&other) - : type(ParamType::TGLenum), enumGroup(gl::GLenumGroup::DefaultGroup) + : type(ParamType::TGLenum), + enumGroup(gl::GLESEnum::AllEnums), + bigGLEnum(gl::BigGLEnum::AllEnums) { *this = std::move(other); } @@ -4993,6 +4998,7 @@ ParamCapture &ParamCapture::operator=(ParamCapture &&other) std::swap(type, other.type); std::swap(value, other.value); std::swap(enumGroup, other.enumGroup); + std::swap(bigGLEnum, other.bigGLEnum); std::swap(data, other.data); std::swap(arrayClientPointerIndex, other.arrayClientPointerIndex); std::swap(readBufferSizeBytes, other.readBufferSizeBytes); diff --git a/src/libANGLE/capture/FrameCapture.h b/src/libANGLE/capture/FrameCapture.h index 6a4af390d..2468ce1ce 100644 --- a/src/libANGLE/capture/FrameCapture.h +++ b/src/libANGLE/capture/FrameCapture.h @@ -19,8 +19,9 @@ namespace gl { -enum class GLenumGroup; -} +enum class BigGLEnum; +enum class GLESEnum; +} // namespace gl namespace angle { @@ -38,7 +39,8 @@ struct ParamCapture : angle::NonCopyable std::string name; ParamType type; ParamValue value; - gl::GLenumGroup enumGroup; // only used for param type GLenum, GLboolean and GLbitfield + gl::GLESEnum enumGroup; // only used for param type GLenum, GLboolean and GLbitfield + gl::BigGLEnum bigGLEnum; // only used for param type GLenum, GLboolean and GLbitfield ParamData data; int dataNElements = 0; int arrayClientPointerIndex = -1; @@ -60,7 +62,12 @@ class ParamBuffer final : angle::NonCopyable void setValueParamAtIndex(const char *paramName, ParamType paramType, T paramValue, int index); template void addEnumParam(const char *paramName, - gl::GLenumGroup enumGroup, + gl::GLESEnum enumGroup, + ParamType paramType, + T paramValue); + template + void addEnumParam(const char *paramName, + gl::BigGLEnum enumGroup, ParamType paramType, T paramValue); @@ -892,7 +899,7 @@ void ParamBuffer::setValueParamAtIndex(const char *paramName, template void ParamBuffer::addEnumParam(const char *paramName, - gl::GLenumGroup enumGroup, + gl::GLESEnum enumGroup, ParamType paramType, T paramValue) { @@ -902,6 +909,18 @@ void ParamBuffer::addEnumParam(const char *paramName, mParamCaptures.emplace_back(std::move(capture)); } +template +void ParamBuffer::addEnumParam(const char *paramName, + gl::BigGLEnum enumGroup, + ParamType paramType, + T paramValue) +{ + ParamCapture capture(paramName, paramType); + InitParamValue(paramType, paramValue, &capture.value); + capture.bigGLEnum = enumGroup; + mParamCaptures.emplace_back(std::move(capture)); +} + // Pointer capture helpers. void CaptureMemory(const void *source, size_t size, ParamCapture *paramCapture); void CaptureString(const GLchar *str, ParamCapture *paramCapture); diff --git a/src/libANGLE/capture/capture_egl.cpp b/src/libANGLE/capture/capture_egl.cpp index 5f8945f3d..eaf505a1d 100644 --- a/src/libANGLE/capture/capture_egl.cpp +++ b/src/libANGLE/capture/capture_egl.cpp @@ -154,8 +154,7 @@ angle::CallCapture CaptureEGLCreateImage(const gl::Context *context, paramBuffer.addValueParam("context", angle::ParamType::TEGLContext, EGL_NO_CONTEXT); } - paramBuffer.addEnumParam("target", gl::GLenumGroup::DefaultGroup, angle::ParamType::TEGLenum, - target); + paramBuffer.addEnumParam("target", gl::GLESEnum::AllEnums, angle::ParamType::TEGLenum, target); angle::ParamCapture paramsClientBuffer("buffer", angle::ParamType::TEGLClientBuffer); uint64_t bufferID = reinterpret_cast(buffer); diff --git a/src/libANGLE/capture/capture_gl_1_autogen.cpp b/src/libANGLE/capture/capture_gl_1_autogen.cpp index 3b50ff112..5d424cfb2 100644 --- a/src/libANGLE/capture/capture_gl_1_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_1_autogen.cpp @@ -26,7 +26,7 @@ CallCapture CaptureAccum(const State &glState, bool isCallValid, GLenum op, GLfl { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("op", GLenumGroup::AccumOp, ParamType::TGLenum, op); + paramBuffer.addEnumParam("op", BigGLEnum::AccumOp, ParamType::TGLenum, op); paramBuffer.addValueParam("value", ParamType::TGLfloat, value); return CallCapture(angle::EntryPoint::GLAccum, std::move(paramBuffer)); @@ -36,7 +36,7 @@ CallCapture CaptureBegin(const State &glState, bool isCallValid, GLenum mode) { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBegin, std::move(paramBuffer)); } @@ -97,7 +97,7 @@ CallCapture CaptureCallLists(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("n", ParamType::TGLsizei, n); - paramBuffer.addEnumParam("type", GLenumGroup::ListNameType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ListNameType, ParamType::TGLenum, type); if (isCallValid) { @@ -159,7 +159,7 @@ CallCapture CaptureClipPlane(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); + paramBuffer.addEnumParam("plane", BigGLEnum::ClipPlaneName, ParamType::TGLenum, plane); if (isCallValid) { @@ -757,8 +757,8 @@ CallCapture CaptureColorMaterial(const State &glState, bool isCallValid, GLenum { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); - paramBuffer.addEnumParam("mode", GLenumGroup::ColorMaterialParameter, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("face", BigGLEnum::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("mode", BigGLEnum::ColorMaterialParameter, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLColorMaterial, std::move(paramBuffer)); } @@ -777,7 +777,7 @@ CallCapture CaptureCopyPixels(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("type", GLenumGroup::PixelCopyType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::PixelCopyType, ParamType::TGLenum, type); return CallCapture(angle::EntryPoint::GLCopyPixels, std::move(paramBuffer)); } @@ -806,7 +806,7 @@ CallCapture CaptureDrawBuffer(const State &glState, bool isCallValid, GLenum buf { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("buf", GLenumGroup::DrawBufferMode, ParamType::TGLenum, buf); + paramBuffer.addEnumParam("buf", BigGLEnum::DrawBufferMode, ParamType::TGLenum, buf); return CallCapture(angle::EntryPoint::GLDrawBuffer, std::move(paramBuffer)); } @@ -823,8 +823,8 @@ CallCapture CaptureDrawPixels(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -1024,7 +1024,7 @@ CallCapture CaptureEvalMesh1(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::MeshMode1, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::MeshMode1, ParamType::TGLenum, mode); paramBuffer.addValueParam("i1", ParamType::TGLint, i1); paramBuffer.addValueParam("i2", ParamType::TGLint, i2); @@ -1041,7 +1041,7 @@ CallCapture CaptureEvalMesh2(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::MeshMode2, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::MeshMode2, ParamType::TGLenum, mode); paramBuffer.addValueParam("i1", ParamType::TGLint, i1); paramBuffer.addValueParam("i2", ParamType::TGLint, i2); paramBuffer.addValueParam("j1", ParamType::TGLint, j1); @@ -1078,7 +1078,7 @@ CallCapture CaptureFeedbackBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("size", ParamType::TGLsizei, size); - paramBuffer.addEnumParam("type", GLenumGroup::FeedbackType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::FeedbackType, ParamType::TGLenum, type); if (isCallValid) { @@ -1102,7 +1102,7 @@ CallCapture CaptureFogi(const State &glState, bool isCallValid, GLenum pname, GL { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::FogParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLFogi, std::move(paramBuffer)); @@ -1112,7 +1112,7 @@ CallCapture CaptureFogiv(const State &glState, bool isCallValid, GLenum pname, c { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::FogParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1176,7 +1176,7 @@ CallCapture CaptureGetClipPlane(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); + paramBuffer.addEnumParam("plane", BigGLEnum::ClipPlaneName, ParamType::TGLenum, plane); if (isCallValid) { @@ -1200,7 +1200,7 @@ CallCapture CaptureGetDoublev(const State &glState, bool isCallValid, GLenum pna { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1228,8 +1228,8 @@ CallCapture CaptureGetLightiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); - paramBuffer.addEnumParam("pname", GLenumGroup::LightParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1256,8 +1256,8 @@ CallCapture CaptureGetMapdv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::GetMapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); if (isCallValid) { @@ -1285,8 +1285,8 @@ CallCapture CaptureGetMapfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::GetMapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); if (isCallValid) { @@ -1313,8 +1313,8 @@ CallCapture CaptureGetMapiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::GetMapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::GetMapQuery, ParamType::TGLenum, query); if (isCallValid) { @@ -1341,8 +1341,8 @@ CallCapture CaptureGetMaterialiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); - paramBuffer.addEnumParam("pname", GLenumGroup::MaterialParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("face", BigGLEnum::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1368,7 +1368,7 @@ CallCapture CaptureGetPixelMapfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); if (isCallValid) { @@ -1395,7 +1395,7 @@ CallCapture CaptureGetPixelMapuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); if (isCallValid) { @@ -1422,7 +1422,7 @@ CallCapture CaptureGetPixelMapusv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); if (isCallValid) { @@ -1472,8 +1472,8 @@ CallCapture CaptureGetTexGendv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1501,8 +1501,8 @@ CallCapture CaptureGetTexGenfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1530,8 +1530,8 @@ CallCapture CaptureGetTexGeniv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1562,8 +1562,8 @@ CallCapture CaptureGetTexImage(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -1743,7 +1743,7 @@ CallCapture CaptureLightModeli(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::LightModelParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLLightModeli, std::move(paramBuffer)); @@ -1756,7 +1756,7 @@ CallCapture CaptureLightModeliv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::LightModelParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1784,8 +1784,8 @@ CallCapture CaptureLighti(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); - paramBuffer.addEnumParam("pname", GLenumGroup::LightParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLLighti, std::move(paramBuffer)); @@ -1799,8 +1799,8 @@ CallCapture CaptureLightiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); - paramBuffer.addEnumParam("pname", GLenumGroup::LightParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("light", BigGLEnum::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("pname", BigGLEnum::LightParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1884,7 +1884,7 @@ CallCapture CaptureMap1d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); paramBuffer.addValueParam("stride", ParamType::TGLint, stride); @@ -1920,7 +1920,7 @@ CallCapture CaptureMap1f(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); paramBuffer.addValueParam("stride", ParamType::TGLint, stride); @@ -1960,7 +1960,7 @@ CallCapture CaptureMap2d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("u1", ParamType::TGLdouble, u1); paramBuffer.addValueParam("u2", ParamType::TGLdouble, u2); paramBuffer.addValueParam("ustride", ParamType::TGLint, ustride); @@ -2004,7 +2004,7 @@ CallCapture CaptureMap2f(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("u1", ParamType::TGLfloat, u1); paramBuffer.addValueParam("u2", ParamType::TGLfloat, u2); paramBuffer.addValueParam("ustride", ParamType::TGLint, ustride); @@ -2113,8 +2113,8 @@ CallCapture CaptureMateriali(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); - paramBuffer.addEnumParam("pname", GLenumGroup::MaterialParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("face", BigGLEnum::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLMateriali, std::move(paramBuffer)); @@ -2128,8 +2128,8 @@ CallCapture CaptureMaterialiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); - paramBuffer.addEnumParam("pname", GLenumGroup::MaterialParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("face", BigGLEnum::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("pname", BigGLEnum::MaterialParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -2176,7 +2176,7 @@ CallCapture CaptureNewList(const State &glState, bool isCallValid, GLuint list, ParamBuffer paramBuffer; paramBuffer.addValueParam("list", ParamType::TGLuint, list); - paramBuffer.addEnumParam("mode", GLenumGroup::ListMode, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::ListMode, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLNewList, std::move(paramBuffer)); } @@ -2381,7 +2381,7 @@ CallCapture CapturePixelMapfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); if (isCallValid) @@ -2410,7 +2410,7 @@ CallCapture CapturePixelMapuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); if (isCallValid) @@ -2439,7 +2439,7 @@ CallCapture CapturePixelMapusv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("mapsize", ParamType::TGLsizei, mapsize); if (isCallValid) @@ -2464,7 +2464,7 @@ CallCapture CapturePixelStoref(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PixelStoreParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::PixelStoreParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLPixelStoref, std::move(paramBuffer)); @@ -2477,8 +2477,7 @@ CallCapture CapturePixelTransferf(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PixelTransferParameter, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::PixelTransferParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLPixelTransferf, std::move(paramBuffer)); @@ -2488,8 +2487,7 @@ CallCapture CapturePixelTransferi(const State &glState, bool isCallValid, GLenum { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PixelTransferParameter, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::PixelTransferParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLPixelTransferi, std::move(paramBuffer)); @@ -2512,8 +2510,8 @@ CallCapture CapturePolygonMode(const State &glState, bool isCallValid, GLenum fa { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); - paramBuffer.addEnumParam("mode", GLenumGroup::PolygonMode, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("face", BigGLEnum::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("mode", BigGLEnum::PolygonMode, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLPolygonMode, std::move(paramBuffer)); } @@ -2558,7 +2556,7 @@ CallCapture CapturePushAttrib(const State &glState, bool isCallValid, GLbitfield { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mask", GLenumGroup::AttribMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("mask", BigGLEnum::AttribMask, ParamType::TGLbitfield, mask); return CallCapture(angle::EntryPoint::GLPushAttrib, std::move(paramBuffer)); } @@ -3232,7 +3230,7 @@ CallCapture CaptureRenderMode(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::RenderingMode, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::RenderingMode, ParamType::TGLenum, mode); ParamCapture returnValueCapture("returnValue", ParamType::TGLint); InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value); @@ -3860,8 +3858,8 @@ CallCapture CaptureTexGend(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLdouble, param); return CallCapture(angle::EntryPoint::GLTexGend, std::move(paramBuffer)); @@ -3875,8 +3873,8 @@ CallCapture CaptureTexGendv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -3904,8 +3902,8 @@ CallCapture CaptureTexGenf(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLTexGenf, std::move(paramBuffer)); @@ -3919,8 +3917,8 @@ CallCapture CaptureTexGenfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -3948,8 +3946,8 @@ CallCapture CaptureTexGeni(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLTexGeni, std::move(paramBuffer)); @@ -3963,8 +3961,8 @@ CallCapture CaptureTexGeniv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", BigGLEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -3997,13 +3995,13 @@ CallCapture CaptureTexImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("internalformat", ParamType::TGLint, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -4532,9 +4530,9 @@ CallCapture CaptureCopyTexImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("x", ParamType::TGLint, x); paramBuffer.addValueParam("y", ParamType::TGLint, y); @@ -4555,7 +4553,7 @@ CallCapture CaptureCopyTexSubImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); paramBuffer.addValueParam("x", ParamType::TGLint, x); @@ -4600,7 +4598,7 @@ CallCapture CaptureIndexPointer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::IndexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::IndexPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -4660,7 +4658,7 @@ CallCapture CaptureInterleavedArrays(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("format", GLenumGroup::InterleavedArrayFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("format", BigGLEnum::InterleavedArrayFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); @@ -4739,7 +4737,7 @@ CallCapture CapturePushClientAttrib(const State &glState, bool isCallValid, GLbi { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mask", GLenumGroup::ClientAttribMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("mask", BigGLEnum::ClientAttribMask, ParamType::TGLbitfield, mask); return CallCapture(angle::EntryPoint::GLPushClientAttrib, std::move(paramBuffer)); } @@ -4756,12 +4754,12 @@ CallCapture CaptureTexSubImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -4798,9 +4796,9 @@ CallCapture CaptureCompressedTexImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("border", ParamType::TGLint, border); @@ -4837,11 +4835,11 @@ CallCapture CaptureCompressedTexSubImage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -4986,7 +4984,7 @@ CallCapture CaptureMultiTexCoord1d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLdouble, s); return CallCapture(angle::EntryPoint::GLMultiTexCoord1d, std::move(paramBuffer)); @@ -4999,7 +4997,7 @@ CallCapture CaptureMultiTexCoord1dv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5023,7 +5021,7 @@ CallCapture CaptureMultiTexCoord1f(const State &glState, bool isCallValid, GLenu { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLfloat, s); return CallCapture(angle::EntryPoint::GLMultiTexCoord1f, std::move(paramBuffer)); @@ -5036,7 +5034,7 @@ CallCapture CaptureMultiTexCoord1fv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5060,7 +5058,7 @@ CallCapture CaptureMultiTexCoord1i(const State &glState, bool isCallValid, GLenu { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLint, s); return CallCapture(angle::EntryPoint::GLMultiTexCoord1i, std::move(paramBuffer)); @@ -5073,7 +5071,7 @@ CallCapture CaptureMultiTexCoord1iv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5097,7 +5095,7 @@ CallCapture CaptureMultiTexCoord1s(const State &glState, bool isCallValid, GLenu { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLshort, s); return CallCapture(angle::EntryPoint::GLMultiTexCoord1s, std::move(paramBuffer)); @@ -5110,7 +5108,7 @@ CallCapture CaptureMultiTexCoord1sv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5138,7 +5136,7 @@ CallCapture CaptureMultiTexCoord2d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLdouble, s); paramBuffer.addValueParam("t", ParamType::TGLdouble, t); @@ -5152,7 +5150,7 @@ CallCapture CaptureMultiTexCoord2dv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5180,7 +5178,7 @@ CallCapture CaptureMultiTexCoord2f(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLfloat, s); paramBuffer.addValueParam("t", ParamType::TGLfloat, t); @@ -5194,7 +5192,7 @@ CallCapture CaptureMultiTexCoord2fv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5222,7 +5220,7 @@ CallCapture CaptureMultiTexCoord2i(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLint, s); paramBuffer.addValueParam("t", ParamType::TGLint, t); @@ -5236,7 +5234,7 @@ CallCapture CaptureMultiTexCoord2iv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5264,7 +5262,7 @@ CallCapture CaptureMultiTexCoord2s(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLshort, s); paramBuffer.addValueParam("t", ParamType::TGLshort, t); @@ -5278,7 +5276,7 @@ CallCapture CaptureMultiTexCoord2sv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5307,7 +5305,7 @@ CallCapture CaptureMultiTexCoord3d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLdouble, s); paramBuffer.addValueParam("t", ParamType::TGLdouble, t); paramBuffer.addValueParam("r", ParamType::TGLdouble, r); @@ -5322,7 +5320,7 @@ CallCapture CaptureMultiTexCoord3dv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5351,7 +5349,7 @@ CallCapture CaptureMultiTexCoord3f(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLfloat, s); paramBuffer.addValueParam("t", ParamType::TGLfloat, t); paramBuffer.addValueParam("r", ParamType::TGLfloat, r); @@ -5366,7 +5364,7 @@ CallCapture CaptureMultiTexCoord3fv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5395,7 +5393,7 @@ CallCapture CaptureMultiTexCoord3i(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLint, s); paramBuffer.addValueParam("t", ParamType::TGLint, t); paramBuffer.addValueParam("r", ParamType::TGLint, r); @@ -5410,7 +5408,7 @@ CallCapture CaptureMultiTexCoord3iv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5439,7 +5437,7 @@ CallCapture CaptureMultiTexCoord3s(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLshort, s); paramBuffer.addValueParam("t", ParamType::TGLshort, t); paramBuffer.addValueParam("r", ParamType::TGLshort, r); @@ -5454,7 +5452,7 @@ CallCapture CaptureMultiTexCoord3sv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5484,7 +5482,7 @@ CallCapture CaptureMultiTexCoord4d(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLdouble, s); paramBuffer.addValueParam("t", ParamType::TGLdouble, t); paramBuffer.addValueParam("r", ParamType::TGLdouble, r); @@ -5500,7 +5498,7 @@ CallCapture CaptureMultiTexCoord4dv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5527,7 +5525,7 @@ CallCapture CaptureMultiTexCoord4fv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5557,7 +5555,7 @@ CallCapture CaptureMultiTexCoord4i(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLint, s); paramBuffer.addValueParam("t", ParamType::TGLint, t); paramBuffer.addValueParam("r", ParamType::TGLint, r); @@ -5573,7 +5571,7 @@ CallCapture CaptureMultiTexCoord4iv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5603,7 +5601,7 @@ CallCapture CaptureMultiTexCoord4s(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLshort, s); paramBuffer.addValueParam("t", ParamType::TGLshort, t); paramBuffer.addValueParam("r", ParamType::TGLshort, r); @@ -5619,7 +5617,7 @@ CallCapture CaptureMultiTexCoord4sv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureUnit, ParamType::TGLenum, target); if (isCallValid) { @@ -5649,7 +5647,7 @@ CallCapture CaptureFogCoordPointer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::FogPointerTypeEXT, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::FogPointerTypeEXT, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -5838,7 +5836,7 @@ CallCapture CapturePointParameteri(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLPointParameteri, std::move(paramBuffer)); @@ -5851,7 +5849,7 @@ CallCapture CapturePointParameteriv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -6177,7 +6175,7 @@ CallCapture CaptureSecondaryColorPointer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -6482,7 +6480,7 @@ CallCapture CaptureGetBufferSubData(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); @@ -6512,7 +6510,7 @@ CallCapture CaptureGetQueryObjectiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -6541,7 +6539,7 @@ CallCapture CaptureMapBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access); + paramBuffer.addEnumParam("access", BigGLEnum::BufferAccessARB, ParamType::TGLenum, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value); diff --git a/src/libANGLE/capture/capture_gl_2_autogen.cpp b/src/libANGLE/capture/capture_gl_2_autogen.cpp index 7524a3d42..336522da7 100644 --- a/src/libANGLE/capture/capture_gl_2_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_2_autogen.cpp @@ -31,7 +31,7 @@ CallCapture CaptureGetVertexAttribdv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { diff --git a/src/libANGLE/capture/capture_gl_3_autogen.cpp b/src/libANGLE/capture/capture_gl_3_autogen.cpp index 9c7b9b562..d0b950e7b 100644 --- a/src/libANGLE/capture/capture_gl_3_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_3_autogen.cpp @@ -30,7 +30,7 @@ CallCapture CaptureBeginConditionalRender(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("id", ParamType::TGLuint, id); - paramBuffer.addEnumParam("mode", GLenumGroup::TypeEnum, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::ConditionalRenderMode, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBeginConditionalRender, std::move(paramBuffer)); } @@ -69,8 +69,8 @@ CallCapture CaptureClampColor(const State &glState, bool isCallValid, GLenum tar { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("clamp", GLenumGroup::DefaultGroup, ParamType::TGLenum, clamp); + paramBuffer.addEnumParam("target", BigGLEnum::AllEnums, ParamType::TGLenum, target); + paramBuffer.addEnumParam("clamp", BigGLEnum::AllEnums, ParamType::TGLenum, clamp); return CallCapture(angle::EntryPoint::GLClampColor, std::move(paramBuffer)); } @@ -92,8 +92,8 @@ CallCapture CaptureFramebufferTexture1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -113,8 +113,8 @@ CallCapture CaptureFramebufferTexture3D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -633,9 +633,9 @@ CallCapture CaptureTexImage2DMultisample(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -656,9 +656,9 @@ CallCapture CaptureTexImage3DMultisample(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -706,7 +706,7 @@ CallCapture CaptureColorP3ui(const State &glState, bool isCallValid, GLenum type { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("color", ParamType::TGLuint, color); return CallCapture(angle::EntryPoint::GLColorP3ui, std::move(paramBuffer)); @@ -719,7 +719,7 @@ CallCapture CaptureColorP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -743,7 +743,7 @@ CallCapture CaptureColorP4ui(const State &glState, bool isCallValid, GLenum type { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("color", ParamType::TGLuint, color); return CallCapture(angle::EntryPoint::GLColorP4ui, std::move(paramBuffer)); @@ -756,7 +756,7 @@ CallCapture CaptureColorP4uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -817,7 +817,7 @@ CallCapture CaptureGetQueryObjecti64v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -848,7 +848,7 @@ CallCapture CaptureGetQueryObjectui64v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -878,8 +878,8 @@ CallCapture CaptureMultiTexCoordP1ui(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLMultiTexCoordP1ui, std::move(paramBuffer)); @@ -893,8 +893,8 @@ CallCapture CaptureMultiTexCoordP1uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -922,8 +922,8 @@ CallCapture CaptureMultiTexCoordP2ui(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLMultiTexCoordP2ui, std::move(paramBuffer)); @@ -937,8 +937,8 @@ CallCapture CaptureMultiTexCoordP2uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -966,8 +966,8 @@ CallCapture CaptureMultiTexCoordP3ui(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLMultiTexCoordP3ui, std::move(paramBuffer)); @@ -981,8 +981,8 @@ CallCapture CaptureMultiTexCoordP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1010,8 +1010,8 @@ CallCapture CaptureMultiTexCoordP4ui(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLMultiTexCoordP4ui, std::move(paramBuffer)); @@ -1025,8 +1025,8 @@ CallCapture CaptureMultiTexCoordP4uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("texture", BigGLEnum::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1050,7 +1050,7 @@ CallCapture CaptureNormalP3ui(const State &glState, bool isCallValid, GLenum typ { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::NormalPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::NormalPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLNormalP3ui, std::move(paramBuffer)); @@ -1063,7 +1063,7 @@ CallCapture CaptureNormalP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::NormalPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::NormalPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1103,7 +1103,7 @@ CallCapture CaptureSecondaryColorP3ui(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("color", ParamType::TGLuint, color); return CallCapture(angle::EntryPoint::GLSecondaryColorP3ui, std::move(paramBuffer)); @@ -1116,7 +1116,7 @@ CallCapture CaptureSecondaryColorP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::ColorPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::ColorPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1140,7 +1140,7 @@ CallCapture CaptureTexCoordP1ui(const State &glState, bool isCallValid, GLenum t { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLTexCoordP1ui, std::move(paramBuffer)); @@ -1153,7 +1153,7 @@ CallCapture CaptureTexCoordP1uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1177,7 +1177,7 @@ CallCapture CaptureTexCoordP2ui(const State &glState, bool isCallValid, GLenum t { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLTexCoordP2ui, std::move(paramBuffer)); @@ -1190,7 +1190,7 @@ CallCapture CaptureTexCoordP2uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1214,7 +1214,7 @@ CallCapture CaptureTexCoordP3ui(const State &glState, bool isCallValid, GLenum t { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLTexCoordP3ui, std::move(paramBuffer)); @@ -1227,7 +1227,7 @@ CallCapture CaptureTexCoordP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1251,7 +1251,7 @@ CallCapture CaptureTexCoordP4ui(const State &glState, bool isCallValid, GLenum t { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("coords", ParamType::TGLuint, coords); return CallCapture(angle::EntryPoint::GLTexCoordP4ui, std::move(paramBuffer)); @@ -1264,7 +1264,7 @@ CallCapture CaptureTexCoordP4uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::TexCoordPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::TexCoordPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1294,8 +1294,7 @@ CallCapture CaptureVertexAttribP1ui(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); paramBuffer.addValueParam("value", ParamType::TGLuint, value); @@ -1312,8 +1311,7 @@ CallCapture CaptureVertexAttribP1uiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); if (isCallValid) @@ -1345,8 +1343,7 @@ CallCapture CaptureVertexAttribP2ui(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); paramBuffer.addValueParam("value", ParamType::TGLuint, value); @@ -1363,8 +1360,7 @@ CallCapture CaptureVertexAttribP2uiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); if (isCallValid) @@ -1396,8 +1392,7 @@ CallCapture CaptureVertexAttribP3ui(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); paramBuffer.addValueParam("value", ParamType::TGLuint, value); @@ -1414,8 +1409,7 @@ CallCapture CaptureVertexAttribP3uiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); if (isCallValid) @@ -1447,8 +1441,7 @@ CallCapture CaptureVertexAttribP4ui(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); paramBuffer.addValueParam("value", ParamType::TGLuint, value); @@ -1465,8 +1458,7 @@ CallCapture CaptureVertexAttribP4uiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); if (isCallValid) @@ -1492,7 +1484,7 @@ CallCapture CaptureVertexP2ui(const State &glState, bool isCallValid, GLenum typ { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("value", ParamType::TGLuint, value); return CallCapture(angle::EntryPoint::GLVertexP2ui, std::move(paramBuffer)); @@ -1505,7 +1497,7 @@ CallCapture CaptureVertexP2uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1529,7 +1521,7 @@ CallCapture CaptureVertexP3ui(const State &glState, bool isCallValid, GLenum typ { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("value", ParamType::TGLuint, value); return CallCapture(angle::EntryPoint::GLVertexP3ui, std::move(paramBuffer)); @@ -1542,7 +1534,7 @@ CallCapture CaptureVertexP3uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); if (isCallValid) { @@ -1566,7 +1558,7 @@ CallCapture CaptureVertexP4ui(const State &glState, bool isCallValid, GLenum typ { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); paramBuffer.addValueParam("value", ParamType::TGLuint, value); return CallCapture(angle::EntryPoint::GLVertexP4ui, std::move(paramBuffer)); @@ -1579,7 +1571,7 @@ CallCapture CaptureVertexP4uiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::VertexPointerType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexPointerType, ParamType::TGLenum, type); if (isCallValid) { diff --git a/src/libANGLE/capture/capture_gl_4_autogen.cpp b/src/libANGLE/capture/capture_gl_4_autogen.cpp index 5b9c8b172..b66ebf008 100644 --- a/src/libANGLE/capture/capture_gl_4_autogen.cpp +++ b/src/libANGLE/capture/capture_gl_4_autogen.cpp @@ -30,7 +30,7 @@ CallCapture CaptureBeginQueryIndexed(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::QueryTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); @@ -44,7 +44,7 @@ CallCapture CaptureDrawTransformFeedback(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); return CallCapture(angle::EntryPoint::GLDrawTransformFeedback, std::move(paramBuffer)); @@ -58,7 +58,7 @@ CallCapture CaptureDrawTransformFeedbackStream(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); paramBuffer.addValueParam("stream", ParamType::TGLuint, stream); @@ -72,7 +72,7 @@ CallCapture CaptureEndQueryIndexed(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::QueryTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLEndQueryIndexed, std::move(paramBuffer)); @@ -83,23 +83,23 @@ CallCapture CaptureGetActiveSubroutineName(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addValueParam("bufsize", ParamType::TGLsizei, bufsize); + paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) { ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); CaptureGetActiveSubroutineName_length(glState, isCallValid, programPacked, shadertype, - index, bufsize, length, name, &lengthParam); + index, bufSize, length, name, &lengthParam); paramBuffer.addParam(std::move(lengthParam)); } else @@ -115,7 +115,7 @@ CallCapture CaptureGetActiveSubroutineName(const State &glState, ParamCapture nameParam("name", ParamType::TGLcharPointer); InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value); CaptureGetActiveSubroutineName_name(glState, isCallValid, programPacked, shadertype, index, - bufsize, length, name, &nameParam); + bufSize, length, name, &nameParam); paramBuffer.addParam(std::move(nameParam)); } else @@ -133,23 +133,23 @@ CallCapture CaptureGetActiveSubroutineUniformName(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addValueParam("bufsize", ParamType::TGLsizei, bufsize); + paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) { ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); CaptureGetActiveSubroutineUniformName_length(glState, isCallValid, programPacked, - shadertype, index, bufsize, length, name, + shadertype, index, bufSize, length, name, &lengthParam); paramBuffer.addParam(std::move(lengthParam)); } @@ -166,7 +166,7 @@ CallCapture CaptureGetActiveSubroutineUniformName(const State &glState, ParamCapture nameParam("name", ParamType::TGLcharPointer); InitParamValue(ParamType::TGLcharPointer, name, &nameParam.value); CaptureGetActiveSubroutineUniformName_name(glState, isCallValid, programPacked, shadertype, - index, bufsize, length, name, &nameParam); + index, bufSize, length, name, &nameParam); paramBuffer.addParam(std::move(nameParam)); } else @@ -190,9 +190,9 @@ CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::SubroutineParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::SubroutineParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -223,8 +223,8 @@ CallCapture CaptureGetProgramStageiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); - paramBuffer.addEnumParam("pname", GLenumGroup::ProgramStagePName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("pname", BigGLEnum::ProgramStagePName, ParamType::TGLenum, pname); if (isCallValid) { @@ -253,9 +253,9 @@ CallCapture CaptureGetQueryIndexediv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::QueryParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -285,7 +285,7 @@ CallCapture CaptureGetSubroutineIndex(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); if (isCallValid) { @@ -320,7 +320,7 @@ CallCapture CaptureGetSubroutineUniformLocation(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); if (isCallValid) { @@ -353,7 +353,7 @@ CallCapture CaptureGetUniformSubroutineuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); paramBuffer.addValueParam("location", ParamType::TGLint, location); if (isCallValid) @@ -412,7 +412,7 @@ CallCapture CapturePatchParameterfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PatchParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::PatchParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -908,7 +908,7 @@ CallCapture CaptureUniformSubroutinesuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("shadertype", BigGLEnum::ShaderType, ParamType::TGLenum, shadertype); paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) @@ -984,7 +984,7 @@ CallCapture CaptureGetDoublei_v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::GetPName, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -1013,7 +1013,7 @@ CallCapture CaptureGetFloati_v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::GetPName, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -1043,7 +1043,7 @@ CallCapture CaptureGetVertexAttribLdv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::VertexAttribEnum, ParamType::TGLenum, pname); if (isCallValid) { @@ -1825,8 +1825,7 @@ CallCapture CaptureVertexAttribLPointer(const State &glState, paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribPointerType, ParamType::TGLenum, - type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -2033,7 +2032,7 @@ CallCapture CaptureDrawTransformFeedbackInstanced(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount); @@ -2049,7 +2048,7 @@ CallCapture CaptureDrawTransformFeedbackStreamInstanced(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); paramBuffer.addValueParam("stream", ParamType::TGLuint, stream); paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount); @@ -2069,7 +2068,7 @@ CallCapture CaptureGetActiveAtomicCounterBufferiv(const State &glState, paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); paramBuffer.addValueParam("bufferIndex", ParamType::TGLuint, bufferIndex); - paramBuffer.addEnumParam("pname", GLenumGroup::AtomicCounterBufferPName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::AtomicCounterBufferPName, ParamType::TGLenum, pname); if (isCallValid) @@ -2099,9 +2098,9 @@ CallCapture CaptureTexStorage1D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); @@ -2120,12 +2119,11 @@ CallCapture CaptureClearBufferData(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BufferStorageTarget, ParamType::TGLenum, - target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", BigGLEnum::BufferStorageTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2158,13 +2156,13 @@ CallCapture CaptureClearBufferSubData(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2190,23 +2188,23 @@ CallCapture CaptureGetInternalformati64v(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params) { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); - paramBuffer.addEnumParam("pname", GLenumGroup::InternalFormatPName, ParamType::TGLenum, pname); - paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); + paramBuffer.addEnumParam("pname", BigGLEnum::InternalFormatPName, ParamType::TGLenum, pname); + paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) { ParamCapture paramsParam("params", ParamType::TGLint64Pointer); InitParamValue(ParamType::TGLint64Pointer, params, ¶msParam.value); CaptureGetInternalformati64v_params(glState, isCallValid, target, internalformat, pname, - bufSize, params, ¶msParam); + count, params, ¶msParam); paramBuffer.addParam(std::move(paramsParam)); } else @@ -2230,7 +2228,7 @@ CallCapture CaptureGetProgramResourceLocationIndex(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", BigGLEnum::ProgramInterface, ParamType::TGLenum, programInterface); if (isCallValid) @@ -2418,9 +2416,9 @@ CallCapture CaptureTextureView(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("origtexture", ParamType::TGLuint, origtexture); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("minlevel", ParamType::TGLuint, minlevel); paramBuffer.addValueParam("numlevels", ParamType::TGLuint, numlevels); @@ -2441,7 +2439,7 @@ CallCapture CaptureVertexAttribLFormat(const State &glState, paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex); paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type); paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset); return CallCapture(angle::EntryPoint::GLVertexAttribLFormat, std::move(paramBuffer)); @@ -2458,7 +2456,7 @@ CallCapture CaptureBindBuffersBase(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target); paramBuffer.addValueParam("first", ParamType::TGLuint, first); paramBuffer.addValueParam("count", ParamType::TGLsizei, count); @@ -2492,7 +2490,7 @@ CallCapture CaptureBindBuffersRange(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::BufferTargetARB, ParamType::TGLenum, target); paramBuffer.addValueParam("first", ParamType::TGLuint, first); paramBuffer.addValueParam("count", ParamType::TGLsizei, count); @@ -2727,8 +2725,7 @@ CallCapture CaptureBufferStorage(const State &glState, paramBuffer.addParam(std::move(dataParam)); } - paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield, - flags); + paramBuffer.addEnumParam("flags", BigGLEnum::BufferStorageMask, ParamType::TGLbitfield, flags); return CallCapture(angle::EntryPoint::GLBufferStorage, std::move(paramBuffer)); } @@ -2745,8 +2742,8 @@ CallCapture CaptureClearTexImage(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2791,8 +2788,8 @@ CallCapture CaptureClearTexSubImage(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2855,8 +2852,8 @@ CallCapture CaptureBlitNamedFramebuffer(const State &glState, paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0); paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1); paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1); - paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); - paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum, + paramBuffer.addEnumParam("mask", BigGLEnum::ClearBufferMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("filter", BigGLEnum::BlitFramebufferFilter, ParamType::TGLenum, filter); return CallCapture(angle::EntryPoint::GLBlitNamedFramebuffer, std::move(paramBuffer)); @@ -2871,7 +2868,7 @@ CallCapture CaptureCheckNamedFramebufferStatus(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::FramebufferTarget, ParamType::TGLenum, target); ParamCapture returnValueCapture("returnValue", ParamType::TGLenum); InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value); @@ -2891,10 +2888,10 @@ CallCapture CaptureClearNamedBufferData(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2928,12 +2925,12 @@ CallCapture CaptureClearNamedBufferSubData(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2965,7 +2962,7 @@ CallCapture CaptureClearNamedFramebufferfi(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth); paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil); @@ -2983,7 +2980,7 @@ CallCapture CaptureClearNamedFramebufferfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -3015,7 +3012,7 @@ CallCapture CaptureClearNamedFramebufferiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -3047,7 +3044,7 @@ CallCapture CaptureClearNamedFramebufferuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", BigGLEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -3073,8 +3070,8 @@ CallCapture CaptureClipControl(const State &glState, bool isCallValid, GLenum or { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("origin", GLenumGroup::ClipControlOrigin, ParamType::TGLenum, origin); - paramBuffer.addEnumParam("depth", GLenumGroup::ClipControlDepth, ParamType::TGLenum, depth); + paramBuffer.addEnumParam("origin", BigGLEnum::ClipControlOrigin, ParamType::TGLenum, origin); + paramBuffer.addEnumParam("depth", BigGLEnum::ClipControlDepth, ParamType::TGLenum, depth); return CallCapture(angle::EntryPoint::GLClipControl, std::move(paramBuffer)); } @@ -3095,7 +3092,7 @@ CallCapture CaptureCompressedTextureSubImage1D(const State &glState, paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -3137,7 +3134,7 @@ CallCapture CaptureCompressedTextureSubImage2D(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -3184,7 +3181,7 @@ CallCapture CaptureCompressedTextureSubImage3D(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", BigGLEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -3391,7 +3388,7 @@ CallCapture CaptureCreateQueries(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::QueryTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::QueryTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("n", ParamType::TGLsizei, n); if (isCallValid) @@ -3477,7 +3474,7 @@ CallCapture CaptureCreateTextures(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("n", ParamType::TGLsizei, n); if (isCallValid) @@ -3688,8 +3685,7 @@ CallCapture CaptureGetNamedBufferParameteri64v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexBufferObjectParameter, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -3719,8 +3715,7 @@ CallCapture CaptureGetNamedBufferParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexBufferObjectParameter, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -3749,8 +3744,7 @@ CallCapture CaptureGetNamedBufferPointerv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexBufferObjectParameter, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -3812,9 +3806,9 @@ CallCapture CaptureGetNamedFramebufferAttachmentParameteriv(const State &glState ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName, + paramBuffer.addEnumParam("pname", BigGLEnum::FramebufferAttachmentParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -3845,7 +3839,7 @@ CallCapture CaptureGetNamedFramebufferParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetFramebufferParameter, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::GetFramebufferParameter, ParamType::TGLenum, pname); if (isCallValid) @@ -3875,7 +3869,7 @@ CallCapture CaptureGetNamedRenderbufferParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::RenderbufferParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -3908,7 +3902,7 @@ CallCapture CaptureGetQueryBufferObjecti64v(const State &glState, paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -3926,7 +3920,7 @@ CallCapture CaptureGetQueryBufferObjectiv(const State &glState, paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -3944,7 +3938,7 @@ CallCapture CaptureGetQueryBufferObjectui64v(const State &glState, paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -3962,7 +3956,7 @@ CallCapture CaptureGetQueryBufferObjectuiv(const State &glState, paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::QueryObjectParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -3982,8 +3976,8 @@ CallCapture CaptureGetTextureImage(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4015,7 +4009,7 @@ CallCapture CaptureGetTextureLevelParameterfv(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4047,7 +4041,7 @@ CallCapture CaptureGetTextureLevelParameteriv(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4076,7 +4070,7 @@ CallCapture CaptureGetTextureParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4105,7 +4099,7 @@ CallCapture CaptureGetTextureParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4135,7 +4129,7 @@ CallCapture CaptureGetTextureParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4165,7 +4159,7 @@ CallCapture CaptureGetTextureParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -4210,8 +4204,8 @@ CallCapture CaptureGetTextureSubImage(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4243,8 +4237,7 @@ CallCapture CaptureGetTransformFeedbacki64_v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb); - paramBuffer.addEnumParam("pname", GLenumGroup::TransformFeedbackPName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -4276,8 +4269,7 @@ CallCapture CaptureGetTransformFeedbacki_v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb); - paramBuffer.addEnumParam("pname", GLenumGroup::TransformFeedbackPName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -4307,8 +4299,7 @@ CallCapture CaptureGetTransformFeedbackiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("xfb", ParamType::TGLuint, xfb); - paramBuffer.addEnumParam("pname", GLenumGroup::TransformFeedbackPName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TransformFeedbackPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -4338,7 +4329,7 @@ CallCapture CaptureGetVertexArrayIndexed64iv(const State &glState, paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexArrayPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -4370,7 +4361,7 @@ CallCapture CaptureGetVertexArrayIndexediv(const State &glState, paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexArrayPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -4399,7 +4390,7 @@ CallCapture CaptureGetVertexArrayiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexArrayPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::VertexArrayPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -4428,9 +4419,9 @@ CallCapture CaptureGetnColorTable(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::ColorTableTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("target", BigGLEnum::ColorTableTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4460,7 +4451,7 @@ CallCapture CaptureGetnCompressedTexImage(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("lod", ParamType::TGLint, lod); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -4492,9 +4483,9 @@ CallCapture CaptureGetnConvolutionFilter(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::ConvolutionTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("target", BigGLEnum::ConvolutionTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4526,10 +4517,10 @@ CallCapture CaptureGetnHistogram(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::HistogramTargetEXT, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::HistogramTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("reset", ParamType::TGLboolean, reset); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4559,8 +4550,8 @@ CallCapture CaptureGetnMapdv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::MapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4590,8 +4581,8 @@ CallCapture CaptureGetnMapfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::MapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4620,8 +4611,8 @@ CallCapture CaptureGetnMapiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MapTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("query", GLenumGroup::MapQuery, ParamType::TGLenum, query); + paramBuffer.addEnumParam("target", BigGLEnum::MapTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("query", BigGLEnum::MapQuery, ParamType::TGLenum, query); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4652,10 +4643,10 @@ CallCapture CaptureGetnMinmax(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::MinmaxTargetEXT, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::MinmaxTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("reset", ParamType::TGLboolean, reset); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4684,7 +4675,7 @@ CallCapture CaptureGetnPixelMapfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4713,7 +4704,7 @@ CallCapture CaptureGetnPixelMapuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4742,7 +4733,7 @@ CallCapture CaptureGetnPixelMapusv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("map", GLenumGroup::PixelMap, ParamType::TGLenum, map); + paramBuffer.addEnumParam("map", BigGLEnum::PixelMap, ParamType::TGLenum, map); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4803,9 +4794,9 @@ CallCapture CaptureGetnSeparableFilter(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::SeparableTargetEXT, ParamType::TGLenum, target); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("target", BigGLEnum::SeparableTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("rowBufSize", ParamType::TGLsizei, rowBufSize); if (isCallValid) @@ -4869,10 +4860,10 @@ CallCapture CaptureGetnTexImage(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", BigGLEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -5006,7 +4997,7 @@ CallCapture CaptureMapNamedBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access); + paramBuffer.addEnumParam("access", BigGLEnum::BufferAccessARB, ParamType::TGLenum, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value); @@ -5028,7 +5019,7 @@ CallCapture CaptureMapNamedBufferRange(const State &glState, paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("access", BigGLEnum::MapBufferAccessMask, ParamType::TGLbitfield, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); @@ -5066,7 +5057,7 @@ CallCapture CaptureNamedBufferData(const State &glState, paramBuffer.addParam(std::move(dataParam)); } - paramBuffer.addEnumParam("usage", GLenumGroup::VertexBufferObjectUsage, ParamType::TGLenum, + paramBuffer.addEnumParam("usage", BigGLEnum::VertexBufferObjectUsage, ParamType::TGLenum, usage); return CallCapture(angle::EntryPoint::GLNamedBufferData, std::move(paramBuffer)); @@ -5100,8 +5091,7 @@ CallCapture CaptureNamedBufferStorage(const State &glState, paramBuffer.addParam(std::move(dataParam)); } - paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield, - flags); + paramBuffer.addEnumParam("flags", BigGLEnum::BufferStorageMask, ParamType::TGLbitfield, flags); return CallCapture(angle::EntryPoint::GLNamedBufferStorage, std::move(paramBuffer)); } @@ -5146,7 +5136,7 @@ CallCapture CaptureNamedFramebufferDrawBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("buf", GLenumGroup::ColorBuffer, ParamType::TGLenum, buf); + paramBuffer.addEnumParam("buf", BigGLEnum::ColorBuffer, ParamType::TGLenum, buf); return CallCapture(angle::EntryPoint::GLNamedFramebufferDrawBuffer, std::move(paramBuffer)); } @@ -5190,7 +5180,7 @@ CallCapture CaptureNamedFramebufferParameteri(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", BigGLEnum::FramebufferParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); @@ -5205,7 +5195,7 @@ CallCapture CaptureNamedFramebufferReadBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("src", GLenumGroup::ColorBuffer, ParamType::TGLenum, src); + paramBuffer.addEnumParam("src", BigGLEnum::ColorBuffer, ParamType::TGLenum, src); return CallCapture(angle::EntryPoint::GLNamedFramebufferReadBuffer, std::move(paramBuffer)); } @@ -5220,9 +5210,9 @@ CallCapture CaptureNamedFramebufferRenderbuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("renderbuffertarget", GLenumGroup::RenderbufferTarget, + paramBuffer.addEnumParam("renderbuffertarget", BigGLEnum::RenderbufferTarget, ParamType::TGLenum, renderbuffertarget); paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); @@ -5239,7 +5229,7 @@ CallCapture CaptureNamedFramebufferTexture(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -5258,7 +5248,7 @@ CallCapture CaptureNamedFramebufferTextureLayer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("attachment", BigGLEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -5277,7 +5267,7 @@ CallCapture CaptureNamedRenderbufferStorage(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5297,7 +5287,7 @@ CallCapture CaptureNamedRenderbufferStorageMultisample(const State &glState, paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5322,7 +5312,7 @@ CallCapture CaptureTextureBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); @@ -5340,7 +5330,7 @@ CallCapture CaptureTextureBufferRange(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -5358,7 +5348,7 @@ CallCapture CaptureTextureParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5388,7 +5378,7 @@ CallCapture CaptureTextureParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5418,7 +5408,7 @@ CallCapture CaptureTextureParameterf(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLTextureParameterf, std::move(paramBuffer)); @@ -5433,7 +5423,7 @@ CallCapture CaptureTextureParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5463,7 +5453,7 @@ CallCapture CaptureTextureParameteri(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLTextureParameteri, std::move(paramBuffer)); @@ -5478,7 +5468,7 @@ CallCapture CaptureTextureParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", BigGLEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5510,7 +5500,7 @@ CallCapture CaptureTextureStorage1D(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); @@ -5529,7 +5519,7 @@ CallCapture CaptureTextureStorage2D(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5550,7 +5540,7 @@ CallCapture CaptureTextureStorage2DMultisample(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5572,7 +5562,7 @@ CallCapture CaptureTextureStorage3D(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5595,7 +5585,7 @@ CallCapture CaptureTextureStorage3DMultisample(const State &glState, paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", BigGLEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -5621,8 +5611,8 @@ CallCapture CaptureTextureSubImage1D(const State &glState, paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("xoffset", ParamType::TGLint, xoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -5663,8 +5653,8 @@ CallCapture CaptureTextureSubImage2D(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -5709,8 +5699,8 @@ CallCapture CaptureTextureSubImage3D(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", BigGLEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", BigGLEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -5811,7 +5801,7 @@ CallCapture CaptureVertexArrayAttribFormat(const State &glState, paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex); paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribType, ParamType::TGLenum, type); paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized); paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset); @@ -5831,7 +5821,7 @@ CallCapture CaptureVertexArrayAttribIFormat(const State &glState, paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex); paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribIType, ParamType::TGLenum, type); paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset); return CallCapture(angle::EntryPoint::GLVertexArrayAttribIFormat, std::move(paramBuffer)); @@ -5850,7 +5840,7 @@ CallCapture CaptureVertexArrayAttribLFormat(const State &glState, paramBuffer.addValueParam("vaobjPacked", ParamType::TVertexArrayID, vaobjPacked); paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex); paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::VertexAttribType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", BigGLEnum::VertexAttribLType, ParamType::TGLenum, type); paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset); return CallCapture(angle::EntryPoint::GLVertexArrayAttribLFormat, std::move(paramBuffer)); @@ -5982,7 +5972,7 @@ CallCapture CaptureMultiDrawArraysIndirectCount(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); if (isCallValid) { @@ -6018,8 +6008,8 @@ CallCapture CaptureMultiDrawElementsIndirectCount(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::PrimitiveType, ParamType::TGLenum, mode); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("mode", BigGLEnum::PrimitiveType, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("type", BigGLEnum::DrawElementsType, ParamType::TGLenum, type); if (isCallValid) { diff --git a/src/libANGLE/capture/capture_gl_4_autogen.h b/src/libANGLE/capture/capture_gl_4_autogen.h index ad05868c5..495bf4cb7 100644 --- a/src/libANGLE/capture/capture_gl_4_autogen.h +++ b/src/libANGLE/capture/capture_gl_4_autogen.h @@ -43,7 +43,7 @@ angle::CallCapture CaptureGetActiveSubroutineName(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState, @@ -51,7 +51,7 @@ angle::CallCapture CaptureGetActiveSubroutineUniformName(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); angle::CallCapture CaptureGetActiveSubroutineUniformiv(const State &glState, @@ -489,7 +489,7 @@ angle::CallCapture CaptureGetInternalformati64v(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params); angle::CallCapture CaptureGetProgramResourceLocationIndex(const State &glState, bool isCallValid, @@ -1387,7 +1387,7 @@ void CaptureGetActiveSubroutineName_length(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name, angle::ParamCapture *paramCapture); @@ -1396,7 +1396,7 @@ void CaptureGetActiveSubroutineName_name(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name, angle::ParamCapture *paramCapture); @@ -1405,7 +1405,7 @@ void CaptureGetActiveSubroutineUniformName_length(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name, angle::ParamCapture *paramCapture); @@ -1414,7 +1414,7 @@ void CaptureGetActiveSubroutineUniformName_name(const State &glState, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name, angle::ParamCapture *paramCapture); @@ -1791,7 +1791,7 @@ void CaptureGetInternalformati64v_params(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params, angle::ParamCapture *paramCapture); void CaptureGetProgramResourceLocationIndex_name(const State &glState, diff --git a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp index 138fb4235..2daafc7a5 100644 --- a/src/libANGLE/capture/capture_gles_1_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_1_0_autogen.cpp @@ -76,7 +76,7 @@ CallCapture CaptureClientActiveTexture(const State &glState, bool isCallValid, G { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("texture", GLESEnum::TextureUnit, ParamType::TGLenum, texture); return CallCapture(angle::EntryPoint::GLClientActiveTexture, std::move(paramBuffer)); } @@ -85,7 +85,7 @@ CallCapture CaptureClipPlanef(const State &glState, bool isCallValid, GLenum p, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("p", GLenumGroup::ClipPlaneName, ParamType::TGLenum, p); + paramBuffer.addEnumParam("p", GLESEnum::ClipPlaneName, ParamType::TGLenum, p); if (isCallValid) { @@ -112,7 +112,7 @@ CallCapture CaptureClipPlanex(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); + paramBuffer.addEnumParam("plane", GLESEnum::ClipPlaneName, ParamType::TGLenum, plane); if (isCallValid) { @@ -251,7 +251,7 @@ CallCapture CaptureFogf(const State &glState, bool isCallValid, GLenum pname, GL { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::FogParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLFogf, std::move(paramBuffer)); @@ -264,7 +264,7 @@ CallCapture CaptureFogfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::FogParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -288,7 +288,7 @@ CallCapture CaptureFogx(const State &glState, bool isCallValid, GLenum pname, GL { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::FogPName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); return CallCapture(angle::EntryPoint::GLFogx, std::move(paramBuffer)); @@ -298,7 +298,7 @@ CallCapture CaptureFogxv(const State &glState, bool isCallValid, GLenum pname, c { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::FogPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::FogPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -367,7 +367,7 @@ CallCapture CaptureGetClipPlanef(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); + paramBuffer.addEnumParam("plane", GLESEnum::ClipPlaneName, ParamType::TGLenum, plane); if (isCallValid) { @@ -394,7 +394,7 @@ CallCapture CaptureGetClipPlanex(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("plane", GLenumGroup::ClipPlaneName, ParamType::TGLenum, plane); + paramBuffer.addEnumParam("plane", GLESEnum::ClipPlaneName, ParamType::TGLenum, plane); if (isCallValid) { @@ -418,7 +418,7 @@ CallCapture CaptureGetFixedv(const State &glState, bool isCallValid, GLenum pnam { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -446,7 +446,7 @@ CallCapture CaptureGetLightfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); if (isCallValid) @@ -475,7 +475,7 @@ CallCapture CaptureGetLightxv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); if (isCallValid) @@ -504,7 +504,7 @@ CallCapture CaptureGetMaterialfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); if (isCallValid) @@ -533,7 +533,7 @@ CallCapture CaptureGetMaterialxv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); if (isCallValid) @@ -652,7 +652,7 @@ CallCapture CaptureGetTexParameterxv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -677,7 +677,7 @@ CallCapture CaptureLightModelf(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::LightModelParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLLightModelf, std::move(paramBuffer)); @@ -690,7 +690,7 @@ CallCapture CaptureLightModelfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::LightModelParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -714,7 +714,7 @@ CallCapture CaptureLightModelx(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::LightModelParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); return CallCapture(angle::EntryPoint::GLLightModelx, std::move(paramBuffer)); @@ -727,7 +727,7 @@ CallCapture CaptureLightModelxv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::LightModelParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::LightModelParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -755,7 +755,7 @@ CallCapture CaptureLightf(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); @@ -770,7 +770,7 @@ CallCapture CaptureLightfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); if (isCallValid) @@ -799,7 +799,7 @@ CallCapture CaptureLightx(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); @@ -814,7 +814,7 @@ CallCapture CaptureLightxv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("light", GLenumGroup::LightName, ParamType::TGLenum, light); + paramBuffer.addEnumParam("light", GLESEnum::LightName, ParamType::TGLenum, light); paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked); if (isCallValid) @@ -912,7 +912,7 @@ CallCapture CaptureMaterialf(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); @@ -927,7 +927,7 @@ CallCapture CaptureMaterialfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); if (isCallValid) @@ -956,7 +956,7 @@ CallCapture CaptureMaterialx(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); @@ -971,7 +971,7 @@ CallCapture CaptureMaterialxv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::MaterialFace, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::MaterialFace, ParamType::TGLenum, face); paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked); if (isCallValid) @@ -1055,7 +1055,7 @@ CallCapture CaptureMultiTexCoord4f(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureUnit, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::TextureUnit, ParamType::TGLenum, target); paramBuffer.addValueParam("s", ParamType::TGLfloat, s); paramBuffer.addValueParam("t", ParamType::TGLfloat, t); paramBuffer.addValueParam("r", ParamType::TGLfloat, r); @@ -1074,7 +1074,7 @@ CallCapture CaptureMultiTexCoord4x(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("texture", GLESEnum::TextureUnit, ParamType::TGLenum, texture); paramBuffer.addValueParam("s", ParamType::TGLfixed, s); paramBuffer.addValueParam("t", ParamType::TGLfixed, t); paramBuffer.addValueParam("r", ParamType::TGLfixed, r); @@ -1564,7 +1564,7 @@ CallCapture CaptureTexParameterx(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); return CallCapture(angle::EntryPoint::GLTexParameterx, std::move(paramBuffer)); @@ -1579,7 +1579,7 @@ CallCapture CaptureTexParameterxv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { diff --git a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp index 5fadc82b1..f2e0fc5ab 100644 --- a/src/libANGLE/capture/capture_gles_2_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_2_0_autogen.cpp @@ -24,7 +24,7 @@ CallCapture CaptureActiveTexture(const State &glState, bool isCallValid, GLenum { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("texture", GLenumGroup::TextureUnit, ParamType::TGLenum, texture); + paramBuffer.addEnumParam("texture", GLESEnum::TextureUnit, ParamType::TGLenum, texture); return CallCapture(angle::EntryPoint::GLActiveTexture, std::move(paramBuffer)); } @@ -92,7 +92,7 @@ CallCapture CaptureBindFramebuffer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); return CallCapture(angle::EntryPoint::GLBindFramebuffer, std::move(paramBuffer)); @@ -105,7 +105,7 @@ CallCapture CaptureBindRenderbuffer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); return CallCapture(angle::EntryPoint::GLBindRenderbuffer, std::move(paramBuffer)); @@ -145,7 +145,7 @@ CallCapture CaptureBlendEquation(const State &glState, bool isCallValid, GLenum { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBlendEquation, std::move(paramBuffer)); } @@ -157,9 +157,9 @@ CallCapture CaptureBlendEquationSeparate(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeRGB); - paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeAlpha); return CallCapture(angle::EntryPoint::GLBlendEquationSeparate, std::move(paramBuffer)); @@ -169,8 +169,8 @@ CallCapture CaptureBlendFunc(const State &glState, bool isCallValid, GLenum sfac { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("sfactor", GLenumGroup::BlendingFactor, ParamType::TGLenum, sfactor); - paramBuffer.addEnumParam("dfactor", GLenumGroup::BlendingFactor, ParamType::TGLenum, dfactor); + paramBuffer.addEnumParam("sfactor", GLESEnum::BlendingFactor, ParamType::TGLenum, sfactor); + paramBuffer.addEnumParam("dfactor", GLESEnum::BlendingFactor, ParamType::TGLenum, dfactor); return CallCapture(angle::EntryPoint::GLBlendFunc, std::move(paramBuffer)); } @@ -184,13 +184,13 @@ CallCapture CaptureBlendFuncSeparate(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("sfactorRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, + paramBuffer.addEnumParam("sfactorRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, sfactorRGB); - paramBuffer.addEnumParam("dfactorRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, + paramBuffer.addEnumParam("dfactorRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dfactorRGB); - paramBuffer.addEnumParam("sfactorAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, + paramBuffer.addEnumParam("sfactorAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, sfactorAlpha); - paramBuffer.addEnumParam("dfactorAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, + paramBuffer.addEnumParam("dfactorAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dfactorAlpha); return CallCapture(angle::EntryPoint::GLBlendFuncSeparate, std::move(paramBuffer)); @@ -268,7 +268,7 @@ CallCapture CaptureCheckFramebufferStatus(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); ParamCapture returnValueCapture("returnValue", ParamType::TGLenum); InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value); @@ -281,7 +281,7 @@ CallCapture CaptureClear(const State &glState, bool isCallValid, GLbitfield mask { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask); return CallCapture(angle::EntryPoint::GLClear, std::move(paramBuffer)); } @@ -364,7 +364,7 @@ CallCapture CaptureCompressedTexImage2D(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -410,7 +410,7 @@ CallCapture CaptureCompressedTexSubImage2D(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -448,7 +448,7 @@ CallCapture CaptureCopyTexImage2D(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("x", ParamType::TGLint, x); paramBuffer.addValueParam("y", ParamType::TGLint, y); @@ -666,7 +666,7 @@ CallCapture CaptureDepthFunc(const State &glState, bool isCallValid, GLenum func { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("func", GLenumGroup::DepthFunction, ParamType::TGLenum, func); + paramBuffer.addEnumParam("func", GLESEnum::DepthFunction, ParamType::TGLenum, func); return CallCapture(angle::EntryPoint::GLDepthFunc, std::move(paramBuffer)); } @@ -707,7 +707,7 @@ CallCapture CaptureDisable(const State &glState, bool isCallValid, GLenum cap) { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("cap", GLenumGroup::EnableCap, ParamType::TGLenum, cap); + paramBuffer.addEnumParam("cap", GLESEnum::EnableCap, ParamType::TGLenum, cap); return CallCapture(angle::EntryPoint::GLDisable, std::move(paramBuffer)); } @@ -772,7 +772,7 @@ CallCapture CaptureEnable(const State &glState, bool isCallValid, GLenum cap) { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("cap", GLenumGroup::EnableCap, ParamType::TGLenum, cap); + paramBuffer.addEnumParam("cap", GLESEnum::EnableCap, ParamType::TGLenum, cap); return CallCapture(angle::EntryPoint::GLEnable, std::move(paramBuffer)); } @@ -809,11 +809,11 @@ CallCapture CaptureFramebufferRenderbuffer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("renderbuffertarget", GLenumGroup::RenderbufferTarget, - ParamType::TGLenum, renderbuffertarget); + paramBuffer.addEnumParam("renderbuffertarget", GLESEnum::RenderbufferTarget, ParamType::TGLenum, + renderbuffertarget); paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); return CallCapture(angle::EntryPoint::GLFramebufferRenderbuffer, std::move(paramBuffer)); @@ -829,8 +829,8 @@ CallCapture CaptureFramebufferTexture2D(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -843,7 +843,7 @@ CallCapture CaptureFrontFace(const State &glState, bool isCallValid, GLenum mode { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("mode", GLenumGroup::FrontFaceDirection, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", GLESEnum::FrontFaceDirection, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLFrontFace, std::move(paramBuffer)); } @@ -1222,7 +1222,7 @@ CallCapture CaptureGetBooleanv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1251,7 +1251,7 @@ CallCapture CaptureGetBufferParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1286,7 +1286,7 @@ CallCapture CaptureGetFloatv(const State &glState, bool isCallValid, GLenum pnam { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1315,10 +1315,10 @@ CallCapture CaptureGetFramebufferAttachmentParameteriv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName, + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -1344,7 +1344,7 @@ CallCapture CaptureGetIntegerv(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1419,7 +1419,7 @@ CallCapture CaptureGetProgramiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::ProgramPropertyARB, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::ProgramPropertyARB, ParamType::TGLenum, pname); if (isCallValid) { @@ -1447,8 +1447,8 @@ CallCapture CaptureGetRenderbufferParameteriv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::RenderbufferParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -1525,8 +1525,8 @@ CallCapture CaptureGetShaderPrecisionFormat(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("shadertype", GLenumGroup::ShaderType, ParamType::TGLenum, shadertype); - paramBuffer.addEnumParam("precisiontype", GLenumGroup::PrecisionType, ParamType::TGLenum, + paramBuffer.addEnumParam("shadertype", GLESEnum::ShaderType, ParamType::TGLenum, shadertype); + paramBuffer.addEnumParam("precisiontype", GLESEnum::PrecisionType, ParamType::TGLenum, precisiontype); if (isCallValid) @@ -1619,7 +1619,7 @@ CallCapture CaptureGetShaderiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::ShaderParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::ShaderParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1645,7 +1645,7 @@ CallCapture CaptureGetString(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("name", GLenumGroup::StringName, ParamType::TGLenum, name); + paramBuffer.addEnumParam("name", GLESEnum::StringName, ParamType::TGLenum, name); ParamCapture returnValueCapture("returnValue", ParamType::TGLubyteConstPointer); InitParamValue(ParamType::TGLubyteConstPointer, returnValue, &returnValueCapture.value); @@ -1663,7 +1663,7 @@ CallCapture CaptureGetTexParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1693,7 +1693,7 @@ CallCapture CaptureGetTexParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -1813,7 +1813,7 @@ CallCapture CaptureGetVertexAttribPointerv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1843,7 +1843,7 @@ CallCapture CaptureGetVertexAttribfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1872,7 +1872,7 @@ CallCapture CaptureGetVertexAttribiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1895,8 +1895,8 @@ CallCapture CaptureHint(const State &glState, bool isCallValid, GLenum target, G { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::HintTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("mode", GLenumGroup::HintMode, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("target", GLESEnum::HintTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("mode", GLESEnum::HintMode, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLHint, std::move(paramBuffer)); } @@ -1924,7 +1924,7 @@ CallCapture CaptureIsEnabled(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("cap", GLenumGroup::EnableCap, ParamType::TGLenum, cap); + paramBuffer.addEnumParam("cap", GLESEnum::EnableCap, ParamType::TGLenum, cap); ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value); @@ -2037,7 +2037,7 @@ CallCapture CapturePixelStorei(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PixelStoreParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::PixelStoreParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLPixelStorei, std::move(paramBuffer)); @@ -2072,8 +2072,8 @@ CallCapture CaptureReadPixels(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2109,8 +2109,8 @@ CallCapture CaptureRenderbufferStorage(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -2152,7 +2152,7 @@ CallCapture CaptureShaderBinary(const State &glState, bool isCallValid, GLsizei count, const ShaderProgramID *shadersPacked, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length) { @@ -2165,7 +2165,7 @@ CallCapture CaptureShaderBinary(const State &glState, ParamCapture shadersPackedParam("shadersPacked", ParamType::TShaderProgramIDConstPointer); InitParamValue(ParamType::TShaderProgramIDConstPointer, shadersPacked, &shadersPackedParam.value); - CaptureShaderBinary_shadersPacked(glState, isCallValid, count, shadersPacked, binaryformat, + CaptureShaderBinary_shadersPacked(glState, isCallValid, count, shadersPacked, binaryFormat, binary, length, &shadersPackedParam); paramBuffer.addParam(std::move(shadersPackedParam)); } @@ -2177,14 +2177,14 @@ CallCapture CaptureShaderBinary(const State &glState, paramBuffer.addParam(std::move(shadersPackedParam)); } - paramBuffer.addEnumParam("binaryformat", GLenumGroup::DefaultGroup, ParamType::TGLenum, - binaryformat); + paramBuffer.addEnumParam("binaryFormat", GLESEnum::ShaderBinaryFormat, ParamType::TGLenum, + binaryFormat); if (isCallValid) { ParamCapture binaryParam("binary", ParamType::TvoidConstPointer); InitParamValue(ParamType::TvoidConstPointer, binary, &binaryParam.value); - CaptureShaderBinary_binary(glState, isCallValid, count, shadersPacked, binaryformat, binary, + CaptureShaderBinary_binary(glState, isCallValid, count, shadersPacked, binaryFormat, binary, length, &binaryParam); paramBuffer.addParam(std::move(binaryParam)); } @@ -2256,7 +2256,7 @@ CallCapture CaptureStencilFunc(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("func", GLenumGroup::StencilFunction, ParamType::TGLenum, func); + paramBuffer.addEnumParam("func", GLESEnum::StencilFunction, ParamType::TGLenum, func); paramBuffer.addValueParam("ref", ParamType::TGLint, ref); paramBuffer.addValueParam("mask", ParamType::TGLuint, mask); @@ -2272,8 +2272,8 @@ CallCapture CaptureStencilFuncSeparate(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::StencilFaceDirection, ParamType::TGLenum, face); - paramBuffer.addEnumParam("func", GLenumGroup::StencilFunction, ParamType::TGLenum, func); + paramBuffer.addEnumParam("face", GLESEnum::StencilFaceDirection, ParamType::TGLenum, face); + paramBuffer.addEnumParam("func", GLESEnum::StencilFunction, ParamType::TGLenum, func); paramBuffer.addValueParam("ref", ParamType::TGLint, ref); paramBuffer.addValueParam("mask", ParamType::TGLuint, mask); @@ -2296,7 +2296,7 @@ CallCapture CaptureStencilMaskSeparate(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::StencilFaceDirection, ParamType::TGLenum, face); + paramBuffer.addEnumParam("face", GLESEnum::StencilFaceDirection, ParamType::TGLenum, face); paramBuffer.addValueParam("mask", ParamType::TGLuint, mask); return CallCapture(angle::EntryPoint::GLStencilMaskSeparate, std::move(paramBuffer)); @@ -2310,9 +2310,9 @@ CallCapture CaptureStencilOp(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("fail", GLenumGroup::StencilOp, ParamType::TGLenum, fail); - paramBuffer.addEnumParam("zfail", GLenumGroup::StencilOp, ParamType::TGLenum, zfail); - paramBuffer.addEnumParam("zpass", GLenumGroup::StencilOp, ParamType::TGLenum, zpass); + paramBuffer.addEnumParam("fail", GLESEnum::StencilOp, ParamType::TGLenum, fail); + paramBuffer.addEnumParam("zfail", GLESEnum::StencilOp, ParamType::TGLenum, zfail); + paramBuffer.addEnumParam("zpass", GLESEnum::StencilOp, ParamType::TGLenum, zpass); return CallCapture(angle::EntryPoint::GLStencilOp, std::move(paramBuffer)); } @@ -2326,10 +2326,10 @@ CallCapture CaptureStencilOpSeparate(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("face", GLenumGroup::StencilFaceDirection, ParamType::TGLenum, face); - paramBuffer.addEnumParam("sfail", GLenumGroup::StencilOp, ParamType::TGLenum, sfail); - paramBuffer.addEnumParam("dpfail", GLenumGroup::StencilOp, ParamType::TGLenum, dpfail); - paramBuffer.addEnumParam("dppass", GLenumGroup::StencilOp, ParamType::TGLenum, dppass); + paramBuffer.addEnumParam("face", GLESEnum::StencilFaceDirection, ParamType::TGLenum, face); + paramBuffer.addEnumParam("sfail", GLESEnum::StencilOp, ParamType::TGLenum, sfail); + paramBuffer.addEnumParam("dpfail", GLESEnum::StencilOp, ParamType::TGLenum, dpfail); + paramBuffer.addEnumParam("dppass", GLESEnum::StencilOp, ParamType::TGLenum, dppass); return CallCapture(angle::EntryPoint::GLStencilOpSeparate, std::move(paramBuffer)); } @@ -2354,8 +2354,8 @@ CallCapture CaptureTexImage2D(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2385,7 +2385,7 @@ CallCapture CaptureTexParameterf(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLTexParameterf, std::move(paramBuffer)); @@ -2400,7 +2400,7 @@ CallCapture CaptureTexParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -2430,7 +2430,7 @@ CallCapture CaptureTexParameteri(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLTexParameteri, std::move(paramBuffer)); @@ -2445,7 +2445,7 @@ CallCapture CaptureTexParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -2486,8 +2486,8 @@ CallCapture CaptureTexSubImage2D(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { diff --git a/src/libANGLE/capture/capture_gles_2_0_autogen.h b/src/libANGLE/capture/capture_gles_2_0_autogen.h index 45c437821..d4d1d978a 100644 --- a/src/libANGLE/capture/capture_gles_2_0_autogen.h +++ b/src/libANGLE/capture/capture_gles_2_0_autogen.h @@ -437,7 +437,7 @@ angle::CallCapture CaptureShaderBinary(const State &glState, bool isCallValid, GLsizei count, const ShaderProgramID *shadersPacked, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length); angle::CallCapture CaptureShaderSource(const State &glState, @@ -1030,7 +1030,7 @@ void CaptureShaderBinary_shadersPacked(const State &glState, bool isCallValid, GLsizei count, const ShaderProgramID *shadersPacked, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length, angle::ParamCapture *paramCapture); @@ -1038,7 +1038,7 @@ void CaptureShaderBinary_binary(const State &glState, bool isCallValid, GLsizei count, const ShaderProgramID *shadersPacked, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length, angle::ParamCapture *paramCapture); diff --git a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp index 8c819b2a0..9f30f1050 100644 --- a/src/libANGLE/capture/capture_gles_3_0_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_0_autogen.cpp @@ -99,7 +99,7 @@ CallCapture CaptureBindTransformFeedback(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BindTransformFeedbackTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::BindTransformFeedbackTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("idPacked", ParamType::TTransformFeedbackID, idPacked); @@ -140,9 +140,8 @@ CallCapture CaptureBlitFramebuffer(const State &glState, paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0); paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1); paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1); - paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); - paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum, - filter); + paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter); return CallCapture(angle::EntryPoint::GLBlitFramebuffer, std::move(paramBuffer)); } @@ -156,7 +155,7 @@ CallCapture CaptureClearBufferfi(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", GLESEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth); paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil); @@ -172,7 +171,7 @@ CallCapture CaptureClearBufferfv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", GLESEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -201,7 +200,7 @@ CallCapture CaptureClearBufferiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", GLESEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -230,7 +229,7 @@ CallCapture CaptureClearBufferuiv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("buffer", GLenumGroup::Buffer, ParamType::TGLenum, buffer); + paramBuffer.addEnumParam("buffer", GLESEnum::Buffer, ParamType::TGLenum, buffer); paramBuffer.addValueParam("drawbuffer", ParamType::TGLint, drawbuffer); if (isCallValid) @@ -261,7 +260,7 @@ CallCapture CaptureClientWaitSync(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); - paramBuffer.addEnumParam("flags", GLenumGroup::SyncObjectMask, ParamType::TGLbitfield, flags); + paramBuffer.addEnumParam("flags", GLESEnum::SyncObjectMask, ParamType::TGLbitfield, flags); paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout); ParamCapture returnValueCapture("returnValue", ParamType::TGLenum); @@ -287,7 +286,7 @@ CallCapture CaptureCompressedTexImage3D(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -338,7 +337,7 @@ CallCapture CaptureCompressedTexSubImage3D(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -669,9 +668,8 @@ CallCapture CaptureFenceSync(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("condition", GLenumGroup::SyncCondition, ParamType::TGLenum, - condition); - paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags); + paramBuffer.addEnumParam("condition", GLESEnum::SyncCondition, ParamType::TGLenum, condition); + paramBuffer.addEnumParam("flags", GLESEnum::SyncBehaviorFlags, ParamType::TGLbitfield, flags); ParamCapture returnValueCapture("returnValue", ParamType::TGLsync); InitParamValue(ParamType::TGLsync, returnValue, &returnValueCapture.value); @@ -705,8 +703,8 @@ CallCapture CaptureFramebufferTextureLayer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -886,7 +884,7 @@ CallCapture CaptureGetActiveUniformBlockiv(const State &glState, paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); paramBuffer.addValueParam("uniformBlockIndexPacked", ParamType::TUniformBlockIndex, uniformBlockIndexPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::UniformBlockPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::UniformBlockPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -936,7 +934,7 @@ CallCapture CaptureGetActiveUniformsiv(const State &glState, paramBuffer.addParam(std::move(uniformIndicesParam)); } - paramBuffer.addEnumParam("pname", GLenumGroup::UniformPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::UniformPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -965,7 +963,7 @@ CallCapture CaptureGetBufferParameteri64v(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -995,7 +993,7 @@ CallCapture CaptureGetBufferPointerv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1056,7 +1054,7 @@ CallCapture CaptureGetInteger64i_v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::GetPName, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -1084,7 +1082,7 @@ CallCapture CaptureGetInteger64v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1112,7 +1110,7 @@ CallCapture CaptureGetIntegeri_v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TypeEnum, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::GetPName, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -1137,23 +1135,23 @@ CallCapture CaptureGetInternalformativ(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params) { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); - paramBuffer.addEnumParam("pname", GLenumGroup::InternalFormatPName, ParamType::TGLenum, pname); - paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); + paramBuffer.addEnumParam("pname", GLESEnum::InternalFormatPName, ParamType::TGLenum, pname); + paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) { ParamCapture paramsParam("params", ParamType::TGLintPointer); InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); CaptureGetInternalformativ_params(glState, isCallValid, target, internalformat, pname, - bufSize, params, ¶msParam); + count, params, ¶msParam); paramBuffer.addParam(std::move(paramsParam)); } else @@ -1238,7 +1236,7 @@ CallCapture CaptureGetQueryObjectuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -1269,7 +1267,7 @@ CallCapture CaptureGetQueryiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::QueryParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1297,7 +1295,7 @@ CallCapture CaptureGetSamplerParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterF, ParamType::TGLenum, pname); if (isCallValid) { @@ -1327,7 +1325,7 @@ CallCapture CaptureGetSamplerParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -1355,7 +1353,7 @@ CallCapture CaptureGetStringi(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("name", GLenumGroup::StringName, ParamType::TGLenum, name); + paramBuffer.addEnumParam("name", GLESEnum::StringName, ParamType::TGLenum, name); paramBuffer.addValueParam("index", ParamType::TGLuint, index); ParamCapture returnValueCapture("returnValue", ParamType::TGLubyteConstPointer); @@ -1369,21 +1367,21 @@ CallCapture CaptureGetSynciv(const State &glState, bool isCallValid, GLsync sync, GLenum pname, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *values) { ParamBuffer paramBuffer; paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); - paramBuffer.addEnumParam("pname", GLenumGroup::SyncParameterName, ParamType::TGLenum, pname); - paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); + paramBuffer.addEnumParam("pname", GLESEnum::SyncParameterName, ParamType::TGLenum, pname); + paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) { ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); - CaptureGetSynciv_length(glState, isCallValid, sync, pname, bufSize, length, values, + CaptureGetSynciv_length(glState, isCallValid, sync, pname, count, length, values, &lengthParam); paramBuffer.addParam(std::move(lengthParam)); } @@ -1399,7 +1397,7 @@ CallCapture CaptureGetSynciv(const State &glState, { ParamCapture valuesParam("values", ParamType::TGLintPointer); InitParamValue(ParamType::TGLintPointer, values, &valuesParam.value); - CaptureGetSynciv_values(glState, isCallValid, sync, pname, bufSize, length, values, + CaptureGetSynciv_values(glState, isCallValid, sync, pname, count, length, values, &valuesParam); paramBuffer.addParam(std::move(valuesParam)); } @@ -1615,7 +1613,7 @@ CallCapture CaptureGetVertexAttribIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::VertexAttribEnum, ParamType::TGLenum, pname); if (isCallValid) { @@ -1643,7 +1641,7 @@ CallCapture CaptureGetVertexAttribIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::VertexAttribEnum, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::VertexAttribEnum, ParamType::TGLenum, pname); if (isCallValid) { @@ -1671,7 +1669,7 @@ CallCapture CaptureInvalidateFramebuffer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments); if (isCallValid) @@ -1705,7 +1703,7 @@ CallCapture CaptureInvalidateSubFramebuffer(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments); if (isCallValid) @@ -1826,7 +1824,7 @@ CallCapture CaptureMapBufferRange(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("access", GLESEnum::MapBufferAccessMask, ParamType::TGLbitfield, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); @@ -1853,8 +1851,7 @@ CallCapture CaptureProgramBinary(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, - binaryFormat); + paramBuffer.addEnumParam("binaryFormat", GLESEnum::AllEnums, ParamType::TGLenum, binaryFormat); if (isCallValid) { @@ -1886,8 +1883,7 @@ CallCapture CaptureProgramParameteri(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::ProgramParameterPName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::ProgramParameterPName, ParamType::TGLenum, pname); paramBuffer.addValueParam("value", ParamType::TGLint, value); return CallCapture(angle::EntryPoint::GLProgramParameteri, std::move(paramBuffer)); @@ -1897,7 +1893,7 @@ CallCapture CaptureReadBuffer(const State &glState, bool isCallValid, GLenum src { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("src", GLenumGroup::ReadBufferMode, ParamType::TGLenum, src); + paramBuffer.addEnumParam("src", GLESEnum::ReadBufferMode, ParamType::TGLenum, src); return CallCapture(angle::EntryPoint::GLReadBuffer, std::move(paramBuffer)); } @@ -1912,9 +1908,9 @@ CallCapture CaptureRenderbufferStorageMultisample(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -1938,7 +1934,7 @@ CallCapture CaptureSamplerParameterf(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterF, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLSamplerParameterf, std::move(paramBuffer)); @@ -1953,7 +1949,7 @@ CallCapture CaptureSamplerParameterfv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterF, ParamType::TGLenum, pname); if (isCallValid) { @@ -1983,7 +1979,7 @@ CallCapture CaptureSamplerParameteri(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLSamplerParameteri, std::move(paramBuffer)); @@ -1998,7 +1994,7 @@ CallCapture CaptureSamplerParameteriv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -2041,8 +2037,8 @@ CallCapture CaptureTexImage3D(const State &glState, paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2075,7 +2071,7 @@ CallCapture CaptureTexStorage2D(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -2096,7 +2092,7 @@ CallCapture CaptureTexStorage3D(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -2129,8 +2125,8 @@ CallCapture CaptureTexSubImage3D(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -2180,8 +2176,8 @@ CallCapture CaptureTransformFeedbackVaryings(const State &glState, paramBuffer.addParam(std::move(varyingsParam)); } - paramBuffer.addEnumParam("bufferMode", GLenumGroup::DefaultGroup, ParamType::TGLenum, - bufferMode); + paramBuffer.addEnumParam("bufferMode", GLESEnum::TransformFeedbackBufferMode, + ParamType::TGLenum, bufferMode); return CallCapture(angle::EntryPoint::GLTransformFeedbackVaryings, std::move(paramBuffer)); } @@ -2738,7 +2734,7 @@ CallCapture CaptureWaitSync(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("sync", ParamType::TGLsync, sync); - paramBuffer.addEnumParam("flags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, flags); + paramBuffer.addEnumParam("flags", GLESEnum::SyncBehaviorFlags, ParamType::TGLbitfield, flags); paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout); return CallCapture(angle::EntryPoint::GLWaitSync, std::move(paramBuffer)); diff --git a/src/libANGLE/capture/capture_gles_3_0_autogen.h b/src/libANGLE/capture/capture_gles_3_0_autogen.h index a0442ea44..83e2f441b 100644 --- a/src/libANGLE/capture/capture_gles_3_0_autogen.h +++ b/src/libANGLE/capture/capture_gles_3_0_autogen.h @@ -261,7 +261,7 @@ angle::CallCapture CaptureGetInternalformativ(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params); angle::CallCapture CaptureGetProgramBinary(const State &glState, bool isCallValid, @@ -299,7 +299,7 @@ angle::CallCapture CaptureGetSynciv(const State &glState, bool isCallValid, GLsync sync, GLenum pname, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *values); angle::CallCapture CaptureGetTransformFeedbackVarying(const State &glState, @@ -777,7 +777,7 @@ void CaptureGetInternalformativ_params(const State &glState, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params, angle::ParamCapture *paramCapture); void CaptureGetProgramBinary_length(const State &glState, @@ -832,7 +832,7 @@ void CaptureGetSynciv_length(const State &glState, bool isCallValid, GLsync sync, GLenum pname, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *values, angle::ParamCapture *paramCapture); @@ -840,7 +840,7 @@ void CaptureGetSynciv_values(const State &glState, bool isCallValid, GLsync sync, GLenum pname, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *values, angle::ParamCapture *paramCapture); diff --git a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp index 3e33ba5c8..2ec8de055 100644 --- a/src/libANGLE/capture/capture_gles_3_1_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_1_autogen.cpp @@ -50,8 +50,8 @@ CallCapture CaptureBindImageTexture(const State &glState, paramBuffer.addValueParam("level", ParamType::TGLint, level); paramBuffer.addValueParam("layered", ParamType::TGLboolean, layered); paramBuffer.addValueParam("layer", ParamType::TGLint, layer); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access); - paramBuffer.addEnumParam("format", GLenumGroup::InternalFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("access", GLESEnum::BufferAccessARB, ParamType::TGLenum, access); + paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format); return CallCapture(angle::EntryPoint::GLBindImageTexture, std::move(paramBuffer)); } @@ -243,8 +243,8 @@ CallCapture CaptureFramebufferParameteri(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); @@ -288,7 +288,7 @@ CallCapture CaptureGetBooleani_v(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::BufferTargetARB, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::BufferTargetARB, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -317,8 +317,8 @@ CallCapture CaptureGetFramebufferParameteriv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -347,7 +347,7 @@ CallCapture CaptureGetMultisamplefv(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -378,10 +378,9 @@ CallCapture CaptureGetProgramInterfaceiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); - paramBuffer.addEnumParam("pname", GLenumGroup::ProgramInterfacePName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::ProgramInterfacePName, ParamType::TGLenum, pname); if (isCallValid) { @@ -457,8 +456,7 @@ CallCapture CaptureGetProgramPipelineiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::PipelineParameterName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::PipelineParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -488,7 +486,7 @@ CallCapture CaptureGetProgramResourceIndex(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); if (isCallValid) @@ -524,7 +522,7 @@ CallCapture CaptureGetProgramResourceLocation(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); if (isCallValid) @@ -562,7 +560,7 @@ CallCapture CaptureGetProgramResourceName(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -608,14 +606,14 @@ CallCapture CaptureGetProgramResourceiv(const State &glState, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params) { ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("propCount", ParamType::TGLsizei, propCount); @@ -625,7 +623,7 @@ CallCapture CaptureGetProgramResourceiv(const State &glState, ParamCapture propsParam("props", ParamType::TGLenumConstPointer); InitParamValue(ParamType::TGLenumConstPointer, props, &propsParam.value); CaptureGetProgramResourceiv_props(glState, isCallValid, programPacked, programInterface, - index, propCount, props, bufSize, length, params, + index, propCount, props, count, length, params, &propsParam); paramBuffer.addParam(std::move(propsParam)); } @@ -637,14 +635,14 @@ CallCapture CaptureGetProgramResourceiv(const State &glState, paramBuffer.addParam(std::move(propsParam)); } - paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); + paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) { ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); CaptureGetProgramResourceiv_length(glState, isCallValid, programPacked, programInterface, - index, propCount, props, bufSize, length, params, + index, propCount, props, count, length, params, &lengthParam); paramBuffer.addParam(std::move(lengthParam)); } @@ -661,7 +659,7 @@ CallCapture CaptureGetProgramResourceiv(const State &glState, ParamCapture paramsParam("params", ParamType::TGLintPointer); InitParamValue(ParamType::TGLintPointer, params, ¶msParam.value); CaptureGetProgramResourceiv_params(glState, isCallValid, programPacked, programInterface, - index, propCount, props, bufSize, length, params, + index, propCount, props, count, length, params, ¶msParam); paramBuffer.addParam(std::move(paramsParam)); } @@ -686,7 +684,7 @@ CallCapture CaptureGetTexLevelParameterfv(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -718,7 +716,7 @@ CallCapture CaptureGetTexLevelParameteriv(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -758,7 +756,7 @@ CallCapture CaptureMemoryBarrier(const State &glState, bool isCallValid, GLbitfi { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("barriers", GLenumGroup::MemoryBarrierMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("barriers", GLESEnum::MemoryBarrierMask, ParamType::TGLbitfield, barriers); return CallCapture(angle::EntryPoint::GLMemoryBarrier, std::move(paramBuffer)); @@ -770,7 +768,7 @@ CallCapture CaptureMemoryBarrierByRegion(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("barriers", GLenumGroup::MemoryBarrierMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("barriers", GLESEnum::MemoryBarrierMask, ParamType::TGLbitfield, barriers); return CallCapture(angle::EntryPoint::GLMemoryBarrierByRegion, std::move(paramBuffer)); @@ -1690,7 +1688,7 @@ CallCapture CaptureSampleMaski(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber); - paramBuffer.addEnumParam("mask", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("mask", GLESEnum::AllEnums, ParamType::TGLbitfield, mask); return CallCapture(angle::EntryPoint::GLSampleMaski, std::move(paramBuffer)); } @@ -1708,7 +1706,7 @@ CallCapture CaptureTexStorage2DMultisample(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -1726,7 +1724,7 @@ CallCapture CaptureUseProgramStages(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked); - paramBuffer.addEnumParam("stages", GLenumGroup::UseProgramStageMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("stages", GLESEnum::UseProgramStageMask, ParamType::TGLbitfield, stages); paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); diff --git a/src/libANGLE/capture/capture_gles_3_1_autogen.h b/src/libANGLE/capture/capture_gles_3_1_autogen.h index 01c636430..ee594a1c7 100644 --- a/src/libANGLE/capture/capture_gles_3_1_autogen.h +++ b/src/libANGLE/capture/capture_gles_3_1_autogen.h @@ -136,7 +136,7 @@ angle::CallCapture CaptureGetProgramResourceiv(const State &glState, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params); angle::CallCapture CaptureGetTexLevelParameterfv(const State &glState, @@ -527,7 +527,7 @@ void CaptureGetProgramResourceiv_props(const State &glState, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params, angle::ParamCapture *paramCapture); @@ -538,7 +538,7 @@ void CaptureGetProgramResourceiv_length(const State &glState, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params, angle::ParamCapture *paramCapture); @@ -549,7 +549,7 @@ void CaptureGetProgramResourceiv_params(const State &glState, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params, angle::ParamCapture *paramCapture); diff --git a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp index 6fe2ededa..91abf3620 100644 --- a/src/libANGLE/capture/capture_gles_3_2_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_3_2_autogen.cpp @@ -36,9 +36,9 @@ CallCapture CaptureBlendEquationSeparatei(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeRGB); - paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeAlpha); return CallCapture(angle::EntryPoint::GLBlendEquationSeparatei, std::move(paramBuffer)); @@ -49,7 +49,7 @@ CallCapture CaptureBlendEquationi(const State &glState, bool isCallValid, GLuint ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBlendEquationi, std::move(paramBuffer)); } @@ -65,10 +65,10 @@ CallCapture CaptureBlendFuncSeparatei(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB); - paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB); - paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha); - paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha); + paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB); + paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB); + paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha); + paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha); return CallCapture(angle::EntryPoint::GLBlendFuncSeparatei, std::move(paramBuffer)); } @@ -82,8 +82,8 @@ CallCapture CaptureBlendFunci(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src); - paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst); + paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src); + paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst); return CallCapture(angle::EntryPoint::GLBlendFunci, std::move(paramBuffer)); } @@ -128,14 +128,14 @@ CallCapture CaptureCopyImageSubData(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName); - paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyImageSubDataTarget, ParamType::TGLenum, srcTarget); paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel); paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX); paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY); paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ); paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName); - paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyImageSubDataTarget, ParamType::TGLenum, dstTarget); paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel); paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX); @@ -187,9 +187,9 @@ CallCapture CaptureDebugMessageControl(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); - paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type); - paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity); paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) @@ -224,10 +224,10 @@ CallCapture CaptureDebugMessageInsert(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); - paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type); paramBuffer.addValueParam("id", ParamType::TGLuint, id); - paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity); + paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); if (isCallValid) @@ -253,7 +253,7 @@ CallCapture CaptureDisablei(const State &glState, bool isCallValid, GLenum targe { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLDisablei, std::move(paramBuffer)); @@ -377,7 +377,7 @@ CallCapture CaptureEnablei(const State &glState, bool isCallValid, GLenum target { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLEnablei, std::move(paramBuffer)); @@ -392,8 +392,8 @@ CallCapture CaptureFramebufferTexture(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -545,7 +545,7 @@ CallCapture CaptureGetObjectLabel(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("identifier", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("identifier", GLESEnum::ObjectIdentifier, ParamType::TGLenum, identifier); paramBuffer.addValueParam("name", ParamType::TGLuint, name); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -650,7 +650,7 @@ CallCapture CaptureGetPointerv(const State &glState, bool isCallValid, GLenum pn { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPointervPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPointervPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -679,7 +679,7 @@ CallCapture CaptureGetSamplerParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -708,7 +708,7 @@ CallCapture CaptureGetSamplerParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -738,7 +738,7 @@ CallCapture CaptureGetTexParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -767,7 +767,7 @@ CallCapture CaptureGetTexParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -891,7 +891,7 @@ CallCapture CaptureIsEnabledi(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); @@ -919,7 +919,7 @@ CallCapture CaptureObjectLabel(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("identifier", GLenumGroup::ObjectIdentifier, ParamType::TGLenum, + paramBuffer.addEnumParam("identifier", GLESEnum::ObjectIdentifier, ParamType::TGLenum, identifier); paramBuffer.addValueParam("name", ParamType::TGLuint, name); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); @@ -993,7 +993,7 @@ CallCapture CapturePatchParameteri(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PatchParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("value", ParamType::TGLint, value); return CallCapture(angle::EntryPoint::GLPatchParameteri, std::move(paramBuffer)); @@ -1040,7 +1040,7 @@ CallCapture CapturePushDebugGroup(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); @@ -1080,8 +1080,8 @@ CallCapture CaptureReadnPixels(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1111,7 +1111,7 @@ CallCapture CaptureSamplerParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -1141,7 +1141,7 @@ CallCapture CaptureSamplerParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -1171,7 +1171,7 @@ CallCapture CaptureTexBuffer(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); @@ -1189,7 +1189,7 @@ CallCapture CaptureTexBufferRange(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -1207,7 +1207,7 @@ CallCapture CaptureTexParameterIiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1237,7 +1237,7 @@ CallCapture CaptureTexParameterIuiv(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -1272,7 +1272,7 @@ CallCapture CaptureTexStorage3DMultisample(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.cpp b/src/libANGLE/capture/capture_gles_ext_autogen.cpp index 92091b5d9..dcc2636bb 100644 --- a/src/libANGLE/capture/capture_gles_ext_autogen.cpp +++ b/src/libANGLE/capture/capture_gles_ext_autogen.cpp @@ -103,7 +103,7 @@ CallCapture CaptureGetPerfMonitorCounterDataAMD(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("monitor", ParamType::TGLuint, monitor); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize); if (isCallValid) @@ -151,7 +151,7 @@ CallCapture CaptureGetPerfMonitorCounterInfoAMD(const State &glState, paramBuffer.addValueParam("group", ParamType::TGLuint, group); paramBuffer.addValueParam("counter", ParamType::TGLuint, counter); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -694,7 +694,7 @@ CallCapture CaptureCopyTexture3DANGLE(const State &glState, paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked); paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel); paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat); - paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType); + paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType); paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY); paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean, unpackPremultiplyAlpha); @@ -772,9 +772,8 @@ CallCapture CaptureBlitFramebufferANGLE(const State &glState, paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0); paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1); paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1); - paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); - paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum, - filter); + paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter); return CallCapture(angle::EntryPoint::GLBlitFramebufferANGLE, std::move(paramBuffer)); } @@ -789,9 +788,9 @@ CallCapture CaptureRenderbufferStorageMultisampleANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -812,8 +811,8 @@ CallCapture CaptureGetTexImageANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -871,9 +870,9 @@ CallCapture CaptureGetRenderbufferImageANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -904,7 +903,7 @@ CallCapture CaptureGetTexLevelParameterivANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -935,7 +934,7 @@ CallCapture CaptureGetTexLevelParameterfvANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -1038,16 +1037,15 @@ CallCapture CaptureTexStorageMemFlags2DANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked); paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset); - paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, + paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, createFlags); - paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, - usageFlags); + paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags); if (isCallValid) { @@ -1090,17 +1088,16 @@ CallCapture CaptureTexStorageMemFlags2DMultisampleANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations); paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked); paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset); - paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, + paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, createFlags); - paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, - usageFlags); + paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags); if (isCallValid) { @@ -1145,17 +1142,16 @@ CallCapture CaptureTexStorageMemFlags3DANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked); paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset); - paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, + paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, createFlags); - paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, - usageFlags); + paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags); if (isCallValid) { @@ -1200,7 +1196,7 @@ CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::AllEnums, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -1208,10 +1204,9 @@ CallCapture CaptureTexStorageMemFlags3DMultisampleANGLE(const State &glState, paramBuffer.addValueParam("fixedSampleLocations", ParamType::TGLboolean, fixedSampleLocations); paramBuffer.addValueParam("memoryPacked", ParamType::TMemoryObjectID, memoryPacked); paramBuffer.addValueParam("offset", ParamType::TGLuint64, offset); - paramBuffer.addEnumParam("createFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, + paramBuffer.addEnumParam("createFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, createFlags); - paramBuffer.addEnumParam("usageFlags", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, - usageFlags); + paramBuffer.addEnumParam("usageFlags", GLESEnum::AllEnums, ParamType::TGLbitfield, usageFlags); if (isCallValid) { @@ -1558,7 +1553,7 @@ CallCapture CaptureGetBooleanvRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1607,7 +1602,7 @@ CallCapture CaptureGetBufferParameterivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1654,7 +1649,7 @@ CallCapture CaptureGetFloatvRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1703,10 +1698,9 @@ CallCapture CaptureGetFramebufferAttachmentParameterivRobustANGLE(const State &g { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::DefaultGroup, ParamType::TGLenum, - attachment); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::AllEnums, ParamType::TGLenum, attachment); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1753,7 +1747,7 @@ CallCapture CaptureGetIntegervRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1801,7 +1795,7 @@ CallCapture CaptureGetProgramivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1848,8 +1842,8 @@ CallCapture CaptureGetRenderbufferParameterivRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1898,7 +1892,7 @@ CallCapture CaptureGetShaderivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1946,7 +1940,7 @@ CallCapture CaptureGetTexParameterfvRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -1995,7 +1989,7 @@ CallCapture CaptureGetTexParameterivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2140,7 +2134,7 @@ CallCapture CaptureGetVertexAttribfvRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2189,7 +2183,7 @@ CallCapture CaptureGetVertexAttribivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2237,7 +2231,7 @@ CallCapture CaptureGetVertexAttribPointervRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2296,8 +2290,8 @@ CallCapture CaptureReadPixelsRobustANGLE(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2388,8 +2382,8 @@ CallCapture CaptureTexImage2DRobustANGLE(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2422,7 +2416,7 @@ CallCapture CaptureTexParameterfvRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2454,7 +2448,7 @@ CallCapture CaptureTexParameterivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2497,8 +2491,8 @@ CallCapture CaptureTexSubImage2DRobustANGLE(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLint, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2544,8 +2538,8 @@ CallCapture CaptureTexImage3DRobustANGLE(const State &glState, paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2593,8 +2587,8 @@ CallCapture CaptureTexSubImage3DRobustANGLE(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2633,7 +2627,7 @@ CallCapture CaptureCompressedTexImage2DRobustANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -2683,7 +2677,7 @@ CallCapture CaptureCompressedTexSubImage2DRobustANGLE(const State &glState, paramBuffer.addValueParam("yoffset", ParamType::TGLsizei, yoffset); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize); @@ -2725,7 +2719,7 @@ CallCapture CaptureCompressedTexImage3DRobustANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -2780,7 +2774,7 @@ CallCapture CaptureCompressedTexSubImage3DRobustANGLE(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); paramBuffer.addValueParam("dataSize", ParamType::TGLsizei, dataSize); @@ -2816,7 +2810,7 @@ CallCapture CaptureGetQueryivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2864,7 +2858,7 @@ CallCapture CaptureGetQueryObjectuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2913,7 +2907,7 @@ CallCapture CaptureGetBufferPointervRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -2961,7 +2955,7 @@ CallCapture CaptureGetIntegeri_vRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -3010,10 +3004,10 @@ CallCapture CaptureGetInternalformativRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum, internalformat); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3061,7 +3055,7 @@ CallCapture CaptureGetVertexAttribIivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3109,7 +3103,7 @@ CallCapture CaptureGetVertexAttribIuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("index", ParamType::TGLuint, index); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3210,7 +3204,7 @@ CallCapture CaptureGetActiveUniformBlockivRobustANGLE(const State &glState, paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); paramBuffer.addValueParam("uniformBlockIndexPacked", ParamType::TUniformBlockIndex, uniformBlockIndexPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3259,7 +3253,7 @@ CallCapture CaptureGetInteger64vRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3307,7 +3301,7 @@ CallCapture CaptureGetInteger64i_vRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -3357,7 +3351,7 @@ CallCapture CaptureGetBufferParameteri64vRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3438,7 +3432,7 @@ CallCapture CaptureSamplerParameterfvRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3471,7 +3465,7 @@ CallCapture CaptureGetSamplerParameterivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3520,7 +3514,7 @@ CallCapture CaptureGetSamplerParameterfvRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3569,8 +3563,8 @@ CallCapture CaptureGetFramebufferParameterivRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3620,9 +3614,9 @@ CallCapture CaptureGetProgramInterfaceivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::AllEnums, ParamType::TGLenum, programInterface); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3672,7 +3666,7 @@ CallCapture CaptureGetBooleani_vRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -3721,7 +3715,7 @@ CallCapture CaptureGetMultisamplefvRobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("index", ParamType::TGLuint, index); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -3773,7 +3767,7 @@ CallCapture CaptureGetTexLevelParameterivRobustANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3826,7 +3820,7 @@ CallCapture CaptureGetTexLevelParameterfvRobustANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3876,7 +3870,7 @@ CallCapture CaptureGetPointervRobustANGLERobustANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -3935,8 +3929,8 @@ CallCapture CaptureReadnPixelsRobustANGLE(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::DefaultGroup, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::AllEnums, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4163,7 +4157,7 @@ CallCapture CaptureTexParameterIivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4195,7 +4189,7 @@ CallCapture CaptureTexParameterIuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4228,7 +4222,7 @@ CallCapture CaptureGetTexParameterIivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4276,7 +4270,7 @@ CallCapture CaptureGetTexParameterIuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4324,7 +4318,7 @@ CallCapture CaptureSamplerParameterIivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4356,7 +4350,7 @@ CallCapture CaptureSamplerParameterIuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4390,7 +4384,7 @@ CallCapture CaptureGetSamplerParameterIivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4439,7 +4433,7 @@ CallCapture CaptureGetSamplerParameterIuivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4489,7 +4483,7 @@ CallCapture CaptureGetQueryObjectivRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4537,7 +4531,7 @@ CallCapture CaptureGetQueryObjecti64vRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4586,7 +4580,7 @@ CallCapture CaptureGetQueryObjectui64vRobustANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -4659,8 +4653,8 @@ CallCapture CaptureTexImage2DExternalANGLE(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); return CallCapture(angle::EntryPoint::GLTexImage2DExternalANGLE, std::move(paramBuffer)); } @@ -4689,7 +4683,7 @@ CallCapture CaptureTexStorage2DMultisampleANGLE(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::AllEnums, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -4706,7 +4700,7 @@ CallCapture CaptureGetMultisamplefvANGLE(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -4735,7 +4729,7 @@ CallCapture CaptureSampleMaskiANGLE(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber); - paramBuffer.addEnumParam("mask", GLenumGroup::DefaultGroup, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("mask", GLESEnum::AllEnums, ParamType::TGLbitfield, mask); return CallCapture(angle::EntryPoint::GLSampleMaskiANGLE, std::move(paramBuffer)); } @@ -4743,20 +4737,20 @@ CallCapture CaptureSampleMaskiANGLE(const State &glState, CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState, bool isCallValid, ShaderProgramID shaderPacked, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source) { ParamBuffer paramBuffer; paramBuffer.addValueParam("shaderPacked", ParamType::TShaderProgramID, shaderPacked); - paramBuffer.addValueParam("bufsize", ParamType::TGLsizei, bufsize); + paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) { ParamCapture lengthParam("length", ParamType::TGLsizeiPointer); InitParamValue(ParamType::TGLsizeiPointer, length, &lengthParam.value); - CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufsize, + CaptureGetTranslatedShaderSourceANGLE_length(glState, isCallValid, shaderPacked, bufSize, length, source, &lengthParam); paramBuffer.addParam(std::move(lengthParam)); } @@ -4772,7 +4766,7 @@ CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState, { ParamCapture sourceParam("source", ParamType::TGLcharPointer); InitParamValue(ParamType::TGLcharPointer, source, &sourceParam.value); - CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufsize, + CaptureGetTranslatedShaderSourceANGLE_source(glState, isCallValid, shaderPacked, bufSize, length, source, &sourceParam); paramBuffer.addParam(std::move(sourceParam)); } @@ -4943,7 +4937,7 @@ CallCapture CaptureCopyTextureCHROMIUM(const State &glState, paramBuffer.addValueParam("destIdPacked", ParamType::TTextureID, destIdPacked); paramBuffer.addValueParam("destLevel", ParamType::TGLint, destLevel); paramBuffer.addValueParam("internalFormat", ParamType::TGLint, internalFormat); - paramBuffer.addEnumParam("destType", GLenumGroup::DefaultGroup, ParamType::TGLenum, destType); + paramBuffer.addEnumParam("destType", GLESEnum::AllEnums, ParamType::TGLenum, destType); paramBuffer.addValueParam("unpackFlipY", ParamType::TGLboolean, unpackFlipY); paramBuffer.addValueParam("unpackPremultiplyAlpha", ParamType::TGLboolean, unpackPremultiplyAlpha); @@ -4998,8 +4992,7 @@ CallCapture CaptureCoverageModulationCHROMIUM(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("components", GLenumGroup::DefaultGroup, ParamType::TGLenum, - components); + paramBuffer.addEnumParam("components", GLESEnum::AllEnums, ParamType::TGLenum, components); return CallCapture(angle::EntryPoint::GLCoverageModulationCHROMIUM, std::move(paramBuffer)); } @@ -5025,7 +5018,7 @@ CallCapture CaptureEGLImageTargetTexStorageEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image); if (isCallValid) @@ -5282,7 +5275,7 @@ CallCapture CaptureGetProgramResourceLocationIndexEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("programInterface", GLenumGroup::ProgramInterface, ParamType::TGLenum, + paramBuffer.addEnumParam("programInterface", GLESEnum::ProgramInterface, ParamType::TGLenum, programInterface); if (isCallValid) @@ -5337,8 +5330,7 @@ CallCapture CaptureBufferStorageEXT(const State &glState, paramBuffer.addParam(std::move(dataParam)); } - paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield, - flags); + paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags); return CallCapture(angle::EntryPoint::GLBufferStorageEXT, std::move(paramBuffer)); } @@ -5350,8 +5342,8 @@ CallCapture CaptureClipControlEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("origin", GLenumGroup::DefaultGroup, ParamType::TGLenum, origin); - paramBuffer.addEnumParam("depth", GLenumGroup::DefaultGroup, ParamType::TGLenum, depth); + paramBuffer.addEnumParam("origin", GLESEnum::AllEnums, ParamType::TGLenum, origin); + paramBuffer.addEnumParam("depth", GLESEnum::AllEnums, ParamType::TGLenum, depth); return CallCapture(angle::EntryPoint::GLClipControlEXT, std::move(paramBuffer)); } @@ -5377,14 +5369,14 @@ CallCapture CaptureCopyImageSubDataEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName); - paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum, srcTarget); paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel); paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX); paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY); paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ); paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName); - paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum, dstTarget); paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel); paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX); @@ -5407,7 +5399,7 @@ CallCapture CaptureGetObjectLabelEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("object", ParamType::TGLuint, object); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -5455,7 +5447,7 @@ CallCapture CaptureLabelObjectEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("object", ParamType::TGLuint, object); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); @@ -5546,7 +5538,7 @@ CallCapture CaptureDiscardFramebufferEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("numAttachments", ParamType::TGLsizei, numAttachments); if (isCallValid) @@ -5651,7 +5643,7 @@ CallCapture CaptureGetInteger64vEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5680,7 +5672,7 @@ CallCapture CaptureGetQueryObjecti64vEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -5711,7 +5703,7 @@ CallCapture CaptureGetQueryObjectivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -5741,7 +5733,7 @@ CallCapture CaptureGetQueryObjectui64vEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -5772,7 +5764,7 @@ CallCapture CaptureGetQueryObjectuivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("idPacked", ParamType::TQueryID, idPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::QueryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -5803,7 +5795,7 @@ CallCapture CaptureGetQueryivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::QueryParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::QueryParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -5888,9 +5880,9 @@ CallCapture CaptureBlendEquationSeparateiEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeRGB); - paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeAlpha); return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiEXT, std::move(paramBuffer)); @@ -5904,7 +5896,7 @@ CallCapture CaptureBlendEquationiEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBlendEquationiEXT, std::move(paramBuffer)); } @@ -5920,10 +5912,10 @@ CallCapture CaptureBlendFuncSeparateiEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB); - paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB); - paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha); - paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha); + paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB); + paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB); + paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha); + paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha); return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiEXT, std::move(paramBuffer)); } @@ -5937,8 +5929,8 @@ CallCapture CaptureBlendFunciEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src); - paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst); + paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src); + paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst); return CallCapture(angle::EntryPoint::GLBlendFunciEXT, std::move(paramBuffer)); } @@ -5966,7 +5958,7 @@ CallCapture CaptureDisableiEXT(const State &glState, bool isCallValid, GLenum ta { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLDisableiEXT, std::move(paramBuffer)); @@ -5976,7 +5968,7 @@ CallCapture CaptureEnableiEXT(const State &glState, bool isCallValid, GLenum tar { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLEnableiEXT, std::move(paramBuffer)); @@ -5990,7 +5982,7 @@ CallCapture CaptureIsEnablediEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); @@ -6120,7 +6112,7 @@ CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex) { ParamBuffer paramBuffer; @@ -6132,7 +6124,7 @@ CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, ParamCapture countParam("count", ParamType::TGLsizeiConstPointer); InitParamValue(ParamType::TGLsizeiConstPointer, count, &countParam.value); CaptureMultiDrawElementsBaseVertexEXT_count(glState, isCallValid, modePacked, count, - typePacked, indices, primcount, basevertex, + typePacked, indices, drawcount, basevertex, &countParam); paramBuffer.addParam(std::move(countParam)); } @@ -6151,7 +6143,7 @@ CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, ParamCapture indicesParam("indices", ParamType::TvoidConstPointerPointer); InitParamValue(ParamType::TvoidConstPointerPointer, indices, &indicesParam.value); CaptureMultiDrawElementsBaseVertexEXT_indices(glState, isCallValid, modePacked, count, - typePacked, indices, primcount, basevertex, + typePacked, indices, drawcount, basevertex, &indicesParam); paramBuffer.addParam(std::move(indicesParam)); } @@ -6163,14 +6155,14 @@ CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, paramBuffer.addParam(std::move(indicesParam)); } - paramBuffer.addValueParam("primcount", ParamType::TGLsizei, primcount); + paramBuffer.addValueParam("drawcount", ParamType::TGLsizei, drawcount); if (isCallValid) { ParamCapture basevertexParam("basevertex", ParamType::TGLintConstPointer); InitParamValue(ParamType::TGLintConstPointer, basevertex, &basevertexParam.value); CaptureMultiDrawElementsBaseVertexEXT_basevertex(glState, isCallValid, modePacked, count, - typePacked, indices, primcount, basevertex, + typePacked, indices, drawcount, basevertex, &basevertexParam); paramBuffer.addParam(std::move(basevertexParam)); } @@ -6199,8 +6191,7 @@ CallCapture CaptureBufferStorageExternalEXT(const State &glState, paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer); - paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield, - flags); + paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags); return CallCapture(angle::EntryPoint::GLBufferStorageExternalEXT, std::move(paramBuffer)); } @@ -6219,8 +6210,7 @@ CallCapture CaptureNamedBufferStorageExternalEXT(const State &glState, paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size); paramBuffer.addValueParam("clientBuffer", ParamType::TGLeglClientBufferEXT, clientBuffer); - paramBuffer.addEnumParam("flags", GLenumGroup::MapBufferUsageMask, ParamType::TGLbitfield, - flags); + paramBuffer.addEnumParam("flags", GLESEnum::BufferStorageMask, ParamType::TGLbitfield, flags); return CallCapture(angle::EntryPoint::GLNamedBufferStorageExternalEXT, std::move(paramBuffer)); } @@ -6234,8 +6224,8 @@ CallCapture CaptureFramebufferTextureEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -6336,7 +6326,7 @@ CallCapture CaptureMapBufferRangeEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("access", GLESEnum::MapBufferAccessMask, ParamType::TGLbitfield, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); @@ -6435,7 +6425,7 @@ CallCapture CaptureGetMemoryObjectParameterivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -6463,7 +6453,7 @@ CallCapture CaptureGetUnsignedBytevEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::GetPName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetPName, ParamType::TGLenum, pname); if (isCallValid) { @@ -6491,7 +6481,7 @@ CallCapture CaptureGetUnsignedBytei_vEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); if (isCallValid) @@ -6537,7 +6527,7 @@ CallCapture CaptureMemoryObjectParameterivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("memoryObjectPacked", ParamType::TMemoryObjectID, memoryObjectPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::MemoryObjectParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("pname", GLESEnum::MemoryObjectParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -6573,7 +6563,7 @@ CallCapture CaptureTexStorageMem2DEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -6598,7 +6588,7 @@ CallCapture CaptureTexStorageMem2DMultisampleEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -6624,7 +6614,7 @@ CallCapture CaptureTexStorageMem3DEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -6651,7 +6641,7 @@ CallCapture CaptureTexStorageMem3DMultisampleEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, + paramBuffer.addEnumParam("internalFormat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalFormat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -6759,8 +6749,8 @@ CallCapture CaptureFramebufferTexture2DMultisampleEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -6781,9 +6771,9 @@ CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -6910,8 +6900,8 @@ CallCapture CaptureReadnPixelsEXT(const State &glState, paramBuffer.addValueParam("y", ParamType::TGLint, y); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); if (isCallValid) @@ -6999,8 +6989,7 @@ CallCapture CaptureGetSemaphoreParameterui64vEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -7046,8 +7035,7 @@ CallCapture CaptureSemaphoreParameterui64vEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("semaphorePacked", ParamType::TSemaphoreID, semaphorePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SemaphoreParameterName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::SemaphoreParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -7401,8 +7389,7 @@ CallCapture CaptureGetProgramPipelineivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::PipelineParameterName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::PipelineParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -7447,8 +7434,7 @@ CallCapture CaptureProgramParameteriEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::ProgramParameterPName, ParamType::TGLenum, - pname); + paramBuffer.addEnumParam("pname", GLESEnum::ProgramParameterPName, ParamType::TGLenum, pname); paramBuffer.addValueParam("value", ParamType::TGLint, value); return CallCapture(angle::EntryPoint::GLProgramParameteriEXT, std::move(paramBuffer)); @@ -8375,7 +8361,7 @@ CallCapture CaptureUseProgramStagesEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("pipelinePacked", ParamType::TProgramPipelineID, pipelinePacked); - paramBuffer.addEnumParam("stages", GLenumGroup::UseProgramStageMask, ParamType::TGLbitfield, + paramBuffer.addEnumParam("stages", GLESEnum::UseProgramStageMask, ParamType::TGLbitfield, stages); paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); @@ -8407,7 +8393,7 @@ CallCapture CapturePatchParameteriEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::PatchParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::PatchParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("value", ParamType::TGLint, value); return CallCapture(angle::EntryPoint::GLPatchParameteriEXT, std::move(paramBuffer)); @@ -8422,7 +8408,7 @@ CallCapture CaptureGetSamplerParameterIivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -8451,7 +8437,7 @@ CallCapture CaptureGetSamplerParameterIuivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -8481,7 +8467,7 @@ CallCapture CaptureGetTexParameterIivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -8510,7 +8496,7 @@ CallCapture CaptureGetTexParameterIuivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -8540,7 +8526,7 @@ CallCapture CaptureSamplerParameterIivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -8570,7 +8556,7 @@ CallCapture CaptureSamplerParameterIuivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -8600,7 +8586,7 @@ CallCapture CaptureTexParameterIivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -8630,7 +8616,7 @@ CallCapture CaptureTexParameterIuivEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -8660,7 +8646,7 @@ CallCapture CaptureTexBufferEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); @@ -8678,7 +8664,7 @@ CallCapture CaptureTexBufferRangeEXT(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -8696,9 +8682,9 @@ CallCapture CaptureTexStorage1DEXT(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::TextureTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::TextureTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); @@ -8717,7 +8703,7 @@ CallCapture CaptureTexStorage2DEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -8738,7 +8724,7 @@ CallCapture CaptureTexStorage3DEXT(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("levels", ParamType::TGLsizei, levels); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -8793,9 +8779,9 @@ CallCapture CaptureDebugMessageControlKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); - paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type); - paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity); paramBuffer.addValueParam("count", ParamType::TGLsizei, count); if (isCallValid) @@ -8830,10 +8816,10 @@ CallCapture CaptureDebugMessageInsertKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); - paramBuffer.addEnumParam("type", GLenumGroup::DebugType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("type", GLESEnum::DebugType, ParamType::TGLenum, type); paramBuffer.addValueParam("id", ParamType::TGLuint, id); - paramBuffer.addEnumParam("severity", GLenumGroup::DebugSeverity, ParamType::TGLenum, severity); + paramBuffer.addEnumParam("severity", GLESEnum::DebugSeverity, ParamType::TGLenum, severity); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); if (isCallValid) @@ -8986,8 +8972,7 @@ CallCapture CaptureGetObjectLabelKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("identifier", GLenumGroup::DefaultGroup, ParamType::TGLenum, - identifier); + paramBuffer.addEnumParam("identifier", GLESEnum::AllEnums, ParamType::TGLenum, identifier); paramBuffer.addValueParam("name", ParamType::TGLuint, name); paramBuffer.addValueParam("bufSize", ParamType::TGLsizei, bufSize); @@ -9095,7 +9080,7 @@ CallCapture CaptureGetPointervKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -9124,7 +9109,7 @@ CallCapture CaptureObjectLabelKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("identifier", GLenumGroup::ObjectIdentifier, ParamType::TGLenum, + paramBuffer.addEnumParam("identifier", GLESEnum::ObjectIdentifier, ParamType::TGLenum, identifier); paramBuffer.addValueParam("name", ParamType::TGLuint, name); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); @@ -9207,7 +9192,7 @@ CallCapture CapturePushDebugGroupKHR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("source", GLenumGroup::DebugSource, ParamType::TGLenum, source); + paramBuffer.addEnumParam("source", GLESEnum::DebugSource, ParamType::TGLenum, source); paramBuffer.addValueParam("id", ParamType::TGLuint, id); paramBuffer.addValueParam("length", ParamType::TGLsizei, length); @@ -9247,8 +9232,8 @@ CallCapture CaptureFramebufferParameteriMESA(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferParameterName, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); @@ -9263,8 +9248,8 @@ CallCapture CaptureGetFramebufferParameterivMESA(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -9358,7 +9343,7 @@ CallCapture CaptureGetFenceivNV(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -9401,7 +9386,7 @@ CallCapture CaptureSetFenceNV(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("fencePacked", ParamType::TFenceNVID, fencePacked); - paramBuffer.addEnumParam("condition", GLenumGroup::DefaultGroup, ParamType::TGLenum, condition); + paramBuffer.addEnumParam("condition", GLESEnum::AllEnums, ParamType::TGLenum, condition); return CallCapture(angle::EntryPoint::GLSetFenceNV, std::move(paramBuffer)); } @@ -9445,9 +9430,8 @@ CallCapture CaptureBlitFramebufferNV(const State &glState, paramBuffer.addValueParam("dstY0", ParamType::TGLint, dstY0); paramBuffer.addValueParam("dstX1", ParamType::TGLint, dstX1); paramBuffer.addValueParam("dstY1", ParamType::TGLint, dstY1); - paramBuffer.addEnumParam("mask", GLenumGroup::ClearBufferMask, ParamType::TGLbitfield, mask); - paramBuffer.addEnumParam("filter", GLenumGroup::BlitFramebufferFilter, ParamType::TGLenum, - filter); + paramBuffer.addEnumParam("mask", GLESEnum::ClearBufferMask, ParamType::TGLbitfield, mask); + paramBuffer.addEnumParam("filter", GLESEnum::BlitFramebufferFilter, ParamType::TGLenum, filter); return CallCapture(angle::EntryPoint::GLBlitFramebufferNV, std::move(paramBuffer)); } @@ -9459,7 +9443,7 @@ CallCapture CaptureEGLImageTargetRenderbufferStorageOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::DefaultGroup, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::AllEnums, ParamType::TGLenum, target); paramBuffer.addValueParam("image", ParamType::TGLeglImageOES, image); return CallCapture(angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES, @@ -9500,14 +9484,14 @@ CallCapture CaptureCopyImageSubDataOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("srcName", ParamType::TGLuint, srcName); - paramBuffer.addEnumParam("srcTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("srcTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum, srcTarget); paramBuffer.addValueParam("srcLevel", ParamType::TGLint, srcLevel); paramBuffer.addValueParam("srcX", ParamType::TGLint, srcX); paramBuffer.addValueParam("srcY", ParamType::TGLint, srcY); paramBuffer.addValueParam("srcZ", ParamType::TGLint, srcZ); paramBuffer.addValueParam("dstName", ParamType::TGLuint, dstName); - paramBuffer.addEnumParam("dstTarget", GLenumGroup::CopyBufferSubDataTarget, ParamType::TGLenum, + paramBuffer.addEnumParam("dstTarget", GLESEnum::CopyBufferSubDataTarget, ParamType::TGLenum, dstTarget); paramBuffer.addValueParam("dstLevel", ParamType::TGLint, dstLevel); paramBuffer.addValueParam("dstX", ParamType::TGLint, dstX); @@ -9529,9 +9513,9 @@ CallCapture CaptureBlendEquationSeparateiOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("modeRGB", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeRGB", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeRGB); - paramBuffer.addEnumParam("modeAlpha", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, + paramBuffer.addEnumParam("modeAlpha", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, modeAlpha); return CallCapture(angle::EntryPoint::GLBlendEquationSeparateiOES, std::move(paramBuffer)); @@ -9545,7 +9529,7 @@ CallCapture CaptureBlendEquationiOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("mode", GLenumGroup::BlendEquationModeEXT, ParamType::TGLenum, mode); + paramBuffer.addEnumParam("mode", GLESEnum::BlendEquationModeEXT, ParamType::TGLenum, mode); return CallCapture(angle::EntryPoint::GLBlendEquationiOES, std::move(paramBuffer)); } @@ -9561,10 +9545,10 @@ CallCapture CaptureBlendFuncSeparateiOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("srcRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcRGB); - paramBuffer.addEnumParam("dstRGB", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstRGB); - paramBuffer.addEnumParam("srcAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, srcAlpha); - paramBuffer.addEnumParam("dstAlpha", GLenumGroup::BlendingFactor, ParamType::TGLenum, dstAlpha); + paramBuffer.addEnumParam("srcRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, srcRGB); + paramBuffer.addEnumParam("dstRGB", GLESEnum::BlendingFactor, ParamType::TGLenum, dstRGB); + paramBuffer.addEnumParam("srcAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, srcAlpha); + paramBuffer.addEnumParam("dstAlpha", GLESEnum::BlendingFactor, ParamType::TGLenum, dstAlpha); return CallCapture(angle::EntryPoint::GLBlendFuncSeparateiOES, std::move(paramBuffer)); } @@ -9578,8 +9562,8 @@ CallCapture CaptureBlendFunciOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("buf", ParamType::TGLuint, buf); - paramBuffer.addEnumParam("src", GLenumGroup::BlendingFactor, ParamType::TGLenum, src); - paramBuffer.addEnumParam("dst", GLenumGroup::BlendingFactor, ParamType::TGLenum, dst); + paramBuffer.addEnumParam("src", GLESEnum::BlendingFactor, ParamType::TGLenum, src); + paramBuffer.addEnumParam("dst", GLESEnum::BlendingFactor, ParamType::TGLenum, dst); return CallCapture(angle::EntryPoint::GLBlendFunciOES, std::move(paramBuffer)); } @@ -9607,7 +9591,7 @@ CallCapture CaptureDisableiOES(const State &glState, bool isCallValid, GLenum ta { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLDisableiOES, std::move(paramBuffer)); @@ -9617,7 +9601,7 @@ CallCapture CaptureEnableiOES(const State &glState, bool isCallValid, GLenum tar { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); return CallCapture(angle::EntryPoint::GLEnableiOES, std::move(paramBuffer)); @@ -9631,7 +9615,7 @@ CallCapture CaptureIsEnablediOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::EnableCap, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::EnableCap, ParamType::TGLenum, target); paramBuffer.addValueParam("index", ParamType::TGLuint, index); ParamCapture returnValueCapture("returnValue", ParamType::TGLboolean); @@ -9926,7 +9910,7 @@ CallCapture CaptureBindFramebufferOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("framebufferPacked", ParamType::TFramebufferID, framebufferPacked); return CallCapture(angle::EntryPoint::GLBindFramebufferOES, std::move(paramBuffer)); @@ -9939,7 +9923,7 @@ CallCapture CaptureBindRenderbufferOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); return CallCapture(angle::EntryPoint::GLBindRenderbufferOES, std::move(paramBuffer)); @@ -9952,7 +9936,7 @@ CallCapture CaptureCheckFramebufferStatusOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); ParamCapture returnValueCapture("returnValue", ParamType::TGLenum); InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value); @@ -10033,11 +10017,11 @@ CallCapture CaptureFramebufferRenderbufferOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("renderbuffertarget", GLenumGroup::RenderbufferTarget, - ParamType::TGLenum, renderbuffertarget); + paramBuffer.addEnumParam("renderbuffertarget", GLESEnum::RenderbufferTarget, ParamType::TGLenum, + renderbuffertarget); paramBuffer.addValueParam("renderbufferPacked", ParamType::TRenderbufferID, renderbufferPacked); return CallCapture(angle::EntryPoint::GLFramebufferRenderbufferOES, std::move(paramBuffer)); @@ -10053,8 +10037,8 @@ CallCapture CaptureFramebufferTexture2DOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -10145,10 +10129,10 @@ CallCapture CaptureGetFramebufferAttachmentParameterivOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); - paramBuffer.addEnumParam("pname", GLenumGroup::FramebufferAttachmentParameterName, + paramBuffer.addEnumParam("pname", GLESEnum::FramebufferAttachmentParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -10178,8 +10162,8 @@ CallCapture CaptureGetRenderbufferParameterivOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("pname", GLenumGroup::RenderbufferParameterName, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("pname", GLESEnum::RenderbufferParameterName, ParamType::TGLenum, pname); if (isCallValid) @@ -10241,8 +10225,8 @@ CallCapture CaptureRenderbufferStorageOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::RenderbufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::RenderbufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -10259,8 +10243,8 @@ CallCapture CaptureFramebufferTextureOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -10341,8 +10325,7 @@ CallCapture CaptureProgramBinaryOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("programPacked", ParamType::TShaderProgramID, programPacked); - paramBuffer.addEnumParam("binaryFormat", GLenumGroup::DefaultGroup, ParamType::TGLenum, - binaryFormat); + paramBuffer.addEnumParam("binaryFormat", GLESEnum::AllEnums, ParamType::TGLenum, binaryFormat); if (isCallValid) { @@ -10374,7 +10357,7 @@ CallCapture CaptureGetBufferPointervOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::DefaultGroup, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::AllEnums, ParamType::TGLenum, pname); if (isCallValid) { @@ -10404,7 +10387,7 @@ CallCapture CaptureMapBufferOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked); - paramBuffer.addEnumParam("access", GLenumGroup::BufferAccessARB, ParamType::TGLenum, access); + paramBuffer.addEnumParam("access", GLESEnum::BufferAccessARB, ParamType::TGLenum, access); ParamCapture returnValueCapture("returnValue", ParamType::TvoidPointer); InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value); @@ -10458,7 +10441,7 @@ CallCapture CaptureMatrixIndexPointerOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -10490,7 +10473,7 @@ CallCapture CaptureWeightPointerOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("size", ParamType::TGLint, size); - paramBuffer.addEnumParam("type", GLenumGroup::DefaultGroup, ParamType::TGLenum, type); + paramBuffer.addEnumParam("type", GLESEnum::AllEnums, ParamType::TGLenum, type); paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride); if (isCallValid) @@ -10637,7 +10620,7 @@ CallCapture CaptureCompressedTexImage3DOES(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -10689,7 +10672,7 @@ CallCapture CaptureCompressedTexSubImage3DOES(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("format", GLESEnum::InternalFormat, ParamType::TGLenum, format); paramBuffer.addValueParam("imageSize", ParamType::TGLsizei, imageSize); if (isCallValid) @@ -10750,8 +10733,8 @@ CallCapture CaptureFramebufferTexture3DOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("textargetPacked", ParamType::TTextureTarget, textargetPacked); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); @@ -10778,14 +10761,14 @@ CallCapture CaptureTexImage3DOES(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureTarget, targetPacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::InternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); paramBuffer.addValueParam("border", ParamType::TGLint, border); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -10831,8 +10814,8 @@ CallCapture CaptureTexSubImage3DOES(const State &glState, paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth); - paramBuffer.addEnumParam("format", GLenumGroup::PixelFormat, ParamType::TGLenum, format); - paramBuffer.addEnumParam("type", GLenumGroup::PixelType, ParamType::TGLenum, type); + paramBuffer.addEnumParam("format", GLESEnum::PixelFormat, ParamType::TGLenum, format); + paramBuffer.addEnumParam("type", GLESEnum::PixelType, ParamType::TGLenum, type); if (isCallValid) { @@ -10863,7 +10846,7 @@ CallCapture CaptureGetSamplerParameterIivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -10892,7 +10875,7 @@ CallCapture CaptureGetSamplerParameterIuivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -10922,7 +10905,7 @@ CallCapture CaptureGetTexParameterIivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -10951,7 +10934,7 @@ CallCapture CaptureGetTexParameterIuivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::GetTextureParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::GetTextureParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -10981,7 +10964,7 @@ CallCapture CaptureSamplerParameterIivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -11011,7 +10994,7 @@ CallCapture CaptureSamplerParameterIuivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("samplerPacked", ParamType::TSamplerID, samplerPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::SamplerParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::SamplerParameterI, ParamType::TGLenum, pname); if (isCallValid) { @@ -11041,7 +11024,7 @@ CallCapture CaptureTexParameterIivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -11071,7 +11054,7 @@ CallCapture CaptureTexParameterIuivOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureParameterName, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("pname", GLESEnum::TextureParameterName, ParamType::TGLenum, pname); if (isCallValid) { @@ -11101,7 +11084,7 @@ CallCapture CaptureTexBufferOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); @@ -11119,7 +11102,7 @@ CallCapture CaptureTexBufferRangeOES(const State &glState, ParamBuffer paramBuffer; paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("bufferPacked", ParamType::TBufferID, bufferPacked); paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset); @@ -11136,8 +11119,8 @@ CallCapture CaptureGetTexGenfvOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11165,8 +11148,8 @@ CallCapture CaptureGetTexGenivOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11193,8 +11176,8 @@ CallCapture CaptureGetTexGenxvOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11222,8 +11205,8 @@ CallCapture CaptureTexGenfOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfloat, param); return CallCapture(angle::EntryPoint::GLTexGenfOES, std::move(paramBuffer)); @@ -11237,8 +11220,8 @@ CallCapture CaptureTexGenfvOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11266,8 +11249,8 @@ CallCapture CaptureTexGeniOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLint, param); return CallCapture(angle::EntryPoint::GLTexGeniOES, std::move(paramBuffer)); @@ -11281,8 +11264,8 @@ CallCapture CaptureTexGenivOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11310,8 +11293,8 @@ CallCapture CaptureTexGenxOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); paramBuffer.addValueParam("param", ParamType::TGLfixed, param); return CallCapture(angle::EntryPoint::GLTexGenxOES, std::move(paramBuffer)); @@ -11325,8 +11308,8 @@ CallCapture CaptureTexGenxvOES(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("coord", GLenumGroup::TextureCoordName, ParamType::TGLenum, coord); - paramBuffer.addEnumParam("pname", GLenumGroup::TextureGenParameter, ParamType::TGLenum, pname); + paramBuffer.addEnumParam("coord", GLESEnum::TextureCoordName, ParamType::TGLenum, coord); + paramBuffer.addEnumParam("pname", GLESEnum::TextureGenParameter, ParamType::TGLenum, pname); if (isCallValid) { @@ -11360,7 +11343,7 @@ CallCapture CaptureTexStorage3DMultisampleOES(const State &glState, paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked); paramBuffer.addValueParam("samples", ParamType::TGLsizei, samples); - paramBuffer.addEnumParam("internalformat", GLenumGroup::InternalFormat, ParamType::TGLenum, + paramBuffer.addEnumParam("internalformat", GLESEnum::SizedInternalFormat, ParamType::TGLenum, internalformat); paramBuffer.addValueParam("width", ParamType::TGLsizei, width); paramBuffer.addValueParam("height", ParamType::TGLsizei, height); @@ -11465,8 +11448,8 @@ CallCapture CaptureFramebufferTextureMultiviewOVR(const State &glState, { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("target", GLenumGroup::FramebufferTarget, ParamType::TGLenum, target); - paramBuffer.addEnumParam("attachment", GLenumGroup::FramebufferAttachment, ParamType::TGLenum, + paramBuffer.addEnumParam("target", GLESEnum::FramebufferTarget, ParamType::TGLenum, target); + paramBuffer.addEnumParam("attachment", GLESEnum::FramebufferAttachment, ParamType::TGLenum, attachment); paramBuffer.addValueParam("texturePacked", ParamType::TTextureID, texturePacked); paramBuffer.addValueParam("level", ParamType::TGLint, level); @@ -11480,7 +11463,7 @@ CallCapture CaptureShadingRateQCOM(const State &glState, bool isCallValid, GLenu { ParamBuffer paramBuffer; - paramBuffer.addEnumParam("rate", GLenumGroup::ShadingRate, ParamType::TGLenum, rate); + paramBuffer.addEnumParam("rate", GLESEnum::ShadingRateQCOM, ParamType::TGLenum, rate); return CallCapture(angle::EntryPoint::GLShadingRateQCOM, std::move(paramBuffer)); } diff --git a/src/libANGLE/capture/capture_gles_ext_autogen.h b/src/libANGLE/capture/capture_gles_ext_autogen.h index 2cd2b0cc3..3982de121 100644 --- a/src/libANGLE/capture/capture_gles_ext_autogen.h +++ b/src/libANGLE/capture/capture_gles_ext_autogen.h @@ -891,7 +891,7 @@ angle::CallCapture CaptureSampleMaskiANGLE(const State &glState, angle::CallCapture CaptureGetTranslatedShaderSourceANGLE(const State &glState, bool isCallValid, ShaderProgramID shaderPacked, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source); @@ -1240,7 +1240,7 @@ angle::CallCapture CaptureMultiDrawElementsBaseVertexEXT(const State &glState, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex); // GL_EXT_external_buffer @@ -1423,6 +1423,8 @@ angle::CallCapture CaptureRenderbufferStorageMultisampleEXT(const State &glState GLsizei width, GLsizei height); +// GL_EXT_multisampled_render_to_texture2 + // GL_EXT_occlusion_query_boolean // GL_EXT_primitive_bounding_box @@ -4073,14 +4075,14 @@ void CaptureGetMultisamplefvANGLE_val(const State &glState, void CaptureGetTranslatedShaderSourceANGLE_length(const State &glState, bool isCallValid, ShaderProgramID shaderPacked, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source, angle::ParamCapture *paramCapture); void CaptureGetTranslatedShaderSourceANGLE_source(const State &glState, bool isCallValid, ShaderProgramID shaderPacked, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source, angle::ParamCapture *paramCapture); @@ -4299,7 +4301,7 @@ void CaptureMultiDrawElementsBaseVertexEXT_count(const State &glState, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex, angle::ParamCapture *paramCapture); void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState, @@ -4308,7 +4310,7 @@ void CaptureMultiDrawElementsBaseVertexEXT_indices(const State &glState, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex, angle::ParamCapture *paramCapture); void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState, @@ -4317,7 +4319,7 @@ void CaptureMultiDrawElementsBaseVertexEXT_basevertex(const State &glState, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex, angle::ParamCapture *paramCapture); void CaptureDrawElementsInstancedEXT_indices(const State &glState, diff --git a/src/libANGLE/capture/frame_capture_replay_autogen.cpp b/src/libANGLE/capture/frame_capture_replay_autogen.cpp index b9b46d86d..0e025456b 100644 --- a/src/libANGLE/capture/frame_capture_replay_autogen.cpp +++ b/src/libANGLE/capture/frame_capture_replay_autogen.cpp @@ -1236,7 +1236,7 @@ void FrameCaptureShared::ReplayCall(gl::Context *context, params.getParam("target", ParamType::TGLenum, 0).value.GLenumVal, params.getParam("internalformat", ParamType::TGLenum, 1).value.GLenumVal, params.getParam("pname", ParamType::TGLenum, 2).value.GLenumVal, - params.getParam("bufSize", ParamType::TGLsizei, 3).value.GLsizeiVal, + params.getParam("count", ParamType::TGLsizei, 3).value.GLsizeiVal, replayContext->getReadBufferPointer( params.getParam("params", ParamType::TGLintPointer, 4))); break; @@ -1394,7 +1394,7 @@ void FrameCaptureShared::ReplayCall(gl::Context *context, params.getParam("propCount", ParamType::TGLsizei, 3).value.GLsizeiVal, replayContext->getAsConstPointer( params.getParam("props", ParamType::TGLenumConstPointer, 4)), - params.getParam("bufSize", ParamType::TGLsizei, 5).value.GLsizeiVal, + params.getParam("count", ParamType::TGLsizei, 5).value.GLsizeiVal, replayContext->getReadBufferPointer( params.getParam("length", ParamType::TGLsizeiPointer, 6)), replayContext->getReadBufferPointer( @@ -1523,7 +1523,7 @@ void FrameCaptureShared::ReplayCall(gl::Context *context, case angle::EntryPoint::GLGetSynciv: context->getSynciv(params.getParam("sync", ParamType::TGLsync, 0).value.GLsyncVal, params.getParam("pname", ParamType::TGLenum, 1).value.GLenumVal, - params.getParam("bufSize", ParamType::TGLsizei, 2).value.GLsizeiVal, + params.getParam("count", ParamType::TGLsizei, 2).value.GLsizeiVal, replayContext->getReadBufferPointer( params.getParam("length", ParamType::TGLsizeiPointer, 3)), replayContext->getReadBufferPointer( @@ -2679,7 +2679,7 @@ void FrameCaptureShared::ReplayCall(gl::Context *context, params.getParam("count", ParamType::TGLsizei, 0).value.GLsizeiVal, replayContext->getAsConstPointer( params.getParam("shadersPacked", ParamType::TShaderProgramIDConstPointer, 1)), - params.getParam("binaryformat", ParamType::TGLenum, 2).value.GLenumVal, + params.getParam("binaryFormat", ParamType::TGLenum, 2).value.GLenumVal, replayContext->getAsConstPointer( params.getParam("binary", ParamType::TvoidConstPointer, 3)), params.getParam("length", ParamType::TGLsizei, 4).value.GLsizeiVal); diff --git a/src/libANGLE/capture/frame_capture_utils.cpp b/src/libANGLE/capture/frame_capture_utils.cpp index 8e489aebe..e750a6c63 100644 --- a/src/libANGLE/capture/frame_capture_utils.cpp +++ b/src/libANGLE/capture/frame_capture_utils.cpp @@ -218,8 +218,7 @@ bool IsValidColorAttachmentBinding(GLenum binding, size_t colorAttachmentsCount) void SerializeFormat(JsonSerializer *json, GLenum glFormat) { - json->addCString("InternalFormat", - gl::GLenumToString(gl::GLenumGroup::InternalFormat, glFormat)); + json->addCString("InternalFormat", gl::GLenumToString(gl::GLESEnum::InternalFormat, glFormat)); } void SerializeInternalFormat(JsonSerializer *json, const gl::InternalFormat *internalFormat) @@ -273,15 +272,15 @@ Result SerializeFramebufferAttachment(const gl::Context *context, ScratchBuffer *scratchBuffer, gl::Framebuffer *framebuffer, const gl::FramebufferAttachment &framebufferAttachment, - gl::GLenumGroup enumGroup) + gl::GLESEnum enumGroup) { if (framebufferAttachment.type() == GL_TEXTURE || framebufferAttachment.type() == GL_RENDERBUFFER) { json->addScalar("AttachedResourceID", framebufferAttachment.id()); } - json->addCString("Type", gl::GLenumToString(gl::GLenumGroup::ObjectIdentifier, - framebufferAttachment.type())); + json->addCString( + "Type", gl::GLenumToString(gl::GLESEnum::ObjectIdentifier, framebufferAttachment.type())); // serialize target variable json->addString("Binding", gl::GLenumToString(enumGroup, framebufferAttachment.getBinding())); if (framebufferAttachment.type() == GL_TEXTURE) @@ -360,7 +359,7 @@ Result SerializeFramebufferState(const gl::Context *context, static_cast(attachmentIndex)); ANGLE_TRY(SerializeFramebufferAttachment(context, json, scratchBuffer, framebuffer, colorAttachment, - gl::GLenumGroup::ColorBuffer)); + gl::GLESEnum::ColorBuffer)); } } if (framebuffer->getDepthStencilAttachment()) @@ -368,7 +367,7 @@ Result SerializeFramebufferState(const gl::Context *context, GroupScope dsAttachmentgroup(json, "DepthStencilAttachment"); ANGLE_TRY(SerializeFramebufferAttachment(context, json, scratchBuffer, framebuffer, *framebuffer->getDepthStencilAttachment(), - gl::GLenumGroup::DefaultGroup)); + gl::GLESEnum::AllEnums)); } else { @@ -377,14 +376,14 @@ Result SerializeFramebufferState(const gl::Context *context, GroupScope depthAttachmentgroup(json, "DepthAttachment"); ANGLE_TRY(SerializeFramebufferAttachment(context, json, scratchBuffer, framebuffer, *framebuffer->getDepthAttachment(), - gl::GLenumGroup::FramebufferAttachment)); + gl::GLESEnum::FramebufferAttachment)); } if (framebuffer->getStencilAttachment()) { GroupScope stencilAttachmengroup(json, "StencilAttachment"); ANGLE_TRY(SerializeFramebufferAttachment(context, json, scratchBuffer, framebuffer, *framebuffer->getStencilAttachment(), - gl::GLenumGroup::DefaultGroup)); + gl::GLESEnum::AllEnums)); } } } @@ -1113,7 +1112,7 @@ void SerializeProgram(JsonSerializer *json, json->addCString("Name", uniformName); json->addScalar("Size", size); - json->addCString("Type", gl::GLenumToString(gl::GLenumGroup::AttributeType, type)); + json->addCString("Type", gl::GLenumToString(gl::GLESEnum::AttributeType, type)); const gl::UniformLocation loc = program->getUniformLocation(uniformName); diff --git a/src/libANGLE/capture/gl_enum_utils.cpp b/src/libANGLE/capture/gl_enum_utils.cpp index 8f3011e14..1ec5c8dfc 100644 --- a/src/libANGLE/capture/gl_enum_utils.cpp +++ b/src/libANGLE/capture/gl_enum_utils.cpp @@ -17,7 +17,7 @@ namespace gl { const char kUnknownGLenumString[] = "EnumUnknown"; -void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int value) +void OutputGLenumString(std::ostream &out, GLESEnum enumGroup, unsigned int value) { const char *enumStr = GLenumToString(enumGroup, value); if (enumStr != kUnknownGLenumString) @@ -26,7 +26,7 @@ void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int v return; } - if (enumGroup == GLenumGroup::Boolean) + if (enumGroup == GLESEnum::Boolean) { // If an unknown enum was submitted as GLboolean, just write out the value. if (enumStr == kUnknownGLenumString) @@ -41,10 +41,10 @@ void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int v return; } - if (enumGroup != GLenumGroup::DefaultGroup) + if (enumGroup != GLESEnum::AllEnums) { // Retry with the "Default" group - enumStr = GLenumToString(GLenumGroup::DefaultGroup, value); + enumStr = GLenumToString(GLESEnum::AllEnums, value); if (enumStr != kUnknownGLenumString) { out << enumStr; @@ -55,17 +55,17 @@ void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int v out << std::hex << "0x" << std::setfill('0') << std::setw(4) << value << std::dec; } -void OutputGLbitfieldString(std::ostream &out, GLenumGroup enumGroup, unsigned int value) +void OutputGLbitfieldString(std::ostream &out, GLESEnum enumGroup, unsigned int value) { out << GLbitfieldToString(enumGroup, value); } const char *GLbooleanToString(unsigned int value) { - return GLenumToString(GLenumGroup::Boolean, value); + return GLenumToString(GLESEnum::Boolean, value); } -std::string GLbitfieldToString(GLenumGroup enumGroup, unsigned int value) +std::string GLbitfieldToString(GLESEnum enumGroup, unsigned int value) { std::stringstream st; @@ -93,6 +93,6 @@ std::string GLbitfieldToString(GLenumGroup enumGroup, unsigned int value) const char *GLinternalFormatToString(unsigned int format) { - return GLenumToString(gl::GLenumGroup::InternalFormat, format); + return GLenumToString(gl::GLESEnum::InternalFormat, format); } } // namespace gl diff --git a/src/libANGLE/capture/gl_enum_utils.h b/src/libANGLE/capture/gl_enum_utils.h index 39ec03719..ce112d8a2 100644 --- a/src/libANGLE/capture/gl_enum_utils.h +++ b/src/libANGLE/capture/gl_enum_utils.h @@ -17,10 +17,11 @@ namespace gl { const char *GLbooleanToString(unsigned int value); -const char *GLenumToString(GLenumGroup enumGroup, unsigned int value); -std::string GLbitfieldToString(GLenumGroup enumGroup, unsigned int value); -void OutputGLenumString(std::ostream &out, GLenumGroup enumGroup, unsigned int value); -void OutputGLbitfieldString(std::ostream &out, GLenumGroup enumGroup, unsigned int value); +const char *GLenumToString(GLESEnum enumGroup, unsigned int value); +const char *GLenumToString(BigGLEnum enumGroup, unsigned int value); +std::string GLbitfieldToString(GLESEnum enumGroup, unsigned int value); +void OutputGLenumString(std::ostream &out, GLESEnum enumGroup, unsigned int value); +void OutputGLbitfieldString(std::ostream &out, GLESEnum enumGroup, unsigned int value); const char *GLinternalFormatToString(unsigned int format); extern const char kUnknownGLenumString[]; diff --git a/src/libANGLE/capture/gl_enum_utils_autogen.cpp b/src/libANGLE/capture/gl_enum_utils_autogen.cpp index b8dd93313..6a21fc3ca 100644 --- a/src/libANGLE/capture/gl_enum_utils_autogen.cpp +++ b/src/libANGLE/capture/gl_enum_utils_autogen.cpp @@ -16,7 +16,7 @@ namespace gl { namespace { -const char *UnknownGLenumToString(unsigned int value) +const char *UnknownEnumToString(unsigned int value) { constexpr size_t kBufferSize = 64; static thread_local char sBuffer[kBufferSize]; @@ -25,16 +25,69 @@ const char *UnknownGLenumToString(unsigned int value) } } // anonymous namespace -const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) +const char *GLenumToString(GLESEnum enumGroup, unsigned int value) { switch (enumGroup) { - case GLenumGroup::AlphaFunction: + case GLESEnum::AccumOp: { switch (value) { + case 0x104: + return "GL_ADD"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::AllEnums: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_CREATE_SPARSE_BINDING_BIT_ANGLE"; + case 0x2: + return "GL_CONTEXT_FLAG_DEBUG_BIT"; + case 0x3: + return "GL_LINE_STRIP"; + case 0x4: + return "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"; + case 0x5: + return "GL_TRIANGLE_STRIP"; + case 0x6: + return "GL_TRIANGLE_FAN"; + case 0x7: + return "GL_QUADS"; + case 0x8: + return "GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR"; + case 0xA: + return "GL_LINES_ADJACENCY"; + case 0xB: + return "GL_LINE_STRIP_ADJACENCY"; + case 0xC: + return "GL_TRIANGLES_ADJACENCY"; + case 0xD: + return "GL_TRIANGLE_STRIP_ADJACENCY"; + case 0xE: + return "GL_PATCHES"; + case 0x10: + return "GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT"; + case 0x16: + return "GL_UUID_SIZE_EXT"; + case 0x20: + return "GL_COMPUTE_SHADER_BIT"; + case 0x40: + return "GL_COMMAND_BARRIER_BIT"; + case 0x80: + return "GL_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_ANGLE"; + case 0x100: + return "GL_CREATE_EXTENDED_USAGE_BIT_ANGLE"; + case 0x104: + return "GL_ADD"; case 0x200: - return "GL_NEVER"; + return "GL_BUFFER_UPDATE_BARRIER_BIT"; case 0x201: return "GL_LESS"; case 0x202: @@ -49,160 +102,6 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_GEQUAL"; case 0x207: return "GL_ALWAYS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::AtomicCounterBufferPName: - { - switch (value) - { - case 0x92C1: - return "GL_ATOMIC_COUNTER_BUFFER_BINDING"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::AttribMask: - { - switch (value) - { - case 0x100: - return "GL_DEPTH_BUFFER_BIT"; - case 0x400: - return "GL_STENCIL_BUFFER_BIT"; - case 0x4000: - return "GL_COLOR_BUFFER_BIT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::AttributeType: - { - switch (value) - { - case 0x8B50: - return "GL_FLOAT_VEC2"; - case 0x8B51: - return "GL_FLOAT_VEC3"; - case 0x8B52: - return "GL_FLOAT_VEC4"; - case 0x8B53: - return "GL_INT_VEC2"; - case 0x8B54: - return "GL_INT_VEC3"; - case 0x8B55: - return "GL_INT_VEC4"; - case 0x8B56: - return "GL_BOOL"; - case 0x8B57: - return "GL_BOOL_VEC2"; - case 0x8B58: - return "GL_BOOL_VEC3"; - case 0x8B59: - return "GL_BOOL_VEC4"; - case 0x8B5A: - return "GL_FLOAT_MAT2"; - case 0x8B5B: - return "GL_FLOAT_MAT3"; - case 0x8B5C: - return "GL_FLOAT_MAT4"; - case 0x8B5E: - return "GL_SAMPLER_2D"; - case 0x8B5F: - return "GL_SAMPLER_3D"; - case 0x8B60: - return "GL_SAMPLER_CUBE"; - case 0x8B62: - return "GL_SAMPLER_2D_SHADOW"; - case 0x8B65: - return "GL_FLOAT_MAT2x3"; - case 0x8B66: - return "GL_FLOAT_MAT2x4"; - case 0x8B67: - return "GL_FLOAT_MAT3x2"; - case 0x8B68: - return "GL_FLOAT_MAT3x4"; - case 0x8B69: - return "GL_FLOAT_MAT4x2"; - case 0x8B6A: - return "GL_FLOAT_MAT4x3"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BindTransformFeedbackTarget: - { - switch (value) - { - case 0x8E22: - return "GL_TRANSFORM_FEEDBACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BlendEquationModeEXT: - { - switch (value) - { - case 0x8006: - return "GL_FUNC_ADD"; - case 0x8007: - return "GL_MIN_EXT"; - case 0x8008: - return "GL_MAX_EXT"; - case 0x800A: - return "GL_FUNC_SUBTRACT"; - case 0x800B: - return "GL_FUNC_REVERSE_SUBTRACT"; - case 0x9294: - return "GL_MULTIPLY"; - case 0x9295: - return "GL_SCREEN"; - case 0x9296: - return "GL_OVERLAY"; - case 0x9297: - return "GL_DARKEN"; - case 0x9298: - return "GL_LIGHTEN"; - case 0x9299: - return "GL_COLORDODGE"; - case 0x929A: - return "GL_COLORBURN"; - case 0x929B: - return "GL_HARDLIGHT"; - case 0x929C: - return "GL_SOFTLIGHT"; - case 0x929E: - return "GL_DIFFERENCE"; - case 0x92A0: - return "GL_EXCLUSION"; - case 0x92AD: - return "GL_HSL_HUE"; - case 0x92AE: - return "GL_HSL_SATURATION"; - case 0x92AF: - return "GL_HSL_COLOR"; - case 0x92B0: - return "GL_HSL_LUMINOSITY"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BlendingFactor: - { - switch (value) - { - case 0x0: - return "GL_ZERO"; - case 0x1: - return "GL_ONE"; case 0x300: return "GL_SRC_COLOR"; case 0x301: @@ -221,327 +120,248 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_ONE_MINUS_DST_COLOR"; case 0x308: return "GL_SRC_ALPHA_SATURATE"; - case 0x8001: - return "GL_CONSTANT_COLOR"; - case 0x8002: - return "GL_ONE_MINUS_CONSTANT_COLOR"; - case 0x8003: - return "GL_CONSTANT_ALPHA"; - case 0x8004: - return "GL_ONE_MINUS_CONSTANT_ALPHA"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BlitFramebufferFilter: - { - switch (value) - { - case 0x2600: - return "GL_NEAREST"; - case 0x2601: - return "GL_LINEAR"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::Boolean: - { - switch (value) - { - case 0x0: - return "GL_FALSE"; - case 0x1: - return "GL_TRUE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::Buffer: - { - switch (value) - { - case 0x1800: - return "GL_COLOR"; - case 0x1801: - return "GL_DEPTH"; - case 0x1802: - return "GL_STENCIL"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BufferAccessARB: - { - switch (value) - { - case 0x88B8: - return "GL_READ_ONLY"; - case 0x88B9: - return "GL_WRITE_ONLY"; - case 0x88BA: - return "GL_READ_WRITE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BufferAccessMask: - { - switch (value) - { - case 0x1: - return "GL_MAP_READ_BIT"; - case 0x2: - return "GL_MAP_WRITE_BIT"; - case 0x4: - return "GL_MAP_INVALIDATE_RANGE_BIT"; - case 0x8: - return "GL_MAP_INVALIDATE_BUFFER_BIT"; - case 0x10: - return "GL_MAP_FLUSH_EXPLICIT_BIT"; - case 0x20: - return "GL_MAP_UNSYNCHRONIZED_BIT"; - case 0x40: - return "GL_MAP_PERSISTENT_BIT_EXT"; - case 0x80: - return "GL_MAP_COHERENT_BIT_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BufferStorageTarget: - { - switch (value) - { - case 0x8892: - return "GL_ARRAY_BUFFER"; - case 0x8893: - return "GL_ELEMENT_ARRAY_BUFFER"; - case 0x88EB: - return "GL_PIXEL_PACK_BUFFER"; - case 0x88EC: - return "GL_PIXEL_UNPACK_BUFFER"; - case 0x8A11: - return "GL_UNIFORM_BUFFER"; - case 0x8C2A: - return "GL_TEXTURE_BUFFER"; - case 0x8C8E: - return "GL_TRANSFORM_FEEDBACK_BUFFER"; - case 0x8F36: - return "GL_COPY_READ_BUFFER"; - case 0x8F37: - return "GL_COPY_WRITE_BUFFER"; - case 0x8F3F: - return "GL_DRAW_INDIRECT_BUFFER"; - case 0x90D2: - return "GL_SHADER_STORAGE_BUFFER"; - case 0x90EE: - return "GL_DISPATCH_INDIRECT_BUFFER"; - case 0x92C0: - return "GL_ATOMIC_COUNTER_BUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BufferTargetARB: - { - switch (value) - { - case 0x8892: - return "GL_ARRAY_BUFFER"; - case 0x8893: - return "GL_ELEMENT_ARRAY_BUFFER"; - case 0x88EB: - return "GL_PIXEL_PACK_BUFFER"; - case 0x88EC: - return "GL_PIXEL_UNPACK_BUFFER"; - case 0x8A11: - return "GL_UNIFORM_BUFFER"; - case 0x8C2A: - return "GL_TEXTURE_BUFFER"; - case 0x8C8E: - return "GL_TRANSFORM_FEEDBACK_BUFFER"; - case 0x8F36: - return "GL_COPY_READ_BUFFER"; - case 0x8F37: - return "GL_COPY_WRITE_BUFFER"; - case 0x8F3F: - return "GL_DRAW_INDIRECT_BUFFER"; - case 0x90D2: - return "GL_SHADER_STORAGE_BUFFER"; - case 0x90EE: - return "GL_DISPATCH_INDIRECT_BUFFER"; - case 0x92C0: - return "GL_ATOMIC_COUNTER_BUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::BufferUsageARB: - { - switch (value) - { - case 0x88E0: - return "GL_STREAM_DRAW"; - case 0x88E1: - return "GL_STREAM_READ"; - case 0x88E2: - return "GL_STREAM_COPY"; - case 0x88E4: - return "GL_STATIC_DRAW"; - case 0x88E5: - return "GL_STATIC_READ"; - case 0x88E6: - return "GL_STATIC_COPY"; - case 0x88E8: - return "GL_DYNAMIC_DRAW"; - case 0x88E9: - return "GL_DYNAMIC_READ"; - case 0x88EA: - return "GL_DYNAMIC_COPY"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::CheckFramebufferStatusTarget: - { - switch (value) - { - case 0x8CA8: - return "GL_READ_FRAMEBUFFER"; - case 0x8CA9: - return "GL_DRAW_FRAMEBUFFER"; - case 0x8D40: - return "GL_FRAMEBUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ClearBufferMask: - { - switch (value) - { - case 0x100: - return "GL_DEPTH_BUFFER_BIT"; case 0x400: - return "GL_STENCIL_BUFFER_BIT"; - case 0x4000: - return "GL_COLOR_BUFFER_BIT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ColorBuffer: - { - switch (value) - { - case 0x0: - return "GL_NONE"; + return "GL_CREATE_ALIAS_BIT_ANGLE"; case 0x404: return "GL_FRONT"; case 0x405: return "GL_BACK"; case 0x408: return "GL_FRONT_AND_BACK"; - case 0x8CE0: - return "GL_COLOR_ATTACHMENT0"; - case 0x8CE1: - return "GL_COLOR_ATTACHMENT1"; - case 0x8CE2: - return "GL_COLOR_ATTACHMENT2"; - case 0x8CE3: - return "GL_COLOR_ATTACHMENT3"; - case 0x8CE4: - return "GL_COLOR_ATTACHMENT4"; - case 0x8CE5: - return "GL_COLOR_ATTACHMENT5"; - case 0x8CE6: - return "GL_COLOR_ATTACHMENT6"; - case 0x8CE7: - return "GL_COLOR_ATTACHMENT7"; - case 0x8CE8: - return "GL_COLOR_ATTACHMENT8"; - case 0x8CE9: - return "GL_COLOR_ATTACHMENT9"; - case 0x8CEA: - return "GL_COLOR_ATTACHMENT10"; - case 0x8CEB: - return "GL_COLOR_ATTACHMENT11"; - case 0x8CEC: - return "GL_COLOR_ATTACHMENT12"; - case 0x8CED: - return "GL_COLOR_ATTACHMENT13"; - case 0x8CEE: - return "GL_COLOR_ATTACHMENT14"; - case 0x8CEF: - return "GL_COLOR_ATTACHMENT15"; - case 0x8CF0: - return "GL_COLOR_ATTACHMENT16"; - case 0x8CF1: - return "GL_COLOR_ATTACHMENT17"; - case 0x8CF2: - return "GL_COLOR_ATTACHMENT18"; - case 0x8CF3: - return "GL_COLOR_ATTACHMENT19"; - case 0x8CF4: - return "GL_COLOR_ATTACHMENT20"; - case 0x8CF5: - return "GL_COLOR_ATTACHMENT21"; - case 0x8CF6: - return "GL_COLOR_ATTACHMENT22"; - case 0x8CF7: - return "GL_COLOR_ATTACHMENT23"; - case 0x8CF8: - return "GL_COLOR_ATTACHMENT24"; - case 0x8CF9: - return "GL_COLOR_ATTACHMENT25"; - case 0x8CFA: - return "GL_COLOR_ATTACHMENT26"; - case 0x8CFB: - return "GL_COLOR_ATTACHMENT27"; - case 0x8CFC: - return "GL_COLOR_ATTACHMENT28"; - case 0x8CFD: - return "GL_COLOR_ATTACHMENT29"; - case 0x8CFE: - return "GL_COLOR_ATTACHMENT30"; - case 0x8CFF: - return "GL_COLOR_ATTACHMENT31"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ColorMaterialFace: - { - switch (value) - { - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - case 0x408: - return "GL_FRONT_AND_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ColorPointerType: - { - switch (value) - { + case 0x500: + return "GL_INVALID_ENUM"; + case 0x501: + return "GL_INVALID_VALUE"; + case 0x502: + return "GL_INVALID_OPERATION"; + case 0x503: + return "GL_STACK_OVERFLOW"; + case 0x504: + return "GL_STACK_UNDERFLOW"; + case 0x505: + return "GL_OUT_OF_MEMORY"; + case 0x506: + return "GL_INVALID_FRAMEBUFFER_OPERATION"; + case 0x507: + return "GL_CONTEXT_LOST"; + case 0x800: + return "GL_CREATE_PROTECTED_BIT_ANGLE"; + case 0x801: + return "GL_EXP2"; + case 0x900: + return "GL_CW"; + case 0x901: + return "GL_CCW"; + case 0xB00: + return "GL_CURRENT_COLOR"; + case 0xB02: + return "GL_CURRENT_NORMAL"; + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB11: + return "GL_POINT_SIZE"; + case 0xB12: + return "GL_SMOOTH_POINT_SIZE_RANGE"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB21: + return "GL_LINE_WIDTH"; + case 0xB22: + return "GL_SMOOTH_LINE_WIDTH_RANGE"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB45: + return "GL_CULL_FACE_MODE"; + case 0xB46: + return "GL_FRONT_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + case 0xB54: + return "GL_SHADE_MODEL"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + case 0xB70: + return "GL_DEPTH_RANGE"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB72: + return "GL_DEPTH_WRITEMASK"; + case 0xB73: + return "GL_DEPTH_CLEAR_VALUE"; + case 0xB74: + return "GL_DEPTH_FUNC"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xB91: + return "GL_STENCIL_CLEAR_VALUE"; + case 0xB92: + return "GL_STENCIL_FUNC"; + case 0xB93: + return "GL_STENCIL_VALUE_MASK"; + case 0xB94: + return "GL_STENCIL_FAIL"; + case 0xB95: + return "GL_STENCIL_PASS_DEPTH_FAIL"; + case 0xB96: + return "GL_STENCIL_PASS_DEPTH_PASS"; + case 0xB97: + return "GL_STENCIL_REF"; + case 0xB98: + return "GL_STENCIL_WRITEMASK"; + case 0xBA0: + return "GL_MATRIX_MODE"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBA2: + return "GL_VIEWPORT"; + case 0xBA3: + return "GL_MODELVIEW_STACK_DEPTH"; + case 0xBA4: + return "GL_PROJECTION_STACK_DEPTH"; + case 0xBA5: + return "GL_TEXTURE_STACK_DEPTH"; + case 0xBA6: + return "GL_MODELVIEW_MATRIX"; + case 0xBA7: + return "GL_PROJECTION_MATRIX"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBC1: + return "GL_ALPHA_TEST_FUNC"; + case 0xBC2: + return "GL_ALPHA_TEST_REF"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE0: + return "GL_BLEND_DST"; + case 0xBE1: + return "GL_BLEND_SRC"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF0: + return "GL_LOGIC_OP_MODE"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC02: + return "GL_READ_BUFFER"; + case 0xC10: + return "GL_SCISSOR_BOX"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xC22: + return "GL_COLOR_CLEAR_VALUE"; + case 0xC23: + return "GL_COLOR_WRITEMASK"; + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0xD1C: + return "GL_ALPHA_SCALE"; + case 0xD31: + return "GL_MAX_LIGHTS"; + case 0xD32: + return "GL_MAX_CLIP_DISTANCES_APPLE"; + case 0xD33: + return "GL_MAX_TEXTURE_SIZE"; + case 0xD36: + return "GL_MAX_MODELVIEW_STACK_DEPTH"; + case 0xD38: + return "GL_MAX_PROJECTION_STACK_DEPTH"; + case 0xD39: + return "GL_MAX_TEXTURE_STACK_DEPTH"; + case 0xD3A: + return "GL_MAX_VIEWPORT_DIMS"; + case 0xD50: + return "GL_SUBPIXEL_BITS"; + case 0xD52: + return "GL_RED_BITS"; + case 0xD53: + return "GL_GREEN_BITS"; + case 0xD54: + return "GL_BLUE_BITS"; + case 0xD55: + return "GL_ALPHA_BITS"; + case 0xD56: + return "GL_DEPTH_BITS"; + case 0xD57: + return "GL_STENCIL_BITS"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x1000: + return "GL_ATOMIC_COUNTER_BARRIER_BIT"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_INTERNAL_FORMAT"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x1100: + return "GL_DONT_CARE"; + case 0x1101: + return "GL_FASTEST"; + case 0x1102: + return "GL_NICEST"; + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; case 0x1400: return "GL_BYTE"; case 0x1401: @@ -556,205 +376,138 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_UNSIGNED_INT"; case 0x1406: return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ContextFlagMask: - { - switch (value) - { - case 0x2: - return "GL_CONTEXT_FLAG_DEBUG_BIT"; - case 0x4: - return "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"; - case 0x8: - return "GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR"; - case 0x10: - return "GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::CopyBufferSubDataTarget: - { - switch (value) - { - case 0x8892: - return "GL_ARRAY_BUFFER"; - case 0x8893: - return "GL_ELEMENT_ARRAY_BUFFER"; - case 0x88EB: - return "GL_PIXEL_PACK_BUFFER"; - case 0x88EC: - return "GL_PIXEL_UNPACK_BUFFER"; - case 0x8A11: - return "GL_UNIFORM_BUFFER"; - case 0x8C2A: - return "GL_TEXTURE_BUFFER"; - case 0x8C8E: - return "GL_TRANSFORM_FEEDBACK_BUFFER"; - case 0x8F36: - return "GL_COPY_READ_BUFFER"; - case 0x8F37: - return "GL_COPY_WRITE_BUFFER"; - case 0x8F3F: - return "GL_DRAW_INDIRECT_BUFFER"; - case 0x90D2: - return "GL_SHADER_STORAGE_BUFFER"; - case 0x90EE: - return "GL_DISPATCH_INDIRECT_BUFFER"; - case 0x92C0: - return "GL_ATOMIC_COUNTER_BUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::CullFaceMode: - { - switch (value) - { - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - case 0x408: - return "GL_FRONT_AND_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DebugSeverity: - { - switch (value) - { - case 0x1100: - return "GL_DONT_CARE"; - case 0x9146: - return "GL_DEBUG_SEVERITY_HIGH"; - case 0x9147: - return "GL_DEBUG_SEVERITY_MEDIUM"; - case 0x9148: - return "GL_DEBUG_SEVERITY_LOW"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DebugSource: - { - switch (value) - { - case 0x1100: - return "GL_DONT_CARE"; - case 0x8246: - return "GL_DEBUG_SOURCE_API"; - case 0x8247: - return "GL_DEBUG_SOURCE_WINDOW_SYSTEM"; - case 0x8248: - return "GL_DEBUG_SOURCE_SHADER_COMPILER"; - case 0x8249: - return "GL_DEBUG_SOURCE_THIRD_PARTY"; - case 0x824A: - return "GL_DEBUG_SOURCE_APPLICATION"; - case 0x824B: - return "GL_DEBUG_SOURCE_OTHER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DebugType: - { - switch (value) - { - case 0x1100: - return "GL_DONT_CARE"; - case 0x824C: - return "GL_DEBUG_TYPE_ERROR"; - case 0x824D: - return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"; - case 0x824E: - return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"; - case 0x824F: - return "GL_DEBUG_TYPE_PORTABILITY"; - case 0x8250: - return "GL_DEBUG_TYPE_PERFORMANCE"; - case 0x8251: - return "GL_DEBUG_TYPE_OTHER"; - case 0x8268: - return "GL_DEBUG_TYPE_MARKER"; - case 0x8269: - return "GL_DEBUG_TYPE_PUSH_GROUP"; - case 0x826A: - return "GL_DEBUG_TYPE_POP_GROUP"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DefaultGroup: - { - switch (value) - { - case 0x1: - return "GL_CREATE_SPARSE_BINDING_BIT_ANGLE"; - case 0x2: - return "GL_CREATE_SPARSE_RESIDENCY_BIT_ANGLE"; - case 0x4: - return "GL_CREATE_SPARSE_ALIASED_BIT_ANGLE"; - case 0x8: - return "GL_CREATE_MUTABLE_FORMAT_BIT_ANGLE"; - case 0xA: - return "GL_LINES_ADJACENCY_OES"; - case 0xB: - return "GL_LINE_STRIP_ADJACENCY_OES"; - case 0xC: - return "GL_TRIANGLES_ADJACENCY_OES"; - case 0xD: - return "GL_TRIANGLE_STRIP_ADJACENCY_OES"; - case 0x10: - return "GL_CREATE_CUBE_COMPATIBLE_BIT_ANGLE"; - case 0x16: - return "GL_UUID_SIZE_EXT"; - case 0x20: - return "GL_CREATE_2D_ARRAY_COMPATIBLE_BIT_ANGLE"; - case 0x40: - return "GL_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_ANGLE"; - case 0x80: - return "GL_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_ANGLE"; - case 0x100: - return "GL_CREATE_EXTENDED_USAGE_BIT_ANGLE"; - case 0x200: - return "GL_CREATE_DISJOINT_BIT_ANGLE"; - case 0x308: - return "GL_SRC_ALPHA_SATURATE_EXT"; - case 0x400: - return "GL_CREATE_ALIAS_BIT_ANGLE"; - case 0x503: - return "GL_STACK_OVERFLOW_KHR"; - case 0x504: - return "GL_STACK_UNDERFLOW_KHR"; - case 0x507: - return "GL_CONTEXT_LOST"; - case 0x800: - return "GL_CREATE_PROTECTED_BIT_ANGLE"; - case 0xD32: - return "GL_MAX_CLIP_DISTANCES_APPLE"; - case 0x1000: - return "GL_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_ANGLE"; - case 0x1004: - return "GL_TEXTURE_BORDER_COLOR_EXT"; + case 0x140B: + return "GL_HALF_FLOAT"; + case 0x140C: + return "GL_FIXED"; + case 0x1500: + return "GL_CLEAR"; + case 0x1501: + return "GL_AND"; + case 0x1502: + return "GL_AND_REVERSE"; + case 0x1503: + return "GL_COPY"; + case 0x1504: + return "GL_AND_INVERTED"; + case 0x1505: + return "GL_NOOP"; + case 0x1506: + return "GL_XOR"; + case 0x1507: + return "GL_OR"; + case 0x1508: + return "GL_NOR"; + case 0x1509: + return "GL_EQUIV"; + case 0x150A: + return "GL_INVERT"; + case 0x150B: + return "GL_OR_REVERSE"; + case 0x150C: + return "GL_COPY_INVERTED"; + case 0x150D: + return "GL_OR_INVERTED"; + case 0x150E: + return "GL_NAND"; + case 0x150F: + return "GL_SET"; + case 0x1600: + return "GL_EMISSION"; + case 0x1601: + return "GL_SHININESS"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + case 0x1700: + return "GL_MODELVIEW"; + case 0x1701: + return "GL_PROJECTION"; + case 0x1702: + return "GL_TEXTURE"; + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; case 0x1901: - return "GL_STENCIL_INDEX_OES"; + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + case 0x1D00: + return "GL_FLAT"; + case 0x1D01: + return "GL_SMOOTH"; + case 0x1E00: + return "GL_KEEP"; + case 0x1E01: + return "GL_REPLACE"; + case 0x1E02: + return "GL_INCR"; + case 0x1E03: + return "GL_DECR"; + case 0x1F00: + return "GL_VENDOR"; + case 0x1F01: + return "GL_RENDERER"; + case 0x1F02: + return "GL_VERSION"; + case 0x1F03: + return "GL_EXTENSIONS"; case 0x2000: return "GL_CREATE_CORNER_SAMPLED_BIT_ANGLE"; + case 0x2100: + return "GL_MODULATE"; + case 0x2101: + return "GL_DECAL"; + case 0x2200: + return "GL_TEXTURE_ENV_MODE"; + case 0x2201: + return "GL_TEXTURE_ENV_COLOR"; + case 0x2300: + return "GL_TEXTURE_ENV"; case 0x2500: return "GL_TEXTURE_GEN_MODE_OES"; + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + case 0x2700: + return "GL_NEAREST_MIPMAP_NEAREST"; + case 0x2701: + return "GL_LINEAR_MIPMAP_NEAREST"; + case 0x2702: + return "GL_NEAREST_MIPMAP_LINEAR"; + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x2901: + return "GL_REPEAT"; + case 0x2A00: + return "GL_POLYGON_OFFSET_UNITS"; case 0x3000: return "GL_CLIP_DISTANCE0_APPLE"; case 0x3001: @@ -772,33 +525,149 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x3007: return "GL_CLIP_DISTANCE7_APPLE"; case 0x4000: - return "GL_CREATE_SUBSAMPLED_BIT_ANGLE"; + return "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8001: + return "GL_CONSTANT_COLOR"; + case 0x8002: + return "GL_ONE_MINUS_CONSTANT_COLOR"; + case 0x8003: + return "GL_CONSTANT_ALPHA"; + case 0x8004: + return "GL_ONE_MINUS_CONSTANT_ALPHA"; case 0x8005: return "GL_BLEND_COLOR"; + case 0x8006: + return "GL_FUNC_ADD"; case 0x8007: return "GL_MIN"; case 0x8008: return "GL_MAX"; case 0x8009: return "GL_BLEND_EQUATION"; + case 0x800A: + return "GL_FUNC_SUBTRACT"; + case 0x800B: + return "GL_FUNC_REVERSE_SUBTRACT"; + case 0x8033: + return "GL_UNSIGNED_SHORT_4_4_4_4"; + case 0x8034: + return "GL_UNSIGNED_SHORT_5_5_5_1"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8038: + return "GL_POLYGON_OFFSET_FACTOR"; + case 0x803A: + return "GL_RESCALE_NORMAL"; case 0x803C: return "GL_ALPHA8_EXT"; case 0x8040: return "GL_LUMINANCE8_EXT"; case 0x8045: return "GL_LUMINANCE8_ALPHA8_EXT"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10_EXT"; + case 0x8054: + return "GL_RGB16_EXT"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805B: + return "GL_RGBA16_EXT"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8069: + return "GL_TEXTURE_BINDING_2D"; case 0x806A: - return "GL_TEXTURE_BINDING_3D_OES"; + return "GL_TEXTURE_BINDING_3D"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + case 0x806F: + return "GL_TEXTURE_3D"; case 0x8071: return "GL_TEXTURE_DEPTH"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; case 0x8073: return "GL_MAX_3D_TEXTURE_SIZE"; case 0x8074: - return "GL_VERTEX_ARRAY_KHR"; + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x807A: + return "GL_VERTEX_ARRAY_SIZE"; + case 0x807B: + return "GL_VERTEX_ARRAY_TYPE"; + case 0x807C: + return "GL_VERTEX_ARRAY_STRIDE"; + case 0x807E: + return "GL_NORMAL_ARRAY_TYPE"; + case 0x807F: + return "GL_NORMAL_ARRAY_STRIDE"; + case 0x8081: + return "GL_COLOR_ARRAY_SIZE"; + case 0x8082: + return "GL_COLOR_ARRAY_TYPE"; + case 0x8083: + return "GL_COLOR_ARRAY_STRIDE"; + case 0x8088: + return "GL_TEXTURE_COORD_ARRAY_SIZE"; + case 0x8089: + return "GL_TEXTURE_COORD_ARRAY_TYPE"; + case 0x808A: + return "GL_TEXTURE_COORD_ARRAY_STRIDE"; + case 0x808E: + return "GL_VERTEX_ARRAY_POINTER"; + case 0x808F: + return "GL_NORMAL_ARRAY_POINTER"; + case 0x8090: + return "GL_COLOR_ARRAY_POINTER"; + case 0x8092: + return "GL_TEXTURE_COORD_ARRAY_POINTER"; + case 0x809D: + return "GL_MULTISAMPLE"; case 0x809E: return "GL_SAMPLE_ALPHA_TO_COVERAGE"; + case 0x809F: + return "GL_SAMPLE_ALPHA_TO_ONE"; case 0x80A0: return "GL_SAMPLE_COVERAGE"; + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; case 0x80AA: return "GL_SAMPLE_COVERAGE_VALUE"; case 0x80AB: @@ -811,22 +680,62 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_BLEND_DST_ALPHA"; case 0x80CB: return "GL_BLEND_SRC_ALPHA"; + case 0x80E1: + return "GL_BGRA_EXT"; case 0x80E8: return "GL_MAX_ELEMENTS_VERTICES"; case 0x80E9: return "GL_MAX_ELEMENTS_INDICES"; + case 0x8126: + return "GL_POINT_SIZE_MIN"; + case 0x8127: + return "GL_POINT_SIZE_MAX"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x8129: + return "GL_POINT_DISTANCE_ATTENUATION"; case 0x812D: - return "GL_CLAMP_TO_BORDER_EXT"; + return "GL_CLAMP_TO_BORDER"; + case 0x812F: + return "GL_CLAMP_TO_EDGE"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + case 0x813C: + return "GL_TEXTURE_BASE_LEVEL"; + case 0x813D: + return "GL_TEXTURE_MAX_LEVEL"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x8192: + return "GL_GENERATE_MIPMAP_HINT"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; case 0x81A6: return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32_OES"; case 0x8210: - return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT"; + return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; case 0x8211: - return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT"; + return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; + case 0x8212: + return "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"; + case 0x8213: + return "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; + case 0x8214: + return "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; + case 0x8215: + return "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; + case 0x8216: + return "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; + case 0x8217: + return "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; case 0x8218: return "GL_FRAMEBUFFER_DEFAULT"; case 0x8219: - return "GL_FRAMEBUFFER_UNDEFINED_OES"; + return "GL_FRAMEBUFFER_UNDEFINED"; case 0x821A: return "GL_DEPTH_STENCIL_ATTACHMENT"; case 0x821B: @@ -844,53 +753,97 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8221: return "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED"; case 0x8227: - return "GL_RG_EXT"; + return "GL_RG"; case 0x8228: return "GL_RG_INTEGER"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16_EXT"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16_EXT"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; case 0x8242: return "GL_DEBUG_OUTPUT_SYNCHRONOUS"; case 0x8243: return "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH"; case 0x8244: - return "GL_DEBUG_CALLBACK_FUNCTION_KHR"; + return "GL_DEBUG_CALLBACK_FUNCTION"; case 0x8245: - return "GL_DEBUG_CALLBACK_USER_PARAM_KHR"; + return "GL_DEBUG_CALLBACK_USER_PARAM"; case 0x8246: - return "GL_DEBUG_SOURCE_API_KHR"; + return "GL_DEBUG_SOURCE_API"; case 0x8247: - return "GL_DEBUG_SOURCE_WINDOW_SYSTEM_KHR"; + return "GL_DEBUG_SOURCE_WINDOW_SYSTEM"; case 0x8248: - return "GL_DEBUG_SOURCE_SHADER_COMPILER_KHR"; + return "GL_DEBUG_SOURCE_SHADER_COMPILER"; case 0x8249: - return "GL_DEBUG_SOURCE_THIRD_PARTY_KHR"; + return "GL_DEBUG_SOURCE_THIRD_PARTY"; case 0x824A: - return "GL_DEBUG_SOURCE_APPLICATION_KHR"; + return "GL_DEBUG_SOURCE_APPLICATION"; case 0x824B: - return "GL_DEBUG_SOURCE_OTHER_KHR"; + return "GL_DEBUG_SOURCE_OTHER"; case 0x824C: - return "GL_DEBUG_TYPE_ERROR_KHR"; + return "GL_DEBUG_TYPE_ERROR"; case 0x824D: - return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR"; + return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"; case 0x824E: - return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR"; + return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"; case 0x824F: - return "GL_DEBUG_TYPE_PORTABILITY_KHR"; + return "GL_DEBUG_TYPE_PORTABILITY"; case 0x8250: - return "GL_DEBUG_TYPE_PERFORMANCE_KHR"; + return "GL_DEBUG_TYPE_PERFORMANCE"; case 0x8251: - return "GL_DEBUG_TYPE_OTHER_KHR"; + return "GL_DEBUG_TYPE_OTHER"; case 0x8252: return "GL_LOSE_CONTEXT_ON_RESET"; case 0x8253: - return "GL_GUILTY_CONTEXT_RESET_EXT"; + return "GL_GUILTY_CONTEXT_RESET"; case 0x8254: - return "GL_INNOCENT_CONTEXT_RESET_EXT"; + return "GL_INNOCENT_CONTEXT_RESET"; case 0x8255: - return "GL_UNKNOWN_CONTEXT_RESET_EXT"; + return "GL_UNKNOWN_CONTEXT_RESET"; case 0x8256: return "GL_RESET_NOTIFICATION_STRATEGY"; + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; case 0x8258: - return "GL_PROGRAM_SEPARABLE_EXT"; + return "GL_PROGRAM_SEPARABLE"; + case 0x8259: + return "GL_ACTIVE_PROGRAM"; case 0x825A: return "GL_PROGRAM_PIPELINE_BINDING"; case 0x825E: @@ -909,12 +862,14 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_COMPUTE_ATOMIC_COUNTERS"; case 0x8266: return "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS"; + case 0x8267: + return "GL_COMPUTE_WORK_GROUP_SIZE"; case 0x8268: - return "GL_DEBUG_TYPE_MARKER_KHR"; + return "GL_DEBUG_TYPE_MARKER"; case 0x8269: - return "GL_DEBUG_TYPE_PUSH_GROUP_KHR"; + return "GL_DEBUG_TYPE_PUSH_GROUP"; case 0x826A: - return "GL_DEBUG_TYPE_POP_GROUP_KHR"; + return "GL_DEBUG_TYPE_POP_GROUP"; case 0x826B: return "GL_DEBUG_SEVERITY_NOTIFICATION"; case 0x826C: @@ -925,6 +880,8 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_UNIFORM_LOCATIONS"; case 0x82D4: return "GL_VERTEX_ATTRIB_BINDING"; + case 0x82D5: + return "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"; case 0x82D6: return "GL_VERTEX_BINDING_DIVISOR"; case 0x82D7: @@ -938,21 +895,19 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x82DF: return "GL_TEXTURE_IMMUTABLE_LEVELS"; case 0x82E0: - return "GL_BUFFER_KHR"; + return "GL_BUFFER"; case 0x82E1: - return "GL_SHADER_KHR"; + return "GL_SHADER"; case 0x82E2: - return "GL_PROGRAM_KHR"; + return "GL_PROGRAM"; case 0x82E3: - return "GL_QUERY_KHR"; + return "GL_QUERY"; case 0x82E4: - return "GL_PROGRAM_PIPELINE_KHR"; + return "GL_PROGRAM_PIPELINE"; case 0x82E5: return "GL_MAX_VERTEX_ATTRIB_STRIDE"; case 0x82E6: - return "GL_SAMPLER_KHR"; - case 0x82E7: - return "GL_DISPLAY_LIST"; + return "GL_SAMPLER"; case 0x82E8: return "GL_MAX_LABEL_LENGTH"; case 0x82F9: @@ -961,10 +916,98 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES_EXT"; case 0x8363: return "GL_UNSIGNED_SHORT_5_6_5"; + case 0x8365: + return "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT"; + case 0x8366: + return "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; case 0x8370: return "GL_MIRRORED_REPEAT"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE"; + case 0x846D: + return "GL_ALIASED_POINT_SIZE_RANGE"; + case 0x846E: + return "GL_ALIASED_LINE_WIDTH_RANGE"; + case 0x84C0: + return "GL_TEXTURE0"; + case 0x84C1: + return "GL_TEXTURE1"; + case 0x84C2: + return "GL_TEXTURE2"; + case 0x84C3: + return "GL_TEXTURE3"; + case 0x84C4: + return "GL_TEXTURE4"; + case 0x84C5: + return "GL_TEXTURE5"; + case 0x84C6: + return "GL_TEXTURE6"; + case 0x84C7: + return "GL_TEXTURE7"; + case 0x84C8: + return "GL_TEXTURE8"; + case 0x84C9: + return "GL_TEXTURE9"; + case 0x84CA: + return "GL_TEXTURE10"; + case 0x84CB: + return "GL_TEXTURE11"; + case 0x84CC: + return "GL_TEXTURE12"; + case 0x84CD: + return "GL_TEXTURE13"; + case 0x84CE: + return "GL_TEXTURE14"; + case 0x84CF: + return "GL_TEXTURE15"; + case 0x84D0: + return "GL_TEXTURE16"; + case 0x84D1: + return "GL_TEXTURE17"; + case 0x84D2: + return "GL_TEXTURE18"; + case 0x84D3: + return "GL_TEXTURE19"; + case 0x84D4: + return "GL_TEXTURE20"; + case 0x84D5: + return "GL_TEXTURE21"; + case 0x84D6: + return "GL_TEXTURE22"; + case 0x84D7: + return "GL_TEXTURE23"; + case 0x84D8: + return "GL_TEXTURE24"; + case 0x84D9: + return "GL_TEXTURE25"; + case 0x84DA: + return "GL_TEXTURE26"; + case 0x84DB: + return "GL_TEXTURE27"; + case 0x84DC: + return "GL_TEXTURE28"; + case 0x84DD: + return "GL_TEXTURE29"; + case 0x84DE: + return "GL_TEXTURE30"; + case 0x84DF: + return "GL_TEXTURE31"; case 0x84E0: return "GL_ACTIVE_TEXTURE"; + case 0x84E1: + return "GL_CLIENT_ACTIVE_TEXTURE"; + case 0x84E2: + return "GL_MAX_TEXTURE_UNITS"; + case 0x84E7: + return "GL_SUBTRACT"; case 0x84E8: return "GL_MAX_RENDERBUFFER_SIZE"; case 0x84F2: @@ -973,6 +1016,8 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_FENCE_STATUS_NV"; case 0x84F4: return "GL_FENCE_CONDITION_NV"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; case 0x84FA: return "GL_UNSIGNED_INT_24_8"; case 0x84FD: @@ -990,29 +1035,81 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8512: return "GL_REFLECTION_MAP_OES"; case 0x8513: - return "GL_TEXTURE_CUBE_MAP_OES"; + return "GL_TEXTURE_CUBE_MAP"; case 0x8514: return "GL_TEXTURE_BINDING_CUBE_MAP"; case 0x8515: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_X_OES"; + return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; case 0x8516: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X_OES"; + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; case 0x8517: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y_OES"; + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; case 0x8518: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES"; + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; case 0x8519: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z_OES"; + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; case 0x851A: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES"; + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; case 0x851C: return "GL_MAX_CUBE_MAP_TEXTURE_SIZE"; + case 0x8570: + return "GL_COMBINE"; + case 0x8571: + return "GL_COMBINE_RGB"; + case 0x8572: + return "GL_COMBINE_ALPHA"; + case 0x8573: + return "GL_RGB_SCALE"; + case 0x8574: + return "GL_ADD_SIGNED"; + case 0x8575: + return "GL_INTERPOLATE"; + case 0x8576: + return "GL_CONSTANT"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + case 0x8578: + return "GL_PREVIOUS"; + case 0x8580: + return "GL_SRC0_RGB"; + case 0x8581: + return "GL_SRC1_RGB"; + case 0x8582: + return "GL_SRC2_RGB"; + case 0x8588: + return "GL_SRC0_ALPHA"; case 0x8589: - return "GL_SRC1_ALPHA_EXT"; + return "GL_SRC1_ALPHA"; + case 0x858A: + return "GL_SRC2_ALPHA"; + case 0x8590: + return "GL_OPERAND0_RGB"; + case 0x8591: + return "GL_OPERAND1_RGB"; + case 0x8592: + return "GL_OPERAND2_RGB"; + case 0x8598: + return "GL_OPERAND0_ALPHA"; + case 0x8599: + return "GL_OPERAND1_ALPHA"; + case 0x859A: + return "GL_OPERAND2_ALPHA"; case 0x85B5: return "GL_VERTEX_ARRAY_BINDING"; + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x8626: + return "GL_CURRENT_VERTEX_ATTRIB"; case 0x8645: return "GL_VERTEX_ATTRIB_ARRAY_POINTER"; + case 0x86A1: + return "GL_TEXTURE_COMPRESSED"; case 0x86A2: return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; case 0x86A3: @@ -1029,8 +1126,16 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_WEIGHT_ARRAY_POINTER_OES"; case 0x86AD: return "GL_WEIGHT_ARRAY_OES"; + case 0x86AE: + return "GL_DOT3_RGB"; + case 0x86AF: + return "GL_DOT3_RGBA"; case 0x8741: - return "GL_PROGRAM_BINARY_LENGTH_OES"; + return "GL_PROGRAM_BINARY_LENGTH"; + case 0x8764: + return "GL_BUFFER_SIZE"; + case 0x8765: + return "GL_BUFFER_USAGE"; case 0x87FE: return "GL_NUM_PROGRAM_BINARY_FORMATS"; case 0x87FF: @@ -1043,6 +1148,8 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_STENCIL_BACK_PASS_DEPTH_FAIL"; case 0x8803: return "GL_STENCIL_BACK_PASS_DEPTH_PASS"; + case 0x8814: + return "GL_RGBA32F"; case 0x8815: return "GL_RGB32F"; case 0x8816: @@ -1051,6 +1158,10 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_LUMINANCE32F_EXT"; case 0x8819: return "GL_LUMINANCE_ALPHA32F_EXT"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; case 0x881C: return "GL_ALPHA16F_EXT"; case 0x881E: @@ -1112,9 +1223,9 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x884A: return "GL_TEXTURE_DEPTH_SIZE"; case 0x884C: - return "GL_TEXTURE_COMPARE_MODE_EXT"; + return "GL_TEXTURE_COMPARE_MODE"; case 0x884D: - return "GL_TEXTURE_COMPARE_FUNC_EXT"; + return "GL_TEXTURE_COMPARE_FUNC"; case 0x884E: return "GL_COMPARE_REF_TO_TEXTURE"; case 0x8861: @@ -1124,13 +1235,15 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8864: return "GL_QUERY_COUNTER_BITS_EXT"; case 0x8865: - return "GL_CURRENT_QUERY_EXT"; + return "GL_CURRENT_QUERY"; case 0x8866: - return "GL_QUERY_RESULT_EXT"; + return "GL_QUERY_RESULT"; case 0x8867: - return "GL_QUERY_RESULT_AVAILABLE_EXT"; + return "GL_QUERY_RESULT_AVAILABLE"; case 0x8869: return "GL_MAX_VERTEX_ATTRIBS"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; case 0x886C: return "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS"; case 0x886D: @@ -1139,30 +1252,68 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_TEXTURE_IMAGE_UNITS"; case 0x887F: return "GL_GEOMETRY_SHADER_INVOCATIONS"; + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; case 0x8894: return "GL_ARRAY_BUFFER_BINDING"; case 0x8895: return "GL_ELEMENT_ARRAY_BUFFER_BINDING"; + case 0x8896: + return "GL_VERTEX_ARRAY_BUFFER_BINDING"; + case 0x8897: + return "GL_NORMAL_ARRAY_BUFFER_BINDING"; + case 0x8898: + return "GL_COLOR_ARRAY_BUFFER_BINDING"; + case 0x889A: + return "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING"; case 0x889E: return "GL_WEIGHT_ARRAY_BUFFER_BINDING_OES"; + case 0x889F: + return "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + case 0x88B8: + return "GL_READ_ONLY"; case 0x88B9: - return "GL_WRITE_ONLY_OES"; + return "GL_WRITE_ONLY"; + case 0x88BA: + return "GL_READ_WRITE"; case 0x88BB: return "GL_BUFFER_ACCESS_OES"; case 0x88BC: - return "GL_BUFFER_MAPPED_OES"; + return "GL_BUFFER_MAPPED"; case 0x88BD: return "GL_BUFFER_MAP_POINTER"; case 0x88BF: return "GL_TIME_ELAPSED_EXT"; + case 0x88E0: + return "GL_STREAM_DRAW"; + case 0x88E1: + return "GL_STREAM_READ"; + case 0x88E2: + return "GL_STREAM_COPY"; + case 0x88E4: + return "GL_STATIC_DRAW"; + case 0x88E5: + return "GL_STATIC_READ"; + case 0x88E6: + return "GL_STATIC_COPY"; + case 0x88E8: + return "GL_DYNAMIC_DRAW"; + case 0x88E9: + return "GL_DYNAMIC_READ"; + case 0x88EA: + return "GL_DYNAMIC_COPY"; case 0x88EB: - return "GL_PIXEL_PACK_BUFFER_NV"; + return "GL_PIXEL_PACK_BUFFER"; case 0x88EC: - return "GL_PIXEL_UNPACK_BUFFER_NV"; + return "GL_PIXEL_UNPACK_BUFFER"; case 0x88ED: return "GL_PIXEL_PACK_BUFFER_BINDING"; case 0x88EF: return "GL_PIXEL_UNPACK_BUFFER_BINDING"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; case 0x88F1: return "GL_TEXTURE_STENCIL_SIZE"; case 0x88F9: @@ -1173,8 +1324,10 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_ONE_MINUS_SRC1_ALPHA_EXT"; case 0x88FC: return "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; case 0x88FE: - return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE"; + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; case 0x88FF: return "GL_MAX_ARRAY_TEXTURE_LAYERS"; case 0x8904: @@ -1184,7 +1337,7 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8916: return "GL_GEOMETRY_LINKED_VERTICES_OUT_EXT"; case 0x8917: - return "GL_GEOMETRY_LINKED_INPUT_TYPE_EXT"; + return "GL_GEOMETRY_INPUT_TYPE"; case 0x8918: return "GL_GEOMETRY_LINKED_OUTPUT_TYPE_EXT"; case 0x8919: @@ -1195,6 +1348,8 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_POINT_SIZE_ARRAY_STRIDE_OES"; case 0x898C: return "GL_POINT_SIZE_ARRAY_POINTER_OES"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; case 0x8A28: return "GL_UNIFORM_BUFFER_BINDING"; case 0x8A29: @@ -1221,6 +1376,40 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; case 0x8A34: return "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT"; + case 0x8A35: + return "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"; + case 0x8A36: + return "GL_ACTIVE_UNIFORM_BLOCKS"; + case 0x8A37: + return "GL_UNIFORM_TYPE"; + case 0x8A38: + return "GL_UNIFORM_SIZE"; + case 0x8A39: + return "GL_UNIFORM_NAME_LENGTH"; + case 0x8A3A: + return "GL_UNIFORM_BLOCK_INDEX"; + case 0x8A3B: + return "GL_UNIFORM_OFFSET"; + case 0x8A3C: + return "GL_UNIFORM_ARRAY_STRIDE"; + case 0x8A3D: + return "GL_UNIFORM_MATRIX_STRIDE"; + case 0x8A3E: + return "GL_UNIFORM_IS_ROW_MAJOR"; + case 0x8A3F: + return "GL_UNIFORM_BLOCK_BINDING"; + case 0x8A40: + return "GL_UNIFORM_BLOCK_DATA_SIZE"; + case 0x8A41: + return "GL_UNIFORM_BLOCK_NAME_LENGTH"; + case 0x8A42: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS"; + case 0x8A43: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"; + case 0x8A44: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"; + case 0x8A46: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; case 0x8A48: return "GL_TEXTURE_SRGB_DECODE_EXT"; case 0x8A49: @@ -1231,6 +1420,18 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_PROGRAM_PIPELINE_OBJECT_EXT"; case 0x8A52: return "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT"; + case 0x8A54: + return "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT"; + case 0x8A55: + return "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT"; + case 0x8A56: + return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT"; + case 0x8A57: + return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT"; + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; case 0x8B40: return "GL_PROGRAM_OBJECT_EXT"; case 0x8B48: @@ -1245,8 +1446,86 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"; case 0x8B4D: return "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"; + case 0x8B4F: + return "GL_SHADER_TYPE"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B81: + return "GL_COMPILE_STATUS"; + case 0x8B82: + return "GL_LINK_STATUS"; + case 0x8B83: + return "GL_VALIDATE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B85: + return "GL_ATTACHED_SHADERS"; + case 0x8B86: + return "GL_ACTIVE_UNIFORMS"; + case 0x8B87: + return "GL_ACTIVE_UNIFORM_MAX_LENGTH"; + case 0x8B88: + return "GL_SHADER_SOURCE_LENGTH"; + case 0x8B89: + return "GL_ACTIVE_ATTRIBUTES"; + case 0x8B8A: + return "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + case 0x8B8C: + return "GL_SHADING_LANGUAGE_VERSION"; case 0x8B8D: return "GL_ACTIVE_PROGRAM_EXT"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; case 0x8B9C: return "GL_POINT_SIZE_ARRAY_OES"; case 0x8B9D: @@ -1275,6 +1554,14 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT"; case 0x8BFA: return "GL_TEXTURE_PROTECTED_EXT"; + case 0x8C00: + return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; + case 0x8C01: + return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; + case 0x8C02: + return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; + case 0x8C03: + return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; case 0x8C10: return "GL_TEXTURE_RED_TYPE"; case 0x8C11: @@ -1287,12 +1574,14 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_TEXTURE_DEPTH_TYPE"; case 0x8C17: return "GL_UNSIGNED_NORMALIZED"; + case 0x8C1A: + return "GL_TEXTURE_2D_ARRAY"; case 0x8C1D: return "GL_TEXTURE_BINDING_2D_ARRAY"; case 0x8C29: return "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS"; case 0x8C2A: - return "GL_TEXTURE_BUFFER_BINDING"; + return "GL_TEXTURE_BUFFER"; case 0x8C2B: return "GL_MAX_TEXTURE_BUFFER_SIZE"; case 0x8C2C: @@ -1300,19 +1589,53 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8C2D: return "GL_TEXTURE_BUFFER_DATA_STORE_BINDING"; case 0x8C2F: - return "GL_ANY_SAMPLES_PASSED_EXT"; + return "GL_ANY_SAMPLES_PASSED"; case 0x8C36: return "GL_SAMPLE_SHADING"; case 0x8C37: return "GL_MIN_SAMPLE_SHADING_VALUE"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3B: + return "GL_UNSIGNED_INT_10F_11F_11F_REV"; + case 0x8C3D: + return "GL_RGB9_E5"; case 0x8C3E: return "GL_UNSIGNED_INT_5_9_9_9_REV"; case 0x8C3F: return "GL_TEXTURE_SHARED_SIZE"; + case 0x8C40: + return "GL_SRGB"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C42: + return "GL_SRGB_ALPHA_EXT"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8C4C: + return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT"; + case 0x8C4D: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; + case 0x8C4E: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; + case 0x8C4F: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; + case 0x8C76: + return "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"; + case 0x8C7F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"; case 0x8C80: return "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"; + case 0x8C83: + return "GL_TRANSFORM_FEEDBACK_VARYINGS"; + case 0x8C84: + return "GL_TRANSFORM_FEEDBACK_BUFFER_START"; + case 0x8C85: + return "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"; case 0x8C87: - return "GL_PRIMITIVES_GENERATED_EXT"; + return "GL_PRIMITIVES_GENERATED"; + case 0x8C88: + return "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; case 0x8C89: return "GL_RASTERIZER_DISCARD"; case 0x8C8A: @@ -1323,6 +1646,10 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_INTERLEAVED_ATTRIBS"; case 0x8C8D: return "GL_SEPARATE_ATTRIBS"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8C8F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"; case 0x8CA1: return "GL_LOWER_LEFT_EXT"; case 0x8CA2: @@ -1338,822 +1665,39 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8CA7: return "GL_RENDERBUFFER_BINDING"; case 0x8CA8: - return "GL_READ_FRAMEBUFFER_ANGLE"; + return "GL_READ_FRAMEBUFFER"; case 0x8CA9: - return "GL_DRAW_FRAMEBUFFER_ANGLE"; + return "GL_DRAW_FRAMEBUFFER"; case 0x8CAA: return "GL_READ_FRAMEBUFFER_BINDING"; case 0x8CAB: - return "GL_RENDERBUFFER_SAMPLES_ANGLE"; + return "GL_RENDERBUFFER_SAMPLES"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; case 0x8CD0: return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; case 0x8CD1: - return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES"; + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; case 0x8CD2: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES"; + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; case 0x8CD3: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES"; + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; case 0x8CD4: return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES"; case 0x8CD5: - return "GL_FRAMEBUFFER_COMPLETE_OES"; + return "GL_FRAMEBUFFER_COMPLETE"; case 0x8CD6: - return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES"; + return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; case 0x8CD7: - return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES"; + return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; case 0x8CD9: return "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS"; case 0x8CDA: return "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_OES"; case 0x8CDD: - return "GL_FRAMEBUFFER_UNSUPPORTED_OES"; - case 0x8D20: - return "GL_STENCIL_ATTACHMENT"; - case 0x8D40: - return "GL_FRAMEBUFFER_OES"; - case 0x8D41: - return "GL_RENDERBUFFER_OES"; - case 0x8D42: - return "GL_RENDERBUFFER_WIDTH_OES"; - case 0x8D43: - return "GL_RENDERBUFFER_HEIGHT_OES"; - case 0x8D44: - return "GL_RENDERBUFFER_INTERNAL_FORMAT_OES"; - case 0x8D48: - return "GL_STENCIL_INDEX8"; - case 0x8D50: - return "GL_RENDERBUFFER_RED_SIZE_OES"; - case 0x8D51: - return "GL_RENDERBUFFER_GREEN_SIZE_OES"; - case 0x8D52: - return "GL_RENDERBUFFER_BLUE_SIZE_OES"; - case 0x8D53: - return "GL_RENDERBUFFER_ALPHA_SIZE_OES"; - case 0x8D54: - return "GL_RENDERBUFFER_DEPTH_SIZE_OES"; - case 0x8D55: - return "GL_RENDERBUFFER_STENCIL_SIZE_OES"; - case 0x8D56: - return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE"; - case 0x8D57: - return "GL_MAX_SAMPLES"; - case 0x8D60: - return "GL_TEXTURE_GEN_STR_OES"; - case 0x8D62: - return "GL_RGB565"; - case 0x8D65: - return "GL_TEXTURE_EXTERNAL_OES"; - case 0x8D66: - return "GL_SAMPLER_EXTERNAL_OES"; - case 0x8D67: - return "GL_TEXTURE_BINDING_EXTERNAL_OES"; - case 0x8D68: - return "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES"; - case 0x8D69: - return "GL_PRIMITIVE_RESTART_FIXED_INDEX"; - case 0x8D6A: - return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT"; - case 0x8D6B: - return "GL_MAX_ELEMENT_INDEX"; - case 0x8D6C: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT"; - case 0x8D94: - return "GL_RED_INTEGER"; - case 0x8D98: - return "GL_RGB_INTEGER"; - case 0x8D99: - return "GL_RGBA_INTEGER"; - case 0x8DA7: - return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT"; - case 0x8DA8: - return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT"; - case 0x8DAD: - return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV"; - case 0x8DC1: - return "GL_SAMPLER_2D_ARRAY"; - case 0x8DC2: - return "GL_SAMPLER_BUFFER"; - case 0x8DC4: - return "GL_SAMPLER_2D_ARRAY_SHADOW"; - case 0x8DC5: - return "GL_SAMPLER_CUBE_SHADOW"; - case 0x8DC6: - return "GL_UNSIGNED_INT_VEC2"; - case 0x8DC7: - return "GL_UNSIGNED_INT_VEC3"; - case 0x8DC8: - return "GL_UNSIGNED_INT_VEC4"; - case 0x8DCA: - return "GL_INT_SAMPLER_2D"; - case 0x8DCB: - return "GL_INT_SAMPLER_3D"; - case 0x8DCC: - return "GL_INT_SAMPLER_CUBE"; - case 0x8DCF: - return "GL_INT_SAMPLER_2D_ARRAY"; - case 0x8DD0: - return "GL_INT_SAMPLER_BUFFER"; - case 0x8DD2: - return "GL_UNSIGNED_INT_SAMPLER_2D"; - case 0x8DD3: - return "GL_UNSIGNED_INT_SAMPLER_3D"; - case 0x8DD4: - return "GL_UNSIGNED_INT_SAMPLER_CUBE"; - case 0x8DD7: - return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; - case 0x8DD8: - return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; - case 0x8DD9: - return "GL_GEOMETRY_SHADER_EXT"; - case 0x8DDF: - return "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"; - case 0x8DE0: - return "GL_MAX_GEOMETRY_OUTPUT_VERTICES"; - case 0x8DE1: - return "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS"; - case 0x8DF6: - return "GL_UNSIGNED_INT_10_10_10_2_OES"; - case 0x8DF7: - return "GL_INT_10_10_10_2_OES"; - case 0x8DF8: - return "GL_SHADER_BINARY_FORMATS"; - case 0x8DF9: - return "GL_NUM_SHADER_BINARY_FORMATS"; - case 0x8DFA: - return "GL_SHADER_COMPILER"; - case 0x8DFB: - return "GL_MAX_VERTEX_UNIFORM_VECTORS"; - case 0x8DFC: - return "GL_MAX_VARYING_VECTORS"; - case 0x8DFD: - return "GL_MAX_FRAGMENT_UNIFORM_VECTORS"; - case 0x8E1E: - return "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS"; - case 0x8E1F: - return "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS"; - case 0x8E25: - return "GL_TRANSFORM_FEEDBACK_BINDING"; - case 0x8E28: - return "GL_TIMESTAMP_EXT"; - case 0x8E4D: - return "GL_FIRST_VERTEX_CONVENTION_EXT"; - case 0x8E4E: - return "GL_LAST_VERTEX_CONVENTION_EXT"; - case 0x8E4F: - return "GL_PROVOKING_VERTEX"; - case 0x8E50: - return "GL_SAMPLE_POSITION"; - case 0x8E51: - return "GL_SAMPLE_MASK"; - case 0x8E52: - return "GL_SAMPLE_MASK_VALUE"; - case 0x8E59: - return "GL_MAX_SAMPLE_MASK_WORDS"; - case 0x8E5A: - return "GL_MAX_GEOMETRY_SHADER_INVOCATIONS"; - case 0x8E5B: - return "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET"; - case 0x8E5C: - return "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET"; - case 0x8E5D: - return "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS"; - case 0x8E5E: - return "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET"; - case 0x8E5F: - return "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET"; - case 0x8E72: - return "GL_PATCH_VERTICES_EXT"; - case 0x8E75: - return "GL_TESS_CONTROL_OUTPUT_VERTICES"; - case 0x8E76: - return "GL_TESS_GEN_MODE"; - case 0x8E77: - return "GL_TESS_GEN_SPACING"; - case 0x8E78: - return "GL_TESS_GEN_VERTEX_ORDER"; - case 0x8E79: - return "GL_TESS_GEN_POINT_MODE"; - case 0x8E7A: - return "GL_ISOLINES"; - case 0x8E7B: - return "GL_FRACTIONAL_ODD"; - case 0x8E7C: - return "GL_FRACTIONAL_EVEN"; - case 0x8E7D: - return "GL_MAX_PATCH_VERTICES"; - case 0x8E7E: - return "GL_MAX_TESS_GEN_LEVEL"; - case 0x8E7F: - return "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS"; - case 0x8E80: - return "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS"; - case 0x8E81: - return "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS"; - case 0x8E82: - return "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS"; - case 0x8E83: - return "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS"; - case 0x8E84: - return "GL_MAX_TESS_PATCH_COMPONENTS"; - case 0x8E85: - return "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS"; - case 0x8E86: - return "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS"; - case 0x8E87: - return "GL_TESS_EVALUATION_SHADER_EXT"; - case 0x8E88: - return "GL_TESS_CONTROL_SHADER_EXT"; - case 0x8E89: - return "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"; - case 0x8E8A: - return "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"; - case 0x8F36: - return "GL_COPY_READ_BUFFER_BINDING"; - case 0x8F37: - return "GL_COPY_WRITE_BUFFER_BINDING"; - case 0x8F38: - return "GL_MAX_IMAGE_UNITS"; - case 0x8F39: - return "GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES"; - case 0x8F3A: - return "GL_IMAGE_BINDING_NAME"; - case 0x8F3B: - return "GL_IMAGE_BINDING_LEVEL"; - case 0x8F3C: - return "GL_IMAGE_BINDING_LAYERED"; - case 0x8F3D: - return "GL_IMAGE_BINDING_LAYER"; - case 0x8F3E: - return "GL_IMAGE_BINDING_ACCESS"; - case 0x8F43: - return "GL_DRAW_INDIRECT_BUFFER_BINDING"; - case 0x8F4F: - return "GL_VERTEX_BINDING_BUFFER"; - case 0x8F9C: - return "GL_SIGNED_NORMALIZED"; - case 0x8FBB: - return "GL_GPU_DISJOINT_EXT"; - case 0x8FBD: - return "GL_SR8_EXT"; - case 0x8FBE: - return "GL_SRG8_EXT"; - case 0x8FBF: - return "GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT"; - case 0x900A: - return "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY"; - case 0x900C: - return "GL_SAMPLER_CUBE_MAP_ARRAY"; - case 0x900D: - return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; - case 0x900E: - return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; - case 0x900F: - return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; - case 0x904D: - return "GL_IMAGE_2D"; - case 0x904E: - return "GL_IMAGE_3D"; - case 0x9050: - return "GL_IMAGE_CUBE"; - case 0x9051: - return "GL_IMAGE_BUFFER"; - case 0x9053: - return "GL_IMAGE_2D_ARRAY"; - case 0x9054: - return "GL_IMAGE_CUBE_MAP_ARRAY"; - case 0x9058: - return "GL_INT_IMAGE_2D"; - case 0x9059: - return "GL_INT_IMAGE_3D"; - case 0x905B: - return "GL_INT_IMAGE_CUBE"; - case 0x905C: - return "GL_INT_IMAGE_BUFFER"; - case 0x905E: - return "GL_INT_IMAGE_2D_ARRAY"; - case 0x905F: - return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; - case 0x9063: - return "GL_UNSIGNED_INT_IMAGE_2D"; - case 0x9064: - return "GL_UNSIGNED_INT_IMAGE_3D"; - case 0x9066: - return "GL_UNSIGNED_INT_IMAGE_CUBE"; - case 0x9067: - return "GL_UNSIGNED_INT_IMAGE_BUFFER"; - case 0x9069: - return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; - case 0x906A: - return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; - case 0x906E: - return "GL_IMAGE_BINDING_FORMAT"; - case 0x90C8: - return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE"; - case 0x90C9: - return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS"; - case 0x90CA: - return "GL_MAX_VERTEX_IMAGE_UNIFORMS"; - case 0x90CB: - return "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS"; - case 0x90CC: - return "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS"; - case 0x90CD: - return "GL_MAX_GEOMETRY_IMAGE_UNIFORMS"; - case 0x90CE: - return "GL_MAX_FRAGMENT_IMAGE_UNIFORMS"; - case 0x90CF: - return "GL_MAX_COMBINED_IMAGE_UNIFORMS"; - case 0x90D3: - return "GL_SHADER_STORAGE_BUFFER_BINDING"; - case 0x90D4: - return "GL_SHADER_STORAGE_BUFFER_START"; - case 0x90D5: - return "GL_SHADER_STORAGE_BUFFER_SIZE"; - case 0x90D6: - return "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"; - case 0x90D7: - return "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"; - case 0x90D8: - return "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"; - case 0x90D9: - return "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"; - case 0x90DA: - return "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; - case 0x90DB: - return "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"; - case 0x90DC: - return "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"; - case 0x90DD: - return "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"; - case 0x90DE: - return "GL_MAX_SHADER_STORAGE_BLOCK_SIZE"; - case 0x90DF: - return "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"; - case 0x90EB: - return "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"; - case 0x90EF: - return "GL_DISPATCH_INDIRECT_BUFFER_BINDING"; - case 0x90F3: - return "GL_CONTEXT_ROBUST_ACCESS_EXT"; - case 0x9102: - return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY_OES"; - case 0x9104: - return "GL_TEXTURE_BINDING_2D_MULTISAMPLE"; - case 0x9105: - return "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"; - case 0x9106: - return "GL_TEXTURE_SAMPLES"; - case 0x9107: - return "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS"; - case 0x9108: - return "GL_SAMPLER_2D_MULTISAMPLE"; - case 0x9109: - return "GL_INT_SAMPLER_2D_MULTISAMPLE"; - case 0x910A: - return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; - case 0x910B: - return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; - case 0x910C: - return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; - case 0x910D: - return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; - case 0x910E: - return "GL_MAX_COLOR_TEXTURE_SAMPLES"; - case 0x910F: - return "GL_MAX_DEPTH_TEXTURE_SAMPLES"; - case 0x9110: - return "GL_MAX_INTEGER_SAMPLES"; - case 0x9111: - return "GL_MAX_SERVER_WAIT_TIMEOUT"; - case 0x9116: - return "GL_SYNC_FENCE"; - case 0x9118: - return "GL_UNSIGNALED"; - case 0x9119: - return "GL_SIGNALED"; - case 0x9122: - return "GL_MAX_VERTEX_OUTPUT_COMPONENTS"; - case 0x9123: - return "GL_MAX_GEOMETRY_INPUT_COMPONENTS"; - case 0x9124: - return "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"; - case 0x9125: - return "GL_MAX_FRAGMENT_INPUT_COMPONENTS"; - case 0x912F: - return "GL_TEXTURE_IMMUTABLE_FORMAT"; - case 0x9143: - return "GL_MAX_DEBUG_MESSAGE_LENGTH"; - case 0x9144: - return "GL_MAX_DEBUG_LOGGED_MESSAGES"; - case 0x9145: - return "GL_DEBUG_LOGGED_MESSAGES"; - case 0x9146: - return "GL_DEBUG_SEVERITY_HIGH_KHR"; - case 0x9147: - return "GL_DEBUG_SEVERITY_MEDIUM_KHR"; - case 0x9148: - return "GL_DEBUG_SEVERITY_LOW_KHR"; - case 0x9151: - return "GL_BUFFER_OBJECT_EXT"; - case 0x9153: - return "GL_QUERY_OBJECT_EXT"; - case 0x9154: - return "GL_VERTEX_ARRAY_OBJECT_EXT"; - case 0x919D: - return "GL_TEXTURE_BUFFER_OFFSET"; - case 0x919E: - return "GL_TEXTURE_BUFFER_SIZE"; - case 0x919F: - return "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"; - case 0x91B0: - return "GL_MAX_SHADER_COMPILER_THREADS_KHR"; - case 0x91B1: - return "GL_COMPLETION_STATUS_KHR"; - case 0x91BB: - return "GL_MAX_COMPUTE_UNIFORM_BLOCKS"; - case 0x91BC: - return "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"; - case 0x91BD: - return "GL_MAX_COMPUTE_IMAGE_UNIFORMS"; - case 0x91BE: - return "GL_MAX_COMPUTE_WORK_GROUP_COUNT"; - case 0x91BF: - return "GL_MAX_COMPUTE_WORK_GROUP_SIZE"; - case 0x92BB: - return "GL_PURGED_CONTEXT_RESET_NV"; - case 0x92BE: - return "GL_PRIMITIVE_BOUNDING_BOX"; - case 0x92C2: - return "GL_ATOMIC_COUNTER_BUFFER_START"; - case 0x92C3: - return "GL_ATOMIC_COUNTER_BUFFER_SIZE"; - case 0x92CC: - return "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS"; - case 0x92CD: - return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS"; - case 0x92CE: - return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS"; - case 0x92CF: - return "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS"; - case 0x92D0: - return "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS"; - case 0x92D1: - return "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS"; - case 0x92D2: - return "GL_MAX_VERTEX_ATOMIC_COUNTERS"; - case 0x92D3: - return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"; - case 0x92D4: - return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"; - case 0x92D5: - return "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"; - case 0x92D6: - return "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"; - case 0x92D7: - return "GL_MAX_COMBINED_ATOMIC_COUNTERS"; - case 0x92D8: - return "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE"; - case 0x92DB: - return "GL_UNSIGNED_INT_ATOMIC_COUNTER"; - case 0x92DC: - return "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS"; - case 0x92E0: - return "GL_DEBUG_OUTPUT"; - case 0x92E7: - return "GL_IS_PER_PATCH"; - case 0x92F9: - return "GL_NAME_LENGTH"; - case 0x92FA: - return "GL_TYPE"; - case 0x92FB: - return "GL_ARRAY_SIZE"; - case 0x92FC: - return "GL_OFFSET"; - case 0x92FD: - return "GL_BLOCK_INDEX"; - case 0x92FE: - return "GL_ARRAY_STRIDE"; - case 0x92FF: - return "GL_MATRIX_STRIDE"; - case 0x9300: - return "GL_IS_ROW_MAJOR"; - case 0x9301: - return "GL_ATOMIC_COUNTER_BUFFER_INDEX"; - case 0x9302: - return "GL_BUFFER_BINDING"; - case 0x9303: - return "GL_BUFFER_DATA_SIZE"; - case 0x9304: - return "GL_NUM_ACTIVE_VARIABLES"; - case 0x9305: - return "GL_ACTIVE_VARIABLES"; - case 0x9306: - return "GL_REFERENCED_BY_VERTEX_SHADER"; - case 0x9307: - return "GL_REFERENCED_BY_TESS_CONTROL_SHADER"; - case 0x9308: - return "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"; - case 0x9309: - return "GL_REFERENCED_BY_GEOMETRY_SHADER"; - case 0x930A: - return "GL_REFERENCED_BY_FRAGMENT_SHADER"; - case 0x930B: - return "GL_REFERENCED_BY_COMPUTE_SHADER"; - case 0x930C: - return "GL_TOP_LEVEL_ARRAY_SIZE"; - case 0x930D: - return "GL_TOP_LEVEL_ARRAY_STRIDE"; - case 0x930E: - return "GL_LOCATION"; - case 0x930F: - return "GL_LOCATION_INDEX_EXT"; - case 0x9312: - return "GL_FRAMEBUFFER_DEFAULT_LAYERS_EXT"; - case 0x9315: - return "GL_MAX_FRAMEBUFFER_WIDTH"; - case 0x9316: - return "GL_MAX_FRAMEBUFFER_HEIGHT"; - case 0x9317: - return "GL_MAX_FRAMEBUFFER_LAYERS"; - case 0x9318: - return "GL_MAX_FRAMEBUFFER_SAMPLES"; - case 0x935C: - return "GL_CLIP_ORIGIN_EXT"; - case 0x935D: - return "GL_CLIP_DEPTH_MODE_EXT"; - case 0x935E: - return "GL_NEGATIVE_ONE_TO_ONE_EXT"; - case 0x935F: - return "GL_ZERO_TO_ONE_EXT"; - case 0x9381: - return "GL_MULTISAMPLE_LINE_WIDTH_RANGE"; - case 0x9382: - return "GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY"; - case 0x93A0: - return "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE"; - case 0x93A1: - return "GL_BGRA8_EXT"; - case 0x93A2: - return "GL_TEXTURE_USAGE_ANGLE"; - case 0x93A3: - return "GL_FRAMEBUFFER_ATTACHMENT_ANGLE"; - case 0x93A4: - return "GL_PACK_REVERSE_ROW_ORDER_ANGLE"; - case 0x93A6: - return "GL_PROGRAM_BINARY_ANGLE"; - case 0x93A7: - return "GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE"; - case 0x93AE: - return "GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE"; - case 0x93AF: - return "GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE"; - case 0x93B0: - return "GL_COMPRESSED_RGBA_ASTC_4x4"; - case 0x93B1: - return "GL_COMPRESSED_RGBA_ASTC_5x4"; - case 0x93B2: - return "GL_COMPRESSED_RGBA_ASTC_5x5"; - case 0x93B3: - return "GL_COMPRESSED_RGBA_ASTC_6x5"; - case 0x93B4: - return "GL_COMPRESSED_RGBA_ASTC_6x6"; - case 0x93B5: - return "GL_COMPRESSED_RGBA_ASTC_8x5"; - case 0x93B6: - return "GL_COMPRESSED_RGBA_ASTC_8x6"; - case 0x93B7: - return "GL_COMPRESSED_RGBA_ASTC_8x8"; - case 0x93B8: - return "GL_COMPRESSED_RGBA_ASTC_10x5"; - case 0x93B9: - return "GL_COMPRESSED_RGBA_ASTC_10x6"; - case 0x93BA: - return "GL_COMPRESSED_RGBA_ASTC_10x8"; - case 0x93BB: - return "GL_COMPRESSED_RGBA_ASTC_10x10"; - case 0x93BC: - return "GL_COMPRESSED_RGBA_ASTC_12x10"; - case 0x93BD: - return "GL_COMPRESSED_RGBA_ASTC_12x12"; - case 0x93D0: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4"; - case 0x93D1: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4"; - case 0x93D2: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5"; - case 0x93D3: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5"; - case 0x93D4: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6"; - case 0x93D5: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5"; - case 0x93D6: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6"; - case 0x93D7: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8"; - case 0x93D8: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5"; - case 0x93D9: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6"; - case 0x93DA: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8"; - case 0x93DB: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10"; - case 0x93DC: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10"; - case 0x93DD: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12"; - case 0x9582: - return "GL_NUM_TILING_TYPES_EXT"; - case 0x9583: - return "GL_TILING_TYPES_EXT"; - case 0x9584: - return "GL_OPTIMAL_TILING_EXT"; - case 0x9585: - return "GL_LINEAR_TILING_EXT"; - case 0x9630: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"; - case 0x9631: - return "GL_MAX_VIEWS_OVR"; - case 0x9632: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"; - case 0x9633: - return "GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR"; - case 0x969F: - return "GL_RESOURCE_INITIALIZED_ANGLE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DepthFunction: - { - switch (value) - { - case 0x200: - return "GL_NEVER"; - case 0x201: - return "GL_LESS"; - case 0x202: - return "GL_EQUAL"; - case 0x203: - return "GL_LEQUAL"; - case 0x204: - return "GL_GREATER"; - case 0x205: - return "GL_NOTEQUAL"; - case 0x206: - return "GL_GEQUAL"; - case 0x207: - return "GL_ALWAYS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DrawBufferMode: - { - switch (value) - { - case 0x0: - return "GL_NONE"; - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - case 0x408: - return "GL_FRONT_AND_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::DrawElementsType: - { - switch (value) - { - case 0x1401: - return "GL_UNSIGNED_BYTE"; - case 0x1403: - return "GL_UNSIGNED_SHORT"; - case 0x1405: - return "GL_UNSIGNED_INT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::EnableCap: - { - switch (value) - { - case 0xB44: - return "GL_CULL_FACE"; - case 0xB71: - return "GL_DEPTH_TEST"; - case 0xB90: - return "GL_STENCIL_TEST"; - case 0xBD0: - return "GL_DITHER"; - case 0xBE2: - return "GL_BLEND"; - case 0xC11: - return "GL_SCISSOR_TEST"; - case 0xDE1: - return "GL_TEXTURE_2D"; - case 0x8037: - return "GL_POLYGON_OFFSET_FILL"; - case 0x8074: - return "GL_VERTEX_ARRAY"; - case 0x8DB9: - return "GL_FRAMEBUFFER_SRGB_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ErrorCode: - { - switch (value) - { - case 0x500: - return "GL_INVALID_ENUM"; - case 0x501: - return "GL_INVALID_VALUE"; - case 0x502: - return "GL_INVALID_OPERATION"; - case 0x503: - return "GL_STACK_OVERFLOW"; - case 0x504: - return "GL_STACK_UNDERFLOW"; - case 0x505: - return "GL_OUT_OF_MEMORY"; - case 0x506: - return "GL_INVALID_FRAMEBUFFER_OPERATION"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ExternalHandleType: - { - switch (value) - { - case 0x9586: - return "GL_HANDLE_TYPE_OPAQUE_FD_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FogCoordinatePointerType: - { - switch (value) - { - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FogMode: - { - switch (value) - { - case 0x2601: - return "GL_LINEAR"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FogPointerTypeEXT: - { - switch (value) - { - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FogPointerTypeIBM: - { - switch (value) - { - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FramebufferAttachment: - { - switch (value) - { + return "GL_FRAMEBUFFER_UNSUPPORTED"; case 0x8CDF: return "GL_MAX_COLOR_ATTACHMENTS"; case 0x8CE0: @@ -2222,514 +1766,60 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_COLOR_ATTACHMENT31"; case 0x8D00: return "GL_DEPTH_ATTACHMENT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FramebufferAttachmentParameterName: - { - switch (value) - { - case 0x8210: - return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; - case 0x8211: - return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; - case 0x8212: - return "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"; - case 0x8213: - return "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; - case 0x8214: - return "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; - case 0x8215: - return "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; - case 0x8216: - return "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; - case 0x8217: - return "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; - case 0x8CD1: - return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; - case 0x8CD2: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; - case 0x8CD3: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; - case 0x8CD4: - return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"; - case 0x8DA7: - return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FramebufferParameterName: - { - switch (value) - { - case 0x9310: - return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; - case 0x9311: - return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; - case 0x9312: - return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; - case 0x9313: - return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; - case 0x9314: - return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FramebufferStatus: - { - switch (value) - { - case 0x8219: - return "GL_FRAMEBUFFER_UNDEFINED"; - case 0x8CD5: - return "GL_FRAMEBUFFER_COMPLETE"; - case 0x8CD6: - return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; - case 0x8CD7: - return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; - case 0x8CDD: - return "GL_FRAMEBUFFER_UNSUPPORTED"; - case 0x8D56: - return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; - case 0x8DA8: - return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FramebufferTarget: - { - switch (value) - { - case 0x8CA8: - return "GL_READ_FRAMEBUFFER"; - case 0x8CA9: - return "GL_DRAW_FRAMEBUFFER"; + case 0x8D20: + return "GL_STENCIL_ATTACHMENT"; case 0x8D40: return "GL_FRAMEBUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::FrontFaceDirection: - { - switch (value) - { - case 0x900: - return "GL_CW"; - case 0x901: - return "GL_CCW"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::GetFramebufferParameter: - { - switch (value) - { - case 0x80A8: - return "GL_SAMPLE_BUFFERS"; - case 0x80A9: - return "GL_SAMPLES"; - case 0x8B9A: - return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; - case 0x8B9B: - return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; - case 0x9310: - return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; - case 0x9311: - return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; - case 0x9312: - return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; - case 0x9313: - return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; - case 0x9314: - return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::GetPName: - { - switch (value) - { - case 0xB21: - return "GL_LINE_WIDTH"; - case 0xB44: - return "GL_CULL_FACE"; - case 0xB45: - return "GL_CULL_FACE_MODE"; - case 0xB46: - return "GL_FRONT_FACE"; - case 0xB70: - return "GL_DEPTH_RANGE"; - case 0xB71: - return "GL_DEPTH_TEST"; - case 0xB72: - return "GL_DEPTH_WRITEMASK"; - case 0xB73: - return "GL_DEPTH_CLEAR_VALUE"; - case 0xB74: - return "GL_DEPTH_FUNC"; - case 0xB90: - return "GL_STENCIL_TEST"; - case 0xB91: - return "GL_STENCIL_CLEAR_VALUE"; - case 0xB92: - return "GL_STENCIL_FUNC"; - case 0xB93: - return "GL_STENCIL_VALUE_MASK"; - case 0xB94: - return "GL_STENCIL_FAIL"; - case 0xB95: - return "GL_STENCIL_PASS_DEPTH_FAIL"; - case 0xB96: - return "GL_STENCIL_PASS_DEPTH_PASS"; - case 0xB97: - return "GL_STENCIL_REF"; - case 0xB98: - return "GL_STENCIL_WRITEMASK"; - case 0xBA2: - return "GL_VIEWPORT"; - case 0xBD0: - return "GL_DITHER"; - case 0xBE2: - return "GL_BLEND"; - case 0xC02: - return "GL_READ_BUFFER"; - case 0xC10: - return "GL_SCISSOR_BOX"; - case 0xC11: - return "GL_SCISSOR_TEST"; - case 0xC22: - return "GL_COLOR_CLEAR_VALUE"; - case 0xC23: - return "GL_COLOR_WRITEMASK"; - case 0xCF2: - return "GL_UNPACK_ROW_LENGTH"; - case 0xCF3: - return "GL_UNPACK_SKIP_ROWS"; - case 0xCF4: - return "GL_UNPACK_SKIP_PIXELS"; - case 0xCF5: - return "GL_UNPACK_ALIGNMENT"; - case 0xD02: - return "GL_PACK_ROW_LENGTH"; - case 0xD03: - return "GL_PACK_SKIP_ROWS"; - case 0xD04: - return "GL_PACK_SKIP_PIXELS"; - case 0xD05: - return "GL_PACK_ALIGNMENT"; - case 0xD33: - return "GL_MAX_TEXTURE_SIZE"; - case 0xD3A: - return "GL_MAX_VIEWPORT_DIMS"; - case 0xD50: - return "GL_SUBPIXEL_BITS"; - case 0xD52: - return "GL_RED_BITS"; - case 0xD53: - return "GL_GREEN_BITS"; - case 0xD54: - return "GL_BLUE_BITS"; - case 0xD55: - return "GL_ALPHA_BITS"; - case 0xD56: - return "GL_DEPTH_BITS"; - case 0xD57: - return "GL_STENCIL_BITS"; - case 0xDE1: - return "GL_TEXTURE_2D"; - case 0x2A00: - return "GL_POLYGON_OFFSET_UNITS"; - case 0x8037: - return "GL_POLYGON_OFFSET_FILL"; - case 0x8038: - return "GL_POLYGON_OFFSET_FACTOR"; - case 0x8069: - return "GL_TEXTURE_BINDING_2D"; - case 0x806A: - return "GL_TEXTURE_BINDING_3D"; - case 0x8074: - return "GL_VERTEX_ARRAY"; - case 0x846D: - return "GL_ALIASED_POINT_SIZE_RANGE"; - case 0x846E: - return "GL_ALIASED_LINE_WIDTH_RANGE"; - case 0x9596: - return "GL_NUM_DEVICE_UUIDS_EXT"; - case 0x9597: - return "GL_DEVICE_UUID_EXT"; - case 0x9598: - return "GL_DRIVER_UUID_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::GetPointervPName: - { - switch (value) - { - case 0x8244: - return "GL_DEBUG_CALLBACK_FUNCTION"; - case 0x8245: - return "GL_DEBUG_CALLBACK_USER_PARAM"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::GetTextureParameter: - { - switch (value) - { - case 0x1000: - return "GL_TEXTURE_WIDTH"; - case 0x1001: - return "GL_TEXTURE_HEIGHT"; - case 0x1003: - return "GL_TEXTURE_INTERNAL_FORMAT"; - case 0x1004: - return "GL_TEXTURE_BORDER_COLOR"; - case 0x2800: - return "GL_TEXTURE_MAG_FILTER"; - case 0x2801: - return "GL_TEXTURE_MIN_FILTER"; - case 0x2802: - return "GL_TEXTURE_WRAP_S"; - case 0x2803: - return "GL_TEXTURE_WRAP_T"; - case 0x805C: - return "GL_TEXTURE_RED_SIZE"; - case 0x805D: - return "GL_TEXTURE_GREEN_SIZE"; - case 0x805E: - return "GL_TEXTURE_BLUE_SIZE"; - case 0x805F: - return "GL_TEXTURE_ALPHA_SIZE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::GraphicsResetStatus: - { - switch (value) - { - case 0x8253: - return "GL_GUILTY_CONTEXT_RESET"; - case 0x8254: - return "GL_INNOCENT_CONTEXT_RESET"; - case 0x8255: - return "GL_UNKNOWN_CONTEXT_RESET"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::HintMode: - { - switch (value) - { - case 0x1100: - return "GL_DONT_CARE"; - case 0x1101: - return "GL_FASTEST"; - case 0x1102: - return "GL_NICEST"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::HintTarget: - { - switch (value) - { - case 0x8192: - return "GL_GENERATE_MIPMAP_HINT"; - case 0x8257: - return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; - case 0x8B8B: - return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::IndexPointerType: - { - switch (value) - { - case 0x1402: - return "GL_SHORT"; - case 0x1404: - return "GL_INT"; - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::InternalFormat: - { - switch (value) - { - case 0x1802: - return "GL_STENCIL"; - case 0x1902: - return "GL_DEPTH_COMPONENT"; - case 0x1903: - return "GL_RED"; - case 0x1906: - return "GL_ALPHA"; - case 0x1907: - return "GL_RGB"; - case 0x1908: - return "GL_RGBA"; - case 0x1909: - return "GL_LUMINANCE"; - case 0x190A: - return "GL_LUMINANCE_ALPHA"; - case 0x8051: - return "GL_RGB8"; - case 0x8052: - return "GL_RGB10_EXT"; - case 0x8054: - return "GL_RGB16_EXT"; - case 0x8056: - return "GL_RGBA4"; - case 0x8057: - return "GL_RGB5_A1"; - case 0x8058: - return "GL_RGBA8"; - case 0x8059: - return "GL_RGB10_A2"; - case 0x805B: - return "GL_RGBA16_EXT"; - case 0x80E1: - return "GL_BGRA_EXT"; - case 0x81A5: - return "GL_DEPTH_COMPONENT16"; - case 0x81A6: - return "GL_DEPTH_COMPONENT24_OES"; - case 0x81A7: - return "GL_DEPTH_COMPONENT32_OES"; - case 0x8227: - return "GL_RG"; - case 0x8229: - return "GL_R8"; - case 0x822A: - return "GL_R16_EXT"; - case 0x822B: - return "GL_RG8"; - case 0x822C: - return "GL_RG16_EXT"; - case 0x822D: - return "GL_R16F"; - case 0x822E: - return "GL_R32F"; - case 0x822F: - return "GL_RG16F"; - case 0x8230: - return "GL_RG32F"; - case 0x8231: - return "GL_R8I"; - case 0x8232: - return "GL_R8UI"; - case 0x8233: - return "GL_R16I"; - case 0x8234: - return "GL_R16UI"; - case 0x8235: - return "GL_R32I"; - case 0x8236: - return "GL_R32UI"; - case 0x8237: - return "GL_RG8I"; - case 0x8238: - return "GL_RG8UI"; - case 0x8239: - return "GL_RG16I"; - case 0x823A: - return "GL_RG16UI"; - case 0x823B: - return "GL_RG32I"; - case 0x823C: - return "GL_RG32UI"; - case 0x83F0: - return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; - case 0x83F1: - return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; - case 0x83F2: - return "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE"; - case 0x83F3: - return "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE"; - case 0x84F9: - return "GL_DEPTH_STENCIL"; - case 0x8814: - return "GL_RGBA32F"; - case 0x881A: - return "GL_RGBA16F"; - case 0x881B: - return "GL_RGB16F"; - case 0x88F0: - return "GL_DEPTH24_STENCIL8"; - case 0x8A54: - return "GL_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT"; - case 0x8A55: - return "GL_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT"; - case 0x8A56: - return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT"; - case 0x8A57: - return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT"; - case 0x8C00: - return "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"; - case 0x8C01: - return "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"; - case 0x8C02: - return "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"; - case 0x8C03: - return "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"; - case 0x8C3A: - return "GL_R11F_G11F_B10F"; - case 0x8C3D: - return "GL_RGB9_E5"; - case 0x8C40: - return "GL_SRGB"; - case 0x8C41: - return "GL_SRGB8"; - case 0x8C42: - return "GL_SRGB_ALPHA_EXT"; - case 0x8C43: - return "GL_SRGB8_ALPHA8"; - case 0x8C4C: - return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT"; - case 0x8C4D: - return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; - case 0x8C4E: - return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; - case 0x8C4F: - return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; - case 0x8CAC: - return "GL_DEPTH_COMPONENT32F"; - case 0x8CAD: - return "GL_DEPTH32F_STENCIL8"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x8D42: + return "GL_RENDERBUFFER_WIDTH"; + case 0x8D43: + return "GL_RENDERBUFFER_HEIGHT"; + case 0x8D44: + return "GL_RENDERBUFFER_INTERNAL_FORMAT"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D50: + return "GL_RENDERBUFFER_RED_SIZE"; + case 0x8D51: + return "GL_RENDERBUFFER_GREEN_SIZE"; + case 0x8D52: + return "GL_RENDERBUFFER_BLUE_SIZE"; + case 0x8D53: + return "GL_RENDERBUFFER_ALPHA_SIZE"; + case 0x8D54: + return "GL_RENDERBUFFER_DEPTH_SIZE"; + case 0x8D55: + return "GL_RENDERBUFFER_STENCIL_SIZE"; + case 0x8D56: + return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; + case 0x8D57: + return "GL_MAX_SAMPLES"; + case 0x8D60: + return "GL_TEXTURE_GEN_STR_OES"; + case 0x8D61: + return "GL_HALF_FLOAT_OES"; + case 0x8D62: + return "GL_RGB565"; case 0x8D64: return "GL_ETC1_RGB8_OES"; + case 0x8D65: + return "GL_TEXTURE_EXTERNAL_OES"; + case 0x8D66: + return "GL_SAMPLER_EXTERNAL_OES"; + case 0x8D67: + return "GL_TEXTURE_BINDING_EXTERNAL_OES"; + case 0x8D68: + return "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES"; + case 0x8D69: + return "GL_PRIMITIVE_RESTART_FIXED_INDEX"; + case 0x8D6A: + return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"; + case 0x8D6B: + return "GL_MAX_ELEMENT_INDEX"; + case 0x8D6C: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT"; case 0x8D70: return "GL_RGBA32UI"; case 0x8D71: @@ -2754,6 +1844,22 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_RGBA8I"; case 0x8D8F: return "GL_RGB8I"; + case 0x8D94: + return "GL_RED_INTEGER"; + case 0x8D98: + return "GL_RGB_INTEGER"; + case 0x8D99: + return "GL_RGBA_INTEGER"; + case 0x8D9F: + return "GL_INT_2_10_10_10_REV"; + case 0x8DA7: + return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"; + case 0x8DA8: + return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; + case 0x8DAD: + return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV"; + case 0x8DB9: + return "GL_FRAMEBUFFER_SRGB_EXT"; case 0x8DBB: return "GL_COMPRESSED_RED_RGTC1_EXT"; case 0x8DBC: @@ -2762,6 +1868,170 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; case 0x8DBE: return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8DDF: + return "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8DE0: + return "GL_MAX_GEOMETRY_OUTPUT_VERTICES"; + case 0x8DE1: + return "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS"; + case 0x8DF0: + return "GL_LOW_FLOAT"; + case 0x8DF1: + return "GL_MEDIUM_FLOAT"; + case 0x8DF2: + return "GL_HIGH_FLOAT"; + case 0x8DF3: + return "GL_LOW_INT"; + case 0x8DF4: + return "GL_MEDIUM_INT"; + case 0x8DF5: + return "GL_HIGH_INT"; + case 0x8DF6: + return "GL_UNSIGNED_INT_10_10_10_2_OES"; + case 0x8DF7: + return "GL_INT_10_10_10_2_OES"; + case 0x8DF8: + return "GL_SHADER_BINARY_FORMATS"; + case 0x8DF9: + return "GL_NUM_SHADER_BINARY_FORMATS"; + case 0x8DFA: + return "GL_SHADER_COMPILER"; + case 0x8DFB: + return "GL_MAX_VERTEX_UNIFORM_VECTORS"; + case 0x8DFC: + return "GL_MAX_VARYING_VECTORS"; + case 0x8DFD: + return "GL_MAX_FRAGMENT_UNIFORM_VECTORS"; + case 0x8E1E: + return "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS"; + case 0x8E1F: + return "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS"; + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; + case 0x8E23: + return "GL_TRANSFORM_FEEDBACK_PAUSED"; + case 0x8E24: + return "GL_TRANSFORM_FEEDBACK_ACTIVE"; + case 0x8E25: + return "GL_TRANSFORM_FEEDBACK_BINDING"; + case 0x8E28: + return "GL_TIMESTAMP_EXT"; + case 0x8E42: + return "GL_TEXTURE_SWIZZLE_R"; + case 0x8E43: + return "GL_TEXTURE_SWIZZLE_G"; + case 0x8E44: + return "GL_TEXTURE_SWIZZLE_B"; + case 0x8E45: + return "GL_TEXTURE_SWIZZLE_A"; + case 0x8E4D: + return "GL_FIRST_VERTEX_CONVENTION"; + case 0x8E4E: + return "GL_LAST_VERTEX_CONVENTION"; + case 0x8E4F: + return "GL_PROVOKING_VERTEX"; + case 0x8E50: + return "GL_SAMPLE_POSITION"; + case 0x8E51: + return "GL_SAMPLE_MASK"; + case 0x8E52: + return "GL_SAMPLE_MASK_VALUE"; + case 0x8E59: + return "GL_MAX_SAMPLE_MASK_WORDS"; + case 0x8E5A: + return "GL_MAX_GEOMETRY_SHADER_INVOCATIONS"; + case 0x8E5B: + return "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET"; + case 0x8E5C: + return "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET"; + case 0x8E5D: + return "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS"; + case 0x8E5E: + return "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET"; + case 0x8E5F: + return "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET"; + case 0x8E72: + return "GL_PATCH_VERTICES"; + case 0x8E75: + return "GL_TESS_CONTROL_OUTPUT_VERTICES"; + case 0x8E76: + return "GL_TESS_GEN_MODE"; + case 0x8E77: + return "GL_TESS_GEN_SPACING"; + case 0x8E78: + return "GL_TESS_GEN_VERTEX_ORDER"; + case 0x8E79: + return "GL_TESS_GEN_POINT_MODE"; + case 0x8E7A: + return "GL_ISOLINES"; + case 0x8E7B: + return "GL_FRACTIONAL_ODD"; + case 0x8E7C: + return "GL_FRACTIONAL_EVEN"; + case 0x8E7D: + return "GL_MAX_PATCH_VERTICES"; + case 0x8E7E: + return "GL_MAX_TESS_GEN_LEVEL"; + case 0x8E7F: + return "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS"; + case 0x8E80: + return "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS"; + case 0x8E81: + return "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS"; + case 0x8E82: + return "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS"; + case 0x8E83: + return "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS"; + case 0x8E84: + return "GL_MAX_TESS_PATCH_COMPONENTS"; + case 0x8E85: + return "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS"; + case 0x8E86: + return "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + case 0x8E89: + return "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"; + case 0x8E8A: + return "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"; case 0x8E8C: return "GL_COMPRESSED_RGBA_BPTC_UNORM_EXT"; case 0x8E8D: @@ -2770,6 +2040,30 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"; case 0x8E8F: return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F38: + return "GL_MAX_IMAGE_UNITS"; + case 0x8F39: + return "GL_MAX_COMBINED_SHADER_OUTPUT_RESOURCES"; + case 0x8F3A: + return "GL_IMAGE_BINDING_NAME"; + case 0x8F3B: + return "GL_IMAGE_BINDING_LEVEL"; + case 0x8F3C: + return "GL_IMAGE_BINDING_LAYERED"; + case 0x8F3D: + return "GL_IMAGE_BINDING_LAYER"; + case 0x8F3E: + return "GL_IMAGE_BINDING_ACCESS"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x8F43: + return "GL_DRAW_INDIRECT_BUFFER_BINDING"; + case 0x8F4F: + return "GL_VERTEX_BINDING_BUFFER"; case 0x8F94: return "GL_R8_SNORM"; case 0x8F95: @@ -2786,12 +2080,240 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_RGB16_SNORM_EXT"; case 0x8F9B: return "GL_RGBA16_SNORM_EXT"; + case 0x8F9C: + return "GL_SIGNED_NORMALIZED"; + case 0x8FBB: + return "GL_GPU_DISJOINT_EXT"; + case 0x8FBD: + return "GL_SR8_EXT"; + case 0x8FBE: + return "GL_SRG8_EXT"; + case 0x8FBF: + return "GL_TEXTURE_FORMAT_SRGB_OVERRIDE_EXT"; + case 0x9009: + return "GL_TEXTURE_CUBE_MAP_ARRAY"; + case 0x900A: + return "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x906E: + return "GL_IMAGE_BINDING_FORMAT"; case 0x906F: return "GL_RGB10_A2UI"; + case 0x90C7: + return "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"; + case 0x90C8: + return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE"; + case 0x90C9: + return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS"; + case 0x90CA: + return "GL_MAX_VERTEX_IMAGE_UNIFORMS"; + case 0x90CB: + return "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS"; + case 0x90CC: + return "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS"; + case 0x90CD: + return "GL_MAX_GEOMETRY_IMAGE_UNIFORMS"; + case 0x90CE: + return "GL_MAX_FRAGMENT_IMAGE_UNIFORMS"; + case 0x90CF: + return "GL_MAX_COMBINED_IMAGE_UNIFORMS"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90D3: + return "GL_SHADER_STORAGE_BUFFER_BINDING"; + case 0x90D4: + return "GL_SHADER_STORAGE_BUFFER_START"; + case 0x90D5: + return "GL_SHADER_STORAGE_BUFFER_SIZE"; + case 0x90D6: + return "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"; + case 0x90D7: + return "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"; + case 0x90D8: + return "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"; + case 0x90D9: + return "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"; + case 0x90DA: + return "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; + case 0x90DB: + return "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"; + case 0x90DC: + return "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"; + case 0x90DD: + return "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"; + case 0x90DE: + return "GL_MAX_SHADER_STORAGE_BLOCK_SIZE"; + case 0x90DF: + return "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"; + case 0x90EA: + return "GL_DEPTH_STENCIL_TEXTURE_MODE"; + case 0x90EB: + return "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x90EF: + return "GL_DISPATCH_INDIRECT_BUFFER_BINDING"; + case 0x90F3: + return "GL_CONTEXT_ROBUST_ACCESS_EXT"; + case 0x9100: + return "GL_TEXTURE_2D_MULTISAMPLE"; + case 0x9102: + return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; + case 0x9104: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE"; + case 0x9105: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"; + case 0x9106: + return "GL_TEXTURE_SAMPLES"; + case 0x9107: + return "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910E: + return "GL_MAX_COLOR_TEXTURE_SAMPLES"; + case 0x910F: + return "GL_MAX_DEPTH_TEXTURE_SAMPLES"; + case 0x9110: + return "GL_MAX_INTEGER_SAMPLES"; + case 0x9111: + return "GL_MAX_SERVER_WAIT_TIMEOUT"; + case 0x9112: + return "GL_OBJECT_TYPE"; + case 0x9113: + return "GL_SYNC_CONDITION"; + case 0x9114: + return "GL_SYNC_STATUS"; + case 0x9115: + return "GL_SYNC_FLAGS"; + case 0x9116: + return "GL_SYNC_FENCE"; + case 0x9117: + return "GL_SYNC_GPU_COMMANDS_COMPLETE"; + case 0x9118: + return "GL_UNSIGNALED"; + case 0x9119: + return "GL_SIGNALED"; + case 0x911A: + return "GL_ALREADY_SIGNALED"; + case 0x911B: + return "GL_TIMEOUT_EXPIRED"; + case 0x911C: + return "GL_CONDITION_SATISFIED"; + case 0x911D: + return "GL_WAIT_FAILED"; + case 0x911F: + return "GL_BUFFER_ACCESS_FLAGS"; + case 0x9120: + return "GL_BUFFER_MAP_LENGTH"; + case 0x9121: + return "GL_BUFFER_MAP_OFFSET"; + case 0x9122: + return "GL_MAX_VERTEX_OUTPUT_COMPONENTS"; + case 0x9123: + return "GL_MAX_GEOMETRY_INPUT_COMPONENTS"; + case 0x9124: + return "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"; + case 0x9125: + return "GL_MAX_FRAGMENT_INPUT_COMPONENTS"; + case 0x912F: + return "GL_TEXTURE_IMMUTABLE_FORMAT"; case 0x9137: return "GL_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG"; case 0x9138: return "GL_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG"; + case 0x9143: + return "GL_MAX_DEBUG_MESSAGE_LENGTH"; + case 0x9144: + return "GL_MAX_DEBUG_LOGGED_MESSAGES"; + case 0x9145: + return "GL_DEBUG_LOGGED_MESSAGES"; + case 0x9146: + return "GL_DEBUG_SEVERITY_HIGH"; + case 0x9147: + return "GL_DEBUG_SEVERITY_MEDIUM"; + case 0x9148: + return "GL_DEBUG_SEVERITY_LOW"; + case 0x9151: + return "GL_BUFFER_OBJECT_EXT"; + case 0x9153: + return "GL_QUERY_OBJECT_EXT"; + case 0x9154: + return "GL_VERTEX_ARRAY_OBJECT_EXT"; + case 0x919D: + return "GL_TEXTURE_BUFFER_OFFSET"; + case 0x919E: + return "GL_TEXTURE_BUFFER_SIZE"; + case 0x919F: + return "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"; + case 0x91B0: + return "GL_MAX_SHADER_COMPILER_THREADS_KHR"; + case 0x91B1: + return "GL_COMPLETION_STATUS_KHR"; + case 0x91B9: + return "GL_COMPUTE_SHADER"; + case 0x91BB: + return "GL_MAX_COMPUTE_UNIFORM_BLOCKS"; + case 0x91BC: + return "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"; + case 0x91BD: + return "GL_MAX_COMPUTE_IMAGE_UNIFORMS"; + case 0x91BE: + return "GL_MAX_COMPUTE_WORK_GROUP_COUNT"; + case 0x91BF: + return "GL_MAX_COMPUTE_WORK_GROUP_SIZE"; case 0x9270: return "GL_COMPRESSED_R11_EAC"; case 0x9271: @@ -2812,34 +2334,226 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_COMPRESSED_RGBA8_ETC2_EAC"; case 0x9279: return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x9294: + return "GL_MULTIPLY"; + case 0x9295: + return "GL_SCREEN"; + case 0x9296: + return "GL_OVERLAY"; + case 0x9297: + return "GL_DARKEN"; + case 0x9298: + return "GL_LIGHTEN"; + case 0x9299: + return "GL_COLORDODGE"; + case 0x929A: + return "GL_COLORBURN"; + case 0x929B: + return "GL_HARDLIGHT"; + case 0x929C: + return "GL_SOFTLIGHT"; + case 0x929E: + return "GL_DIFFERENCE"; + case 0x92A0: + return "GL_EXCLUSION"; + case 0x92AD: + return "GL_HSL_HUE"; + case 0x92AE: + return "GL_HSL_SATURATION"; + case 0x92AF: + return "GL_HSL_COLOR"; + case 0x92B0: + return "GL_HSL_LUMINOSITY"; + case 0x92BE: + return "GL_PRIMITIVE_BOUNDING_BOX"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + case 0x92C1: + return "GL_ATOMIC_COUNTER_BUFFER_BINDING"; + case 0x92C2: + return "GL_ATOMIC_COUNTER_BUFFER_START"; + case 0x92C3: + return "GL_ATOMIC_COUNTER_BUFFER_SIZE"; + case 0x92CC: + return "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS"; + case 0x92CD: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS"; + case 0x92CE: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS"; + case 0x92CF: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS"; + case 0x92D0: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS"; + case 0x92D1: + return "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS"; + case 0x92D2: + return "GL_MAX_VERTEX_ATOMIC_COUNTERS"; + case 0x92D3: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"; + case 0x92D4: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"; + case 0x92D5: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"; + case 0x92D6: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"; + case 0x92D7: + return "GL_MAX_COMBINED_ATOMIC_COUNTERS"; + case 0x92D8: + return "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE"; + case 0x92D9: + return "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"; + case 0x92DB: + return "GL_UNSIGNED_INT_ATOMIC_COUNTER"; + case 0x92DC: + return "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS"; + case 0x92E0: + return "GL_DEBUG_OUTPUT"; + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E2: + return "GL_UNIFORM_BLOCK"; + case 0x92E3: + return "GL_PROGRAM_INPUT"; + case 0x92E4: + return "GL_PROGRAM_OUTPUT"; + case 0x92E5: + return "GL_BUFFER_VARIABLE"; + case 0x92E6: + return "GL_SHADER_STORAGE_BLOCK"; + case 0x92E7: + return "GL_IS_PER_PATCH"; + case 0x92F4: + return "GL_TRANSFORM_FEEDBACK_VARYING"; + case 0x92F5: + return "GL_ACTIVE_RESOURCES"; + case 0x92F6: + return "GL_MAX_NAME_LENGTH"; + case 0x92F7: + return "GL_MAX_NUM_ACTIVE_VARIABLES"; + case 0x92F9: + return "GL_NAME_LENGTH"; + case 0x92FA: + return "GL_TYPE"; + case 0x92FB: + return "GL_ARRAY_SIZE"; + case 0x92FC: + return "GL_OFFSET"; + case 0x92FD: + return "GL_BLOCK_INDEX"; + case 0x92FE: + return "GL_ARRAY_STRIDE"; + case 0x92FF: + return "GL_MATRIX_STRIDE"; + case 0x9300: + return "GL_IS_ROW_MAJOR"; + case 0x9301: + return "GL_ATOMIC_COUNTER_BUFFER_INDEX"; + case 0x9302: + return "GL_BUFFER_BINDING"; + case 0x9303: + return "GL_BUFFER_DATA_SIZE"; + case 0x9304: + return "GL_NUM_ACTIVE_VARIABLES"; + case 0x9305: + return "GL_ACTIVE_VARIABLES"; + case 0x9306: + return "GL_REFERENCED_BY_VERTEX_SHADER"; + case 0x9307: + return "GL_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x9308: + return "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x9309: + return "GL_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x930A: + return "GL_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x930B: + return "GL_REFERENCED_BY_COMPUTE_SHADER"; + case 0x930C: + return "GL_TOP_LEVEL_ARRAY_SIZE"; + case 0x930D: + return "GL_TOP_LEVEL_ARRAY_STRIDE"; + case 0x930E: + return "GL_LOCATION"; + case 0x930F: + return "GL_LOCATION_INDEX_EXT"; + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + case 0x9315: + return "GL_MAX_FRAMEBUFFER_WIDTH"; + case 0x9316: + return "GL_MAX_FRAMEBUFFER_HEIGHT"; + case 0x9317: + return "GL_MAX_FRAMEBUFFER_LAYERS"; + case 0x9318: + return "GL_MAX_FRAMEBUFFER_SAMPLES"; + case 0x935C: + return "GL_CLIP_ORIGIN_EXT"; + case 0x935D: + return "GL_CLIP_DEPTH_MODE_EXT"; + case 0x935E: + return "GL_NEGATIVE_ONE_TO_ONE_EXT"; + case 0x935F: + return "GL_ZERO_TO_ONE_EXT"; + case 0x9380: + return "GL_NUM_SAMPLE_COUNTS"; + case 0x9381: + return "GL_MULTISAMPLE_LINE_WIDTH_RANGE"; + case 0x9382: + return "GL_MULTISAMPLE_LINE_WIDTH_GRANULARITY"; + case 0x93A0: + return "GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE"; + case 0x93A1: + return "GL_BGRA8_EXT"; + case 0x93A2: + return "GL_TEXTURE_USAGE_ANGLE"; + case 0x93A3: + return "GL_FRAMEBUFFER_ATTACHMENT_ANGLE"; + case 0x93A4: + return "GL_PACK_REVERSE_ROW_ORDER_ANGLE"; + case 0x93A6: + return "GL_PROGRAM_BINARY_ANGLE"; + case 0x93A7: + return "GL_ROBUST_RESOURCE_INITIALIZATION_ANGLE"; + case 0x93AE: + return "GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE"; + case 0x93AF: + return "GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE"; case 0x93B0: - return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_4x4"; case 0x93B1: - return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_5x4"; case 0x93B2: - return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_5x5"; case 0x93B3: - return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_6x5"; case 0x93B4: - return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_6x6"; case 0x93B5: - return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_8x5"; case 0x93B6: - return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_8x6"; case 0x93B7: - return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_8x8"; case 0x93B8: - return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_10x5"; case 0x93B9: - return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_10x6"; case 0x93BA: - return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_10x8"; case 0x93BB: - return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_10x10"; case 0x93BC: - return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_12x10"; case 0x93BD: - return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; + return "GL_COMPRESSED_RGBA_ASTC_12x12"; case 0x93C0: return "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES"; case 0x93C1: @@ -2861,33 +2575,33 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x93C9: return "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES"; case 0x93D0: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4"; case 0x93D1: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4"; case 0x93D2: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5"; case 0x93D3: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5"; case 0x93D4: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6"; case 0x93D5: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5"; case 0x93D6: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6"; case 0x93D7: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8"; case 0x93D8: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5"; case 0x93D9: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6"; case 0x93DA: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8"; case 0x93DB: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10"; case 0x93DC: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10"; case 0x93DD: - return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12"; case 0x93E0: return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES"; case 0x93E1: @@ -2912,766 +2626,56 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG"; case 0x93F1: return "GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::InternalFormatPName: - { - switch (value) - { - case 0x80A9: - return "GL_SAMPLES"; - case 0x86A1: - return "GL_TEXTURE_COMPRESSED"; - case 0x90C7: - return "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"; - case 0x9380: - return "GL_NUM_SAMPLE_COUNTS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::LightEnvModeSGIX: - { - switch (value) - { - case 0x1E01: - return "GL_REPLACE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ListNameType: - { - switch (value) - { - case 0x1400: - return "GL_BYTE"; - case 0x1401: - return "GL_UNSIGNED_BYTE"; - case 0x1402: - return "GL_SHORT"; - case 0x1403: - return "GL_UNSIGNED_SHORT"; - case 0x1404: - return "GL_INT"; - case 0x1405: - return "GL_UNSIGNED_INT"; - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::LogicOp: - { - switch (value) - { - case 0x150A: - return "GL_INVERT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::MapBufferUsageMask: - { - switch (value) - { - case 0x1: - return "GL_MAP_READ_BIT"; - case 0x2: - return "GL_MAP_WRITE_BIT"; - case 0x4: - return "GL_MAP_INVALIDATE_RANGE_BIT"; - case 0x8: - return "GL_MAP_INVALIDATE_BUFFER_BIT"; - case 0x10: - return "GL_MAP_FLUSH_EXPLICIT_BIT"; - case 0x20: - return "GL_MAP_UNSYNCHRONIZED_BIT"; - case 0x40: - return "GL_MAP_PERSISTENT_BIT_EXT"; - case 0x80: - return "GL_MAP_COHERENT_BIT_EXT"; - case 0x100: - return "GL_DYNAMIC_STORAGE_BIT_EXT"; - case 0x200: - return "GL_CLIENT_STORAGE_BIT_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::MaterialFace: - { - switch (value) - { - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - case 0x408: - return "GL_FRONT_AND_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::MatrixMode: - { - switch (value) - { - case 0x1702: - return "GL_TEXTURE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::MemoryBarrierMask: - { - switch (value) - { - case 0x1: - return "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT"; - case 0x2: - return "GL_ELEMENT_ARRAY_BARRIER_BIT"; - case 0x4: - return "GL_UNIFORM_BARRIER_BIT"; - case 0x8: - return "GL_TEXTURE_FETCH_BARRIER_BIT"; - case 0x20: - return "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT"; - case 0x40: - return "GL_COMMAND_BARRIER_BIT"; - case 0x80: - return "GL_PIXEL_BUFFER_BARRIER_BIT"; - case 0x100: - return "GL_TEXTURE_UPDATE_BARRIER_BIT"; - case 0x200: - return "GL_BUFFER_UPDATE_BARRIER_BIT"; - case 0x400: - return "GL_FRAMEBUFFER_BARRIER_BIT"; - case 0x800: - return "GL_TRANSFORM_FEEDBACK_BARRIER_BIT"; - case 0x1000: - return "GL_ATOMIC_COUNTER_BARRIER_BIT"; - case 0x2000: - return "GL_SHADER_STORAGE_BARRIER_BIT"; - case 0x4000: - return "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT"; - case 0xFFFFFFFF: - return "GL_ALL_BARRIER_BITS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::MemoryObjectParameterName: - { - switch (value) - { + case 0x9530: + return "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT"; + case 0x9531: + return "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT"; + case 0x9580: + return "GL_TEXTURE_TILING_EXT"; case 0x9581: return "GL_DEDICATED_MEMORY_OBJECT_EXT"; + case 0x9582: + return "GL_NUM_TILING_TYPES_EXT"; + case 0x9583: + return "GL_TILING_TYPES_EXT"; + case 0x9584: + return "GL_OPTIMAL_TILING_EXT"; + case 0x9585: + return "GL_LINEAR_TILING_EXT"; + case 0x9586: + return "GL_HANDLE_TYPE_OPAQUE_FD_EXT"; + case 0x958D: + return "GL_LAYOUT_GENERAL_EXT"; + case 0x958E: + return "GL_LAYOUT_COLOR_ATTACHMENT_EXT"; + case 0x958F: + return "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT"; + case 0x9590: + return "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT"; + case 0x9591: + return "GL_LAYOUT_SHADER_READ_ONLY_EXT"; + case 0x9592: + return "GL_LAYOUT_TRANSFER_SRC_EXT"; + case 0x9593: + return "GL_LAYOUT_TRANSFER_DST_EXT"; + case 0x9596: + return "GL_NUM_DEVICE_UUIDS_EXT"; + case 0x9597: + return "GL_DEVICE_UUID_EXT"; + case 0x9598: + return "GL_DRIVER_UUID_EXT"; case 0x959B: return "GL_PROTECTED_MEMORY_OBJECT_EXT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::NormalPointerType: - { - switch (value) - { - case 0x1400: - return "GL_BYTE"; - case 0x1402: - return "GL_SHORT"; - case 0x1404: - return "GL_INT"; - case 0x1406: - return "GL_FLOAT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ObjectIdentifier: - { - switch (value) - { - case 0x1702: - return "GL_TEXTURE"; - case 0x8074: - return "GL_VERTEX_ARRAY"; - case 0x82E0: - return "GL_BUFFER"; - case 0x82E1: - return "GL_SHADER"; - case 0x82E2: - return "GL_PROGRAM"; - case 0x82E3: - return "GL_QUERY"; - case 0x82E4: - return "GL_PROGRAM_PIPELINE"; - case 0x82E6: - return "GL_SAMPLER"; - case 0x8D40: - return "GL_FRAMEBUFFER"; - case 0x8D41: - return "GL_RENDERBUFFER"; - case 0x8E22: - return "GL_TRANSFORM_FEEDBACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PatchParameterName: - { - switch (value) - { - case 0x8E72: - return "GL_PATCH_VERTICES"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PathFillMode: - { - switch (value) - { - case 0x150A: - return "GL_INVERT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PathFontStyle: - { - switch (value) - { - case 0x0: - return "GL_NONE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PathGenMode: - { - switch (value) - { - case 0x0: - return "GL_NONE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PathTransformType: - { - switch (value) - { - case 0x0: - return "GL_NONE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PipelineParameterName: - { - switch (value) - { - case 0x8259: - return "GL_ACTIVE_PROGRAM"; - case 0x8B30: - return "GL_FRAGMENT_SHADER"; - case 0x8B31: - return "GL_VERTEX_SHADER"; - case 0x8B84: - return "GL_INFO_LOG_LENGTH"; - case 0x8DD9: - return "GL_GEOMETRY_SHADER"; - case 0x8E87: - return "GL_TESS_EVALUATION_SHADER"; - case 0x8E88: - return "GL_TESS_CONTROL_SHADER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PixelCopyType: - { - switch (value) - { - case 0x1800: - return "GL_COLOR"; - case 0x1801: - return "GL_DEPTH"; - case 0x1802: - return "GL_STENCIL"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PixelFormat: - { - switch (value) - { - case 0x1403: - return "GL_UNSIGNED_SHORT"; - case 0x1405: - return "GL_UNSIGNED_INT"; - case 0x1901: - return "GL_STENCIL_INDEX"; - case 0x1902: - return "GL_DEPTH_COMPONENT"; - case 0x1903: - return "GL_RED"; - case 0x1904: - return "GL_GREEN"; - case 0x1905: - return "GL_BLUE"; - case 0x1906: - return "GL_ALPHA"; - case 0x1907: - return "GL_RGB"; - case 0x1908: - return "GL_RGBA"; - case 0x1909: - return "GL_LUMINANCE"; - case 0x190A: - return "GL_LUMINANCE_ALPHA"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PixelStoreParameter: - { - switch (value) - { - case 0xCF2: - return "GL_UNPACK_ROW_LENGTH"; - case 0xCF3: - return "GL_UNPACK_SKIP_ROWS"; - case 0xCF4: - return "GL_UNPACK_SKIP_PIXELS"; - case 0xCF5: - return "GL_UNPACK_ALIGNMENT"; - case 0xD02: - return "GL_PACK_ROW_LENGTH"; - case 0xD03: - return "GL_PACK_SKIP_ROWS"; - case 0xD04: - return "GL_PACK_SKIP_PIXELS"; - case 0xD05: - return "GL_PACK_ALIGNMENT"; - case 0x806D: - return "GL_UNPACK_SKIP_IMAGES"; - case 0x806E: - return "GL_UNPACK_IMAGE_HEIGHT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PixelTexGenMode: - { - switch (value) - { - case 0x0: - return "GL_NONE"; - case 0x1907: - return "GL_RGB"; - case 0x1908: - return "GL_RGBA"; - case 0x1909: - return "GL_LUMINANCE"; - case 0x190A: - return "GL_LUMINANCE_ALPHA"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PixelType: - { - switch (value) - { - case 0x1400: - return "GL_BYTE"; - case 0x1401: - return "GL_UNSIGNED_BYTE"; - case 0x1402: - return "GL_SHORT"; - case 0x1403: - return "GL_UNSIGNED_SHORT"; - case 0x1404: - return "GL_INT"; - case 0x1405: - return "GL_UNSIGNED_INT"; - case 0x1406: - return "GL_FLOAT"; - case 0x140B: - return "GL_HALF_FLOAT"; - case 0x8033: - return "GL_UNSIGNED_SHORT_4_4_4_4"; - case 0x8034: - return "GL_UNSIGNED_SHORT_5_5_5_1"; - case 0x8365: - return "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT"; - case 0x8366: - return "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT"; - case 0x8368: - return "GL_UNSIGNED_INT_2_10_10_10_REV"; - case 0x8C3B: - return "GL_UNSIGNED_INT_10F_11F_11F_REV"; - case 0x8D61: - return "GL_HALF_FLOAT_OES"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PrecisionType: - { - switch (value) - { - case 0x8DF0: - return "GL_LOW_FLOAT"; - case 0x8DF1: - return "GL_MEDIUM_FLOAT"; - case 0x8DF2: - return "GL_HIGH_FLOAT"; - case 0x8DF3: - return "GL_LOW_INT"; - case 0x8DF4: - return "GL_MEDIUM_INT"; - case 0x8DF5: - return "GL_HIGH_INT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::PrimitiveType: - { - switch (value) - { - case 0x0: - return "GL_POINTS"; - case 0x1: - return "GL_LINES"; - case 0x2: - return "GL_LINE_LOOP"; - case 0x3: - return "GL_LINE_STRIP"; - case 0x4: - return "GL_TRIANGLES"; - case 0x5: - return "GL_TRIANGLE_STRIP"; - case 0x6: - return "GL_TRIANGLE_FAN"; - case 0x7: - return "GL_QUADS"; - case 0xA: - return "GL_LINES_ADJACENCY"; - case 0xB: - return "GL_LINE_STRIP_ADJACENCY"; - case 0xC: - return "GL_TRIANGLES_ADJACENCY"; - case 0xD: - return "GL_TRIANGLE_STRIP_ADJACENCY"; - case 0xE: - return "GL_PATCHES"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ProgramInterface: - { - switch (value) - { - case 0x8C8E: - return "GL_TRANSFORM_FEEDBACK_BUFFER"; - case 0x92E1: - return "GL_UNIFORM"; - case 0x92E2: - return "GL_UNIFORM_BLOCK"; - case 0x92E3: - return "GL_PROGRAM_INPUT"; - case 0x92E4: - return "GL_PROGRAM_OUTPUT"; - case 0x92E5: - return "GL_BUFFER_VARIABLE"; - case 0x92E6: - return "GL_SHADER_STORAGE_BLOCK"; - case 0x92F4: - return "GL_TRANSFORM_FEEDBACK_VARYING"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ProgramInterfacePName: - { - switch (value) - { - case 0x92F5: - return "GL_ACTIVE_RESOURCES"; - case 0x92F6: - return "GL_MAX_NAME_LENGTH"; - case 0x92F7: - return "GL_MAX_NUM_ACTIVE_VARIABLES"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ProgramParameterPName: - { - switch (value) - { - case 0x8257: - return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; - case 0x8258: - return "GL_PROGRAM_SEPARABLE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ProgramPropertyARB: - { - switch (value) - { - case 0x8267: - return "GL_COMPUTE_WORK_GROUP_SIZE"; - case 0x8741: - return "GL_PROGRAM_BINARY_LENGTH"; - case 0x8916: - return "GL_GEOMETRY_VERTICES_OUT"; - case 0x8917: - return "GL_GEOMETRY_INPUT_TYPE"; - case 0x8918: - return "GL_GEOMETRY_OUTPUT_TYPE"; - case 0x8A35: - return "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"; - case 0x8A36: - return "GL_ACTIVE_UNIFORM_BLOCKS"; - case 0x8B80: - return "GL_DELETE_STATUS"; - case 0x8B82: - return "GL_LINK_STATUS"; - case 0x8B83: - return "GL_VALIDATE_STATUS"; - case 0x8B84: - return "GL_INFO_LOG_LENGTH"; - case 0x8B85: - return "GL_ATTACHED_SHADERS"; - case 0x8B86: - return "GL_ACTIVE_UNIFORMS"; - case 0x8B87: - return "GL_ACTIVE_UNIFORM_MAX_LENGTH"; - case 0x8B89: - return "GL_ACTIVE_ATTRIBUTES"; - case 0x8B8A: - return "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"; - case 0x8C76: - return "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"; - case 0x8C7F: - return "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"; - case 0x8C83: - return "GL_TRANSFORM_FEEDBACK_VARYINGS"; - case 0x92D9: - return "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::QueryObjectParameterName: - { - switch (value) - { - case 0x8866: - return "GL_QUERY_RESULT"; - case 0x8867: - return "GL_QUERY_RESULT_AVAILABLE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::QueryParameterName: - { - switch (value) - { - case 0x8865: - return "GL_CURRENT_QUERY"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::QueryTarget: - { - switch (value) - { - case 0x8C2F: - return "GL_ANY_SAMPLES_PASSED"; - case 0x8C87: - return "GL_PRIMITIVES_GENERATED"; - case 0x8C88: - return "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; - case 0x8D6A: - return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ReadBufferMode: - { - switch (value) - { - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::RenderbufferParameterName: - { - switch (value) - { - case 0x8CAB: - return "GL_RENDERBUFFER_SAMPLES"; - case 0x8D42: - return "GL_RENDERBUFFER_WIDTH"; - case 0x8D43: - return "GL_RENDERBUFFER_HEIGHT"; - case 0x8D44: - return "GL_RENDERBUFFER_INTERNAL_FORMAT"; - case 0x8D50: - return "GL_RENDERBUFFER_RED_SIZE"; - case 0x8D51: - return "GL_RENDERBUFFER_GREEN_SIZE"; - case 0x8D52: - return "GL_RENDERBUFFER_BLUE_SIZE"; - case 0x8D53: - return "GL_RENDERBUFFER_ALPHA_SIZE"; - case 0x8D54: - return "GL_RENDERBUFFER_DEPTH_SIZE"; - case 0x8D55: - return "GL_RENDERBUFFER_STENCIL_SIZE"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::RenderbufferTarget: - { - switch (value) - { - case 0x8D41: - return "GL_RENDERBUFFER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::SamplerParameterName: - { - switch (value) - { - case 0x1004: - return "GL_TEXTURE_BORDER_COLOR"; - case 0x2800: - return "GL_TEXTURE_MAG_FILTER"; - case 0x2801: - return "GL_TEXTURE_MIN_FILTER"; - case 0x2802: - return "GL_TEXTURE_WRAP_S"; - case 0x2803: - return "GL_TEXTURE_WRAP_T"; - case 0x8072: - return "GL_TEXTURE_WRAP_R"; - case 0x813A: - return "GL_TEXTURE_MIN_LOD"; - case 0x813B: - return "GL_TEXTURE_MAX_LOD"; - case 0x884C: - return "GL_TEXTURE_COMPARE_MODE"; - case 0x884D: - return "GL_TEXTURE_COMPARE_FUNC"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ShaderParameterName: - { - switch (value) - { - case 0x8B4F: - return "GL_SHADER_TYPE"; - case 0x8B80: - return "GL_DELETE_STATUS"; - case 0x8B81: - return "GL_COMPILE_STATUS"; - case 0x8B84: - return "GL_INFO_LOG_LENGTH"; - case 0x8B88: - return "GL_SHADER_SOURCE_LENGTH"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ShaderType: - { - switch (value) - { - case 0x8B30: - return "GL_FRAGMENT_SHADER"; - case 0x8B31: - return "GL_VERTEX_SHADER"; - case 0x8DD9: - return "GL_GEOMETRY_SHADER"; - case 0x8E87: - return "GL_TESS_EVALUATION_SHADER"; - case 0x8E88: - return "GL_TESS_CONTROL_SHADER"; - case 0x91B9: - return "GL_COMPUTE_SHADER"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::ShadingRate: - { - switch (value) - { + case 0x9630: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"; + case 0x9631: + return "GL_MAX_VIEWS_OVR"; + case 0x9632: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"; + case 0x9633: + return "GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR"; + case 0x969F: + return "GL_RESOURCE_INITIALIZED_ANGLE"; case 0x96A4: return "GL_SHADING_RATE_QCOM"; case 0x96A5: @@ -3688,27 +2692,14 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_SHADING_RATE_4X2_PIXELS_QCOM"; case 0x96AE: return "GL_SHADING_RATE_4X4_PIXELS_QCOM"; + case 0xFFFFFFFF: + return "GL_ALL_BARRIER_BITS"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::StencilFaceDirection: - { - switch (value) - { - case 0x404: - return "GL_FRONT"; - case 0x405: - return "GL_BACK"; - case 0x408: - return "GL_FRONT_AND_BACK"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::StencilFunction: + case GLESEnum::AlphaFunction: { switch (value) { @@ -3729,123 +2720,202 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x207: return "GL_ALWAYS"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::StencilOp: + case GLESEnum::AtomicCounterBufferPName: { switch (value) { - case 0x0: - return "GL_ZERO"; - case 0x150A: - return "GL_INVERT"; - case 0x1E00: - return "GL_KEEP"; - case 0x1E01: - return "GL_REPLACE"; - case 0x1E02: - return "GL_INCR"; - case 0x1E03: - return "GL_DECR"; + case 0x92C1: + return "GL_ATOMIC_COUNTER_BUFFER_BINDING"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::StringName: + case GLESEnum::AttribMask: { switch (value) { - case 0x1F00: - return "GL_VENDOR"; - case 0x1F01: - return "GL_RENDERER"; - case 0x1F02: - return "GL_VERSION"; - case 0x1F03: - return "GL_EXTENSIONS"; - case 0x8B8C: - return "GL_SHADING_LANGUAGE_VERSION"; + case 0x100: + return "GL_DEPTH_BUFFER_BIT"; + case 0x400: + return "GL_STENCIL_BUFFER_BIT"; + case 0x4000: + return "GL_COLOR_BUFFER_BIT"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::SubroutineParameterName: + case GLESEnum::AttributeType: { switch (value) { - case 0x8A38: - return "GL_UNIFORM_SIZE"; - case 0x8A39: - return "GL_UNIFORM_NAME_LENGTH"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::SyncCondition: + case GLESEnum::BindTransformFeedbackTarget: { switch (value) { - case 0x9117: - return "GL_SYNC_GPU_COMMANDS_COMPLETE"; + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::SyncObjectMask: - { - switch (value) - { - case 0x1: - return "GL_SYNC_FLUSH_COMMANDS_BIT"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::SyncParameterName: - { - switch (value) - { - case 0x9112: - return "GL_OBJECT_TYPE"; - case 0x9113: - return "GL_SYNC_CONDITION"; - case 0x9114: - return "GL_SYNC_STATUS"; - case 0x9115: - return "GL_SYNC_FLAGS"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::SyncStatus: - { - switch (value) - { - case 0x911A: - return "GL_ALREADY_SIGNALED"; - case 0x911B: - return "GL_TIMEOUT_EXPIRED"; - case 0x911C: - return "GL_CONDITION_SATISFIED"; - case 0x911D: - return "GL_WAIT_FAILED"; - default: - return UnknownGLenumToString(value); - } - } - - case GLenumGroup::TexCoordPointerType: + case GLESEnum::BinormalPointerTypeEXT: { switch (value) { + case 0x1400: + return "GL_BYTE"; case 0x1402: return "GL_SHORT"; case 0x1404: @@ -3853,49 +2923,71 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x1406: return "GL_FLOAT"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureEnvMode: + case GLESEnum::BlendEquationModeEXT: { switch (value) { - case 0xBE2: - return "GL_BLEND"; + case 0x8006: + return "GL_FUNC_ADD"; + case 0x8007: + return "GL_MIN"; + case 0x8008: + return "GL_MAX"; + case 0x800A: + return "GL_FUNC_SUBTRACT"; + case 0x800B: + return "GL_FUNC_REVERSE_SUBTRACT"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureLayout: + case GLESEnum::BlendingFactor: { switch (value) { - case 0x9530: - return "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT"; - case 0x9531: - return "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT"; - case 0x958D: - return "GL_LAYOUT_GENERAL_EXT"; - case 0x958E: - return "GL_LAYOUT_COLOR_ATTACHMENT_EXT"; - case 0x958F: - return "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT"; - case 0x9590: - return "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT"; - case 0x9591: - return "GL_LAYOUT_SHADER_READ_ONLY_EXT"; - case 0x9592: - return "GL_LAYOUT_TRANSFER_SRC_EXT"; - case 0x9593: - return "GL_LAYOUT_TRANSFER_DST_EXT"; + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x300: + return "GL_SRC_COLOR"; + case 0x301: + return "GL_ONE_MINUS_SRC_COLOR"; + case 0x302: + return "GL_SRC_ALPHA"; + case 0x303: + return "GL_ONE_MINUS_SRC_ALPHA"; + case 0x304: + return "GL_DST_ALPHA"; + case 0x305: + return "GL_ONE_MINUS_DST_ALPHA"; + case 0x306: + return "GL_DST_COLOR"; + case 0x307: + return "GL_ONE_MINUS_DST_COLOR"; + case 0x308: + return "GL_SRC_ALPHA_SATURATE"; + case 0x8001: + return "GL_CONSTANT_COLOR"; + case 0x8002: + return "GL_ONE_MINUS_CONSTANT_COLOR"; + case 0x8003: + return "GL_CONSTANT_ALPHA"; + case 0x8004: + return "GL_ONE_MINUS_CONSTANT_ALPHA"; + case 0x8589: + return "GL_SRC1_ALPHA"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureMagFilter: + case GLESEnum::BlitFramebufferFilter: { switch (value) { @@ -3904,91 +2996,513 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x2601: return "GL_LINEAR"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureMinFilter: + case GLESEnum::Boolean: { switch (value) { - case 0x2600: - return "GL_NEAREST"; - case 0x2601: - return "GL_LINEAR"; - case 0x2700: - return "GL_NEAREST_MIPMAP_NEAREST"; - case 0x2701: - return "GL_LINEAR_MIPMAP_NEAREST"; - case 0x2702: - return "GL_NEAREST_MIPMAP_LINEAR"; - case 0x2703: - return "GL_LINEAR_MIPMAP_LINEAR"; + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureParameterName: + case GLESEnum::Buffer: { switch (value) { - case 0x1000: - return "GL_TEXTURE_WIDTH"; - case 0x1001: - return "GL_TEXTURE_HEIGHT"; - case 0x1003: - return "GL_TEXTURE_INTERNAL_FORMAT"; - case 0x1004: - return "GL_TEXTURE_BORDER_COLOR"; - case 0x2800: - return "GL_TEXTURE_MAG_FILTER"; - case 0x2801: - return "GL_TEXTURE_MIN_FILTER"; - case 0x2802: - return "GL_TEXTURE_WRAP_S"; - case 0x2803: - return "GL_TEXTURE_WRAP_T"; - case 0x805C: - return "GL_TEXTURE_RED_SIZE"; - case 0x805D: - return "GL_TEXTURE_GREEN_SIZE"; - case 0x805E: - return "GL_TEXTURE_BLUE_SIZE"; - case 0x805F: - return "GL_TEXTURE_ALPHA_SIZE"; - case 0x8072: - return "GL_TEXTURE_WRAP_R"; - case 0x813A: - return "GL_TEXTURE_MIN_LOD"; - case 0x813B: - return "GL_TEXTURE_MAX_LOD"; - case 0x813C: - return "GL_TEXTURE_BASE_LEVEL"; - case 0x813D: - return "GL_TEXTURE_MAX_LEVEL"; - case 0x884C: - return "GL_TEXTURE_COMPARE_MODE"; - case 0x884D: - return "GL_TEXTURE_COMPARE_FUNC"; - case 0x8E42: - return "GL_TEXTURE_SWIZZLE_R"; - case 0x8E43: - return "GL_TEXTURE_SWIZZLE_G"; - case 0x8E44: - return "GL_TEXTURE_SWIZZLE_B"; - case 0x8E45: - return "GL_TEXTURE_SWIZZLE_A"; - case 0x90EA: - return "GL_DEPTH_STENCIL_TEXTURE_MODE"; - case 0x9580: - return "GL_TEXTURE_TILING_EXT"; + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureTarget: + case GLESEnum::BufferAccessARB: + { + switch (value) + { + case 0x88B8: + return "GL_READ_ONLY"; + case 0x88B9: + return "GL_WRITE_ONLY"; + case 0x88BA: + return "GL_READ_WRITE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferPNameARB: + { + switch (value) + { + case 0x8764: + return "GL_BUFFER_SIZE"; + case 0x8765: + return "GL_BUFFER_USAGE"; + case 0x88BC: + return "GL_BUFFER_MAPPED"; + case 0x911F: + return "GL_BUFFER_ACCESS_FLAGS"; + case 0x9120: + return "GL_BUFFER_MAP_LENGTH"; + case 0x9121: + return "GL_BUFFER_MAP_OFFSET"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferPointerNameARB: + { + switch (value) + { + case 0x88BD: + return "GL_BUFFER_MAP_POINTER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferStorageMask: + { + switch (value) + { + case 0x1: + return "GL_MAP_READ_BIT"; + case 0x2: + return "GL_MAP_WRITE_BIT"; + case 0x40: + return "GL_MAP_PERSISTENT_BIT_EXT"; + case 0x80: + return "GL_MAP_COHERENT_BIT_EXT"; + case 0x100: + return "GL_DYNAMIC_STORAGE_BIT_EXT"; + case 0x200: + return "GL_CLIENT_STORAGE_BIT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferStorageTarget: + { + switch (value) + { + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferTargetARB: + { + switch (value) + { + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::BufferUsageARB: + { + switch (value) + { + case 0x88E0: + return "GL_STREAM_DRAW"; + case 0x88E1: + return "GL_STREAM_READ"; + case 0x88E2: + return "GL_STREAM_COPY"; + case 0x88E4: + return "GL_STATIC_DRAW"; + case 0x88E5: + return "GL_STATIC_READ"; + case 0x88E6: + return "GL_STATIC_COPY"; + case 0x88E8: + return "GL_DYNAMIC_DRAW"; + case 0x88E9: + return "GL_DYNAMIC_READ"; + case 0x88EA: + return "GL_DYNAMIC_COPY"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CheckFramebufferStatusTarget: + { + switch (value) + { + case 0x8CA8: + return "GL_READ_FRAMEBUFFER"; + case 0x8CA9: + return "GL_DRAW_FRAMEBUFFER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ClampColorModeARB: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ClearBufferMask: + { + switch (value) + { + case 0x100: + return "GL_DEPTH_BUFFER_BIT"; + case 0x400: + return "GL_STENCIL_BUFFER_BIT"; + case 0x4000: + return "GL_COLOR_BUFFER_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ClipPlaneName: + { + switch (value) + { + case 0x3000: + return "GL_CLIP_PLANE0"; + case 0x3001: + return "GL_CLIP_PLANE1"; + case 0x3002: + return "GL_CLIP_PLANE2"; + case 0x3003: + return "GL_CLIP_PLANE3"; + case 0x3004: + return "GL_CLIP_PLANE4"; + case 0x3005: + return "GL_CLIP_PLANE5"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ColorBuffer: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ColorMaterialFace: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ColorMaterialParameter: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1600: + return "GL_EMISSION"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ColorPointerType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CombinerBiasNV: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CombinerComponentUsageNV: + { + switch (value) + { + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CombinerPortionNV: + { + switch (value) + { + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CombinerScaleNV: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ContainerType: + { + switch (value) + { + case 0x8B40: + return "GL_PROGRAM_OBJECT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ContextFlagMask: + { + switch (value) + { + case 0x2: + return "GL_CONTEXT_FLAG_DEBUG_BIT"; + case 0x4: + return "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"; + case 0x8: + return "GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR"; + case 0x10: + return "GL_CONTEXT_FLAG_PROTECTED_CONTENT_BIT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CopyBufferSubDataTarget: + { + switch (value) + { + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::CopyImageSubDataTarget: { switch (value) { @@ -3998,20 +3512,10 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) return "GL_TEXTURE_3D"; case 0x8513: return "GL_TEXTURE_CUBE_MAP"; - case 0x8515: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; - case 0x8516: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; - case 0x8517: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; - case 0x8518: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; - case 0x8519: - return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; - case 0x851A: - return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; case 0x8C1A: return "GL_TEXTURE_2D_ARRAY"; + case 0x8D41: + return "GL_RENDERBUFFER"; case 0x9009: return "GL_TEXTURE_CUBE_MAP_ARRAY"; case 0x9100: @@ -4019,11 +3523,559 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x9102: return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureUnit: + case GLESEnum::CullFaceMode: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DebugSeverity: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x826B: + return "GL_DEBUG_SEVERITY_NOTIFICATION"; + case 0x9146: + return "GL_DEBUG_SEVERITY_HIGH"; + case 0x9147: + return "GL_DEBUG_SEVERITY_MEDIUM"; + case 0x9148: + return "GL_DEBUG_SEVERITY_LOW"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DebugSource: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x8246: + return "GL_DEBUG_SOURCE_API"; + case 0x8247: + return "GL_DEBUG_SOURCE_WINDOW_SYSTEM"; + case 0x8248: + return "GL_DEBUG_SOURCE_SHADER_COMPILER"; + case 0x8249: + return "GL_DEBUG_SOURCE_THIRD_PARTY"; + case 0x824A: + return "GL_DEBUG_SOURCE_APPLICATION"; + case 0x824B: + return "GL_DEBUG_SOURCE_OTHER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DebugType: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x824C: + return "GL_DEBUG_TYPE_ERROR"; + case 0x824D: + return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"; + case 0x824E: + return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"; + case 0x824F: + return "GL_DEBUG_TYPE_PORTABILITY"; + case 0x8250: + return "GL_DEBUG_TYPE_PERFORMANCE"; + case 0x8251: + return "GL_DEBUG_TYPE_OTHER"; + case 0x8268: + return "GL_DEBUG_TYPE_MARKER"; + case 0x8269: + return "GL_DEBUG_TYPE_PUSH_GROUP"; + case 0x826A: + return "GL_DEBUG_TYPE_POP_GROUP"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DepthFunction: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DepthStencilTextureMode: + { + switch (value) + { + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DrawBufferMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::DrawElementsType: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ElementPointerTypeATI: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::EnableCap: + { + switch (value) + { + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x3000: + return "GL_CLIP_PLANE0"; + case 0x3001: + return "GL_CLIP_PLANE1"; + case 0x3002: + return "GL_CLIP_PLANE2"; + case 0x3003: + return "GL_CLIP_PLANE3"; + case 0x3004: + return "GL_CLIP_PLANE4"; + case 0x3005: + return "GL_CLIP_PLANE5"; + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x809D: + return "GL_MULTISAMPLE"; + case 0x809E: + return "GL_SAMPLE_ALPHA_TO_COVERAGE"; + case 0x809F: + return "GL_SAMPLE_ALPHA_TO_ONE"; + case 0x80A0: + return "GL_SAMPLE_COVERAGE"; + case 0x8242: + return "GL_DEBUG_OUTPUT_SYNCHRONOUS"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8C36: + return "GL_SAMPLE_SHADING"; + case 0x8C89: + return "GL_RASTERIZER_DISCARD"; + case 0x8D60: + return "GL_TEXTURE_GEN_STR_OES"; + case 0x8D69: + return "GL_PRIMITIVE_RESTART_FIXED_INDEX"; + case 0x8E51: + return "GL_SAMPLE_MASK"; + case 0x92E0: + return "GL_DEBUG_OUTPUT"; + case 0x96A5: + return "GL_SHADING_RATE_PRESERVE_ASPECT_RATIO_QCOM"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ErrorCode: + { + switch (value) + { + case 0x0: + return "GL_NO_ERROR"; + case 0x500: + return "GL_INVALID_ENUM"; + case 0x501: + return "GL_INVALID_VALUE"; + case 0x502: + return "GL_INVALID_OPERATION"; + case 0x503: + return "GL_STACK_OVERFLOW"; + case 0x504: + return "GL_STACK_UNDERFLOW"; + case 0x505: + return "GL_OUT_OF_MEMORY"; + case 0x506: + return "GL_INVALID_FRAMEBUFFER_OPERATION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ExternalHandleType: + { + switch (value) + { + case 0x9586: + return "GL_HANDLE_TYPE_OPAQUE_FD_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FenceConditionNV: + { + switch (value) + { + case 0x84F2: + return "GL_ALL_COMPLETED_NV"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FenceParameterNameNV: + { + switch (value) + { + case 0x84F3: + return "GL_FENCE_STATUS_NV"; + case 0x84F4: + return "GL_FENCE_CONDITION_NV"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogCoordinatePointerType: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogMode: + { + switch (value) + { + case 0x800: + return "GL_EXP"; + case 0x801: + return "GL_EXP2"; + case 0x2601: + return "GL_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogPName: + { + switch (value) + { + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogParameter: + { + switch (value) + { + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogPointerTypeEXT: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FogPointerTypeIBM: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FragmentLightParameterSGIX: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FragmentShaderDestMaskATI: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FragmentShaderDestModMaskATI: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FragmentShaderGenericSourceATI: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FragmentShaderTextureSourceATI: { switch (value) { @@ -4092,26 +4144,3615 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x84DF: return "GL_TEXTURE31"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TextureWrapMode: + case GLESEnum::FragmentShaderValueRepATI: { switch (value) { + case 0x0: + return "GL_NONE"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FramebufferAttachment: + { + switch (value) + { + case 0x821A: + return "GL_DEPTH_STENCIL_ATTACHMENT"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + case 0x8D00: + return "GL_DEPTH_ATTACHMENT"; + case 0x8D20: + return "GL_STENCIL_ATTACHMENT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FramebufferAttachmentParameterName: + { + switch (value) + { + case 0x8210: + return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; + case 0x8211: + return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; + case 0x8212: + return "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"; + case 0x8213: + return "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; + case 0x8214: + return "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; + case 0x8215: + return "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; + case 0x8216: + return "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; + case 0x8217: + return "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; + case 0x8CD0: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; + case 0x8CD1: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; + case 0x8CD2: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; + case 0x8CD3: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; + case 0x8CD4: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES"; + case 0x8D6C: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT"; + case 0x8DA7: + return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"; + case 0x9630: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"; + case 0x9632: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FramebufferParameterName: + { + switch (value) + { + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FramebufferStatus: + { + switch (value) + { + case 0x8219: + return "GL_FRAMEBUFFER_UNDEFINED"; + case 0x8CD5: + return "GL_FRAMEBUFFER_COMPLETE"; + case 0x8CD6: + return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; + case 0x8CD7: + return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; + case 0x8CDD: + return "GL_FRAMEBUFFER_UNSUPPORTED"; + case 0x8D56: + return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; + case 0x8DA8: + return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FramebufferTarget: + { + switch (value) + { + case 0x8CA8: + return "GL_READ_FRAMEBUFFER"; + case 0x8CA9: + return "GL_DRAW_FRAMEBUFFER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::FrontFaceDirection: + { + switch (value) + { + case 0x900: + return "GL_CW"; + case 0x901: + return "GL_CCW"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GetFramebufferParameter: + { + switch (value) + { + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GetMultisamplePNameNV: + { + switch (value) + { + case 0x8E50: + return "GL_SAMPLE_POSITION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GetPName: + { + switch (value) + { + case 0xB00: + return "GL_CURRENT_COLOR"; + case 0xB02: + return "GL_CURRENT_NORMAL"; + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB11: + return "GL_POINT_SIZE"; + case 0xB12: + return "GL_SMOOTH_POINT_SIZE_RANGE"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB21: + return "GL_LINE_WIDTH"; + case 0xB22: + return "GL_SMOOTH_LINE_WIDTH_RANGE"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB45: + return "GL_CULL_FACE_MODE"; + case 0xB46: + return "GL_FRONT_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + case 0xB54: + return "GL_SHADE_MODEL"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + case 0xB70: + return "GL_DEPTH_RANGE"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB72: + return "GL_DEPTH_WRITEMASK"; + case 0xB73: + return "GL_DEPTH_CLEAR_VALUE"; + case 0xB74: + return "GL_DEPTH_FUNC"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xB91: + return "GL_STENCIL_CLEAR_VALUE"; + case 0xB92: + return "GL_STENCIL_FUNC"; + case 0xB93: + return "GL_STENCIL_VALUE_MASK"; + case 0xB94: + return "GL_STENCIL_FAIL"; + case 0xB95: + return "GL_STENCIL_PASS_DEPTH_FAIL"; + case 0xB96: + return "GL_STENCIL_PASS_DEPTH_PASS"; + case 0xB97: + return "GL_STENCIL_REF"; + case 0xB98: + return "GL_STENCIL_WRITEMASK"; + case 0xBA0: + return "GL_MATRIX_MODE"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBA2: + return "GL_VIEWPORT"; + case 0xBA3: + return "GL_MODELVIEW_STACK_DEPTH"; + case 0xBA4: + return "GL_PROJECTION_STACK_DEPTH"; + case 0xBA5: + return "GL_TEXTURE_STACK_DEPTH"; + case 0xBA6: + return "GL_MODELVIEW_MATRIX"; + case 0xBA7: + return "GL_PROJECTION_MATRIX"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBC1: + return "GL_ALPHA_TEST_FUNC"; + case 0xBC2: + return "GL_ALPHA_TEST_REF"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE0: + return "GL_BLEND_DST"; + case 0xBE1: + return "GL_BLEND_SRC"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF0: + return "GL_LOGIC_OP_MODE"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC02: + return "GL_READ_BUFFER"; + case 0xC10: + return "GL_SCISSOR_BOX"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xC22: + return "GL_COLOR_CLEAR_VALUE"; + case 0xC23: + return "GL_COLOR_WRITEMASK"; + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0xD1C: + return "GL_ALPHA_SCALE"; + case 0xD31: + return "GL_MAX_LIGHTS"; + case 0xD32: + return "GL_MAX_CLIP_PLANES"; + case 0xD33: + return "GL_MAX_TEXTURE_SIZE"; + case 0xD36: + return "GL_MAX_MODELVIEW_STACK_DEPTH"; + case 0xD38: + return "GL_MAX_PROJECTION_STACK_DEPTH"; + case 0xD39: + return "GL_MAX_TEXTURE_STACK_DEPTH"; + case 0xD3A: + return "GL_MAX_VIEWPORT_DIMS"; + case 0xD50: + return "GL_SUBPIXEL_BITS"; + case 0xD52: + return "GL_RED_BITS"; + case 0xD53: + return "GL_GREEN_BITS"; + case 0xD54: + return "GL_BLUE_BITS"; + case 0xD55: + return "GL_ALPHA_BITS"; + case 0xD56: + return "GL_DEPTH_BITS"; + case 0xD57: + return "GL_STENCIL_BITS"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x2A00: + return "GL_POLYGON_OFFSET_UNITS"; + case 0x3000: + return "GL_CLIP_PLANE0"; + case 0x3001: + return "GL_CLIP_PLANE1"; + case 0x3002: + return "GL_CLIP_PLANE2"; + case 0x3003: + return "GL_CLIP_PLANE3"; + case 0x3004: + return "GL_CLIP_PLANE4"; + case 0x3005: + return "GL_CLIP_PLANE5"; + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8005: + return "GL_BLEND_COLOR"; + case 0x8009: + return "GL_BLEND_EQUATION"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8038: + return "GL_POLYGON_OFFSET_FACTOR"; + case 0x8069: + return "GL_TEXTURE_BINDING_2D"; + case 0x806A: + return "GL_TEXTURE_BINDING_3D"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + case 0x8073: + return "GL_MAX_3D_TEXTURE_SIZE"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x807A: + return "GL_VERTEX_ARRAY_SIZE"; + case 0x807B: + return "GL_VERTEX_ARRAY_TYPE"; + case 0x807C: + return "GL_VERTEX_ARRAY_STRIDE"; + case 0x807E: + return "GL_NORMAL_ARRAY_TYPE"; + case 0x807F: + return "GL_NORMAL_ARRAY_STRIDE"; + case 0x8081: + return "GL_COLOR_ARRAY_SIZE"; + case 0x8082: + return "GL_COLOR_ARRAY_TYPE"; + case 0x8083: + return "GL_COLOR_ARRAY_STRIDE"; + case 0x8088: + return "GL_TEXTURE_COORD_ARRAY_SIZE"; + case 0x8089: + return "GL_TEXTURE_COORD_ARRAY_TYPE"; + case 0x808A: + return "GL_TEXTURE_COORD_ARRAY_STRIDE"; + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; + case 0x80AA: + return "GL_SAMPLE_COVERAGE_VALUE"; + case 0x80AB: + return "GL_SAMPLE_COVERAGE_INVERT"; + case 0x80C8: + return "GL_BLEND_DST_RGB"; + case 0x80C9: + return "GL_BLEND_SRC_RGB"; + case 0x80CA: + return "GL_BLEND_DST_ALPHA"; + case 0x80CB: + return "GL_BLEND_SRC_ALPHA"; + case 0x80E8: + return "GL_MAX_ELEMENTS_VERTICES"; + case 0x80E9: + return "GL_MAX_ELEMENTS_INDICES"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x821B: + return "GL_MAJOR_VERSION"; + case 0x821C: + return "GL_MINOR_VERSION"; + case 0x821D: + return "GL_NUM_EXTENSIONS"; + case 0x821E: + return "GL_CONTEXT_FLAGS"; + case 0x825A: + return "GL_PROGRAM_PIPELINE_BINDING"; + case 0x825E: + return "GL_LAYER_PROVOKING_VERTEX"; + case 0x8263: + return "GL_MAX_COMPUTE_UNIFORM_COMPONENTS"; + case 0x8264: + return "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS"; + case 0x8265: + return "GL_MAX_COMPUTE_ATOMIC_COUNTERS"; + case 0x8266: + return "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS"; + case 0x826C: + return "GL_MAX_DEBUG_GROUP_STACK_DEPTH"; + case 0x826D: + return "GL_DEBUG_GROUP_STACK_DEPTH"; + case 0x826E: + return "GL_MAX_UNIFORM_LOCATIONS"; + case 0x82D6: + return "GL_VERTEX_BINDING_DIVISOR"; + case 0x82D7: + return "GL_VERTEX_BINDING_OFFSET"; + case 0x82D8: + return "GL_VERTEX_BINDING_STRIDE"; + case 0x82D9: + return "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x82DA: + return "GL_MAX_VERTEX_ATTRIB_BINDINGS"; + case 0x82E8: + return "GL_MAX_LABEL_LENGTH"; + case 0x846D: + return "GL_ALIASED_POINT_SIZE_RANGE"; + case 0x846E: + return "GL_ALIASED_LINE_WIDTH_RANGE"; + case 0x84E0: + return "GL_ACTIVE_TEXTURE"; + case 0x84E8: + return "GL_MAX_RENDERBUFFER_SIZE"; + case 0x84FD: + return "GL_MAX_TEXTURE_LOD_BIAS"; + case 0x8514: + return "GL_TEXTURE_BINDING_CUBE_MAP"; + case 0x851C: + return "GL_MAX_CUBE_MAP_TEXTURE_SIZE"; + case 0x85B5: + return "GL_VERTEX_ARRAY_BINDING"; + case 0x86A2: + return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; + case 0x86A3: + return "GL_COMPRESSED_TEXTURE_FORMATS"; + case 0x87FE: + return "GL_NUM_PROGRAM_BINARY_FORMATS"; + case 0x87FF: + return "GL_PROGRAM_BINARY_FORMATS"; + case 0x8800: + return "GL_STENCIL_BACK_FUNC"; + case 0x8801: + return "GL_STENCIL_BACK_FAIL"; + case 0x8802: + return "GL_STENCIL_BACK_PASS_DEPTH_FAIL"; + case 0x8803: + return "GL_STENCIL_BACK_PASS_DEPTH_PASS"; + case 0x8824: + return "GL_MAX_DRAW_BUFFERS"; + case 0x883D: + return "GL_BLEND_EQUATION_ALPHA"; + case 0x8869: + return "GL_MAX_VERTEX_ATTRIBS"; + case 0x8872: + return "GL_MAX_TEXTURE_IMAGE_UNITS"; + case 0x8894: + return "GL_ARRAY_BUFFER_BINDING"; + case 0x8895: + return "GL_ELEMENT_ARRAY_BUFFER_BINDING"; + case 0x88ED: + return "GL_PIXEL_PACK_BUFFER_BINDING"; + case 0x88EF: + return "GL_PIXEL_UNPACK_BUFFER_BINDING"; + case 0x88FF: + return "GL_MAX_ARRAY_TEXTURE_LAYERS"; + case 0x8904: + return "GL_MIN_PROGRAM_TEXEL_OFFSET"; + case 0x8905: + return "GL_MAX_PROGRAM_TEXEL_OFFSET"; + case 0x8919: + return "GL_SAMPLER_BINDING"; + case 0x8A28: + return "GL_UNIFORM_BUFFER_BINDING"; + case 0x8A29: + return "GL_UNIFORM_BUFFER_START"; + case 0x8A2A: + return "GL_UNIFORM_BUFFER_SIZE"; + case 0x8A2B: + return "GL_MAX_VERTEX_UNIFORM_BLOCKS"; + case 0x8A2C: + return "GL_MAX_GEOMETRY_UNIFORM_BLOCKS"; + case 0x8A2D: + return "GL_MAX_FRAGMENT_UNIFORM_BLOCKS"; + case 0x8A2E: + return "GL_MAX_COMBINED_UNIFORM_BLOCKS"; + case 0x8A2F: + return "GL_MAX_UNIFORM_BUFFER_BINDINGS"; + case 0x8A30: + return "GL_MAX_UNIFORM_BLOCK_SIZE"; + case 0x8A31: + return "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"; + case 0x8A32: + return "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8A33: + return "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8A34: + return "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT"; + case 0x8B49: + return "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8B4A: + return "GL_MAX_VERTEX_UNIFORM_COMPONENTS"; + case 0x8B4B: + return "GL_MAX_VARYING_COMPONENTS"; + case 0x8B4C: + return "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"; + case 0x8B4D: + return "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + case 0x8B8D: + return "GL_CURRENT_PROGRAM"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; + case 0x8C1D: + return "GL_TEXTURE_BINDING_2D_ARRAY"; + case 0x8C29: + return "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS"; + case 0x8C2B: + return "GL_MAX_TEXTURE_BUFFER_SIZE"; + case 0x8C2C: + return "GL_TEXTURE_BINDING_BUFFER"; + case 0x8C84: + return "GL_TRANSFORM_FEEDBACK_BUFFER_START"; + case 0x8C85: + return "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"; + case 0x8C8F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"; + case 0x8CA3: + return "GL_STENCIL_BACK_REF"; + case 0x8CA4: + return "GL_STENCIL_BACK_VALUE_MASK"; + case 0x8CA5: + return "GL_STENCIL_BACK_WRITEMASK"; + case 0x8CA6: + return "GL_DRAW_FRAMEBUFFER_BINDING"; + case 0x8CA7: + return "GL_RENDERBUFFER_BINDING"; + case 0x8CAA: + return "GL_READ_FRAMEBUFFER_BINDING"; + case 0x8CDF: + return "GL_MAX_COLOR_ATTACHMENTS"; + case 0x8D60: + return "GL_TEXTURE_GEN_STR_OES"; + case 0x8D6B: + return "GL_MAX_ELEMENT_INDEX"; + case 0x8DDF: + return "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8DF8: + return "GL_SHADER_BINARY_FORMATS"; + case 0x8DF9: + return "GL_NUM_SHADER_BINARY_FORMATS"; + case 0x8DFA: + return "GL_SHADER_COMPILER"; + case 0x8DFB: + return "GL_MAX_VERTEX_UNIFORM_VECTORS"; + case 0x8DFC: + return "GL_MAX_VARYING_VECTORS"; + case 0x8DFD: + return "GL_MAX_FRAGMENT_UNIFORM_VECTORS"; + case 0x8E28: + return "GL_TIMESTAMP_EXT"; + case 0x8E4F: + return "GL_PROVOKING_VERTEX"; + case 0x8E59: + return "GL_MAX_SAMPLE_MASK_WORDS"; + case 0x8E89: + return "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"; + case 0x8E8A: + return "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"; + case 0x90D3: + return "GL_SHADER_STORAGE_BUFFER_BINDING"; + case 0x90D4: + return "GL_SHADER_STORAGE_BUFFER_START"; + case 0x90D5: + return "GL_SHADER_STORAGE_BUFFER_SIZE"; + case 0x90D6: + return "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"; + case 0x90D7: + return "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"; + case 0x90D8: + return "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"; + case 0x90D9: + return "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"; + case 0x90DA: + return "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; + case 0x90DB: + return "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"; + case 0x90DC: + return "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"; + case 0x90DD: + return "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"; + case 0x90DF: + return "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"; + case 0x90EB: + return "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"; + case 0x90EF: + return "GL_DISPATCH_INDIRECT_BUFFER_BINDING"; + case 0x9104: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE"; + case 0x9105: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"; + case 0x910E: + return "GL_MAX_COLOR_TEXTURE_SAMPLES"; + case 0x910F: + return "GL_MAX_DEPTH_TEXTURE_SAMPLES"; + case 0x9110: + return "GL_MAX_INTEGER_SAMPLES"; + case 0x9111: + return "GL_MAX_SERVER_WAIT_TIMEOUT"; + case 0x9122: + return "GL_MAX_VERTEX_OUTPUT_COMPONENTS"; + case 0x9123: + return "GL_MAX_GEOMETRY_INPUT_COMPONENTS"; + case 0x9124: + return "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"; + case 0x9125: + return "GL_MAX_FRAGMENT_INPUT_COMPONENTS"; + case 0x919F: + return "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"; + case 0x91BB: + return "GL_MAX_COMPUTE_UNIFORM_BLOCKS"; + case 0x91BC: + return "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"; + case 0x91BE: + return "GL_MAX_COMPUTE_WORK_GROUP_COUNT"; + case 0x91BF: + return "GL_MAX_COMPUTE_WORK_GROUP_SIZE"; + case 0x92D2: + return "GL_MAX_VERTEX_ATOMIC_COUNTERS"; + case 0x92D3: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"; + case 0x92D4: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"; + case 0x92D5: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"; + case 0x92D6: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"; + case 0x92D7: + return "GL_MAX_COMBINED_ATOMIC_COUNTERS"; + case 0x9315: + return "GL_MAX_FRAMEBUFFER_WIDTH"; + case 0x9316: + return "GL_MAX_FRAMEBUFFER_HEIGHT"; + case 0x9317: + return "GL_MAX_FRAMEBUFFER_LAYERS"; + case 0x9318: + return "GL_MAX_FRAMEBUFFER_SAMPLES"; + case 0x9596: + return "GL_NUM_DEVICE_UUIDS_EXT"; + case 0x9597: + return "GL_DEVICE_UUID_EXT"; + case 0x9598: + return "GL_DRIVER_UUID_EXT"; + case 0x96A4: + return "GL_SHADING_RATE_QCOM"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GetPointervPName: + { + switch (value) + { + case 0x808E: + return "GL_VERTEX_ARRAY_POINTER"; + case 0x808F: + return "GL_NORMAL_ARRAY_POINTER"; + case 0x8090: + return "GL_COLOR_ARRAY_POINTER"; + case 0x8092: + return "GL_TEXTURE_COORD_ARRAY_POINTER"; + case 0x8244: + return "GL_DEBUG_CALLBACK_FUNCTION"; + case 0x8245: + return "GL_DEBUG_CALLBACK_USER_PARAM"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GetTextureParameter: + { + switch (value) + { + case 0x1000: + return "GL_TEXTURE_WIDTH"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_INTERNAL_FORMAT"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8511: + return "GL_NORMAL_MAP_OES"; + case 0x8512: + return "GL_REFLECTION_MAP_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GlslTypeToken: + { + switch (value) + { + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x92DB: + return "GL_UNSIGNED_INT_ATOMIC_COUNTER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::GraphicsResetStatus: + { + switch (value) + { + case 0x0: + return "GL_NO_ERROR"; + case 0x8253: + return "GL_GUILTY_CONTEXT_RESET"; + case 0x8254: + return "GL_INNOCENT_CONTEXT_RESET"; + case 0x8255: + return "GL_UNKNOWN_CONTEXT_RESET"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::HintMode: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x1101: + return "GL_FASTEST"; + case 0x1102: + return "GL_NICEST"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::HintTarget: + { + switch (value) + { + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0x8192: + return "GL_GENERATE_MIPMAP_HINT"; + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::IndexFunctionEXT: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::IndexPointerType: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::InternalFormat: + { + switch (value) + { + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x803C: + return "GL_ALPHA8_EXT"; + case 0x8040: + return "GL_LUMINANCE8_EXT"; + case 0x8045: + return "GL_LUMINANCE8_ALPHA8_EXT"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10_EXT"; + case 0x8054: + return "GL_RGB16_EXT"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805B: + return "GL_RGBA16_EXT"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; + case 0x81A6: + return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32_OES"; + case 0x8227: + return "GL_RG"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16_EXT"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16_EXT"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; + case 0x8814: + return "GL_RGBA32F"; + case 0x8815: + return "GL_RGB32F"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3D: + return "GL_RGB9_E5"; + case 0x8C40: + return "GL_SRGB"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C42: + return "GL_SRGB_ALPHA_EXT"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8C4C: + return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT"; + case 0x8C4D: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; + case 0x8C4E: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; + case 0x8C4F: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D62: + return "GL_RGB565"; + case 0x8D64: + return "GL_ETC1_RGB8_OES"; + case 0x8D70: + return "GL_RGBA32UI"; + case 0x8D71: + return "GL_RGB32UI"; + case 0x8D76: + return "GL_RGBA16UI"; + case 0x8D77: + return "GL_RGB16UI"; + case 0x8D7C: + return "GL_RGBA8UI"; + case 0x8D7D: + return "GL_RGB8UI"; + case 0x8D82: + return "GL_RGBA32I"; + case 0x8D83: + return "GL_RGB32I"; + case 0x8D88: + return "GL_RGBA16I"; + case 0x8D89: + return "GL_RGB16I"; + case 0x8D8E: + return "GL_RGBA8I"; + case 0x8D8F: + return "GL_RGB8I"; + case 0x8DBB: + return "GL_COMPRESSED_RED_RGTC1_EXT"; + case 0x8DBC: + return "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT"; + case 0x8DBD: + return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; + case 0x8DBE: + return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8E8C: + return "GL_COMPRESSED_RGBA_BPTC_UNORM_EXT"; + case 0x8E8D: + return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"; + case 0x8E8E: + return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"; + case 0x8E8F: + return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"; + case 0x8F94: + return "GL_R8_SNORM"; + case 0x8F95: + return "GL_RG8_SNORM"; + case 0x8F96: + return "GL_RGB8_SNORM"; + case 0x8F97: + return "GL_RGBA8_SNORM"; + case 0x8F98: + return "GL_R16_SNORM_EXT"; + case 0x8F99: + return "GL_RG16_SNORM_EXT"; + case 0x8F9A: + return "GL_RGB16_SNORM_EXT"; + case 0x8F9B: + return "GL_RGBA16_SNORM_EXT"; + case 0x8FBD: + return "GL_SR8_EXT"; + case 0x8FBE: + return "GL_SRG8_EXT"; + case 0x906F: + return "GL_RGB10_A2UI"; + case 0x9270: + return "GL_COMPRESSED_R11_EAC"; + case 0x9271: + return "GL_COMPRESSED_SIGNED_R11_EAC"; + case 0x9272: + return "GL_COMPRESSED_RG11_EAC"; + case 0x9273: + return "GL_COMPRESSED_SIGNED_RG11_EAC"; + case 0x9274: + return "GL_COMPRESSED_RGB8_ETC2"; + case 0x9275: + return "GL_COMPRESSED_SRGB8_ETC2"; + case 0x9276: + return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9277: + return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9278: + return "GL_COMPRESSED_RGBA8_ETC2_EAC"; + case 0x9279: + return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x93B0: + return "GL_COMPRESSED_RGBA_ASTC_4x4"; + case 0x93B1: + return "GL_COMPRESSED_RGBA_ASTC_5x4"; + case 0x93B2: + return "GL_COMPRESSED_RGBA_ASTC_5x5"; + case 0x93B3: + return "GL_COMPRESSED_RGBA_ASTC_6x5"; + case 0x93B4: + return "GL_COMPRESSED_RGBA_ASTC_6x6"; + case 0x93B5: + return "GL_COMPRESSED_RGBA_ASTC_8x5"; + case 0x93B6: + return "GL_COMPRESSED_RGBA_ASTC_8x6"; + case 0x93B7: + return "GL_COMPRESSED_RGBA_ASTC_8x8"; + case 0x93B8: + return "GL_COMPRESSED_RGBA_ASTC_10x5"; + case 0x93B9: + return "GL_COMPRESSED_RGBA_ASTC_10x6"; + case 0x93BA: + return "GL_COMPRESSED_RGBA_ASTC_10x8"; + case 0x93BB: + return "GL_COMPRESSED_RGBA_ASTC_10x10"; + case 0x93BC: + return "GL_COMPRESSED_RGBA_ASTC_12x10"; + case 0x93BD: + return "GL_COMPRESSED_RGBA_ASTC_12x12"; + case 0x93C0: + return "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES"; + case 0x93C1: + return "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES"; + case 0x93C2: + return "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES"; + case 0x93C3: + return "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES"; + case 0x93C4: + return "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES"; + case 0x93C5: + return "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES"; + case 0x93C6: + return "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES"; + case 0x93C7: + return "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES"; + case 0x93C8: + return "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES"; + case 0x93C9: + return "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES"; + case 0x93D0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4"; + case 0x93D1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4"; + case 0x93D2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5"; + case 0x93D3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5"; + case 0x93D4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6"; + case 0x93D5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5"; + case 0x93D6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6"; + case 0x93D7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8"; + case 0x93D8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5"; + case 0x93D9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6"; + case 0x93DA: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8"; + case 0x93DB: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10"; + case 0x93DC: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10"; + case 0x93DD: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12"; + case 0x93E0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES"; + case 0x93E1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES"; + case 0x93E2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES"; + case 0x93E3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES"; + case 0x93E4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES"; + case 0x93E5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES"; + case 0x93E6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES"; + case 0x93E7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES"; + case 0x93E8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES"; + case 0x93E9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::InternalFormatPName: + { + switch (value) + { + case 0x80A9: + return "GL_SAMPLES"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x86A1: + return "GL_TEXTURE_COMPRESSED"; + case 0x90C7: + return "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"; + case 0x9380: + return "GL_NUM_SAMPLE_COUNTS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::InvalidateFramebufferAttachment: + { + switch (value) + { + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + case 0x821A: + return "GL_DEPTH_STENCIL_ATTACHMENT"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + case 0x8D00: + return "GL_DEPTH_ATTACHMENT"; + case 0x8D20: + return "GL_STENCIL_ATTACHMENT_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::LightEnvModeSGIX: + { + switch (value) + { + case 0x104: + return "GL_ADD"; + case 0x1E01: + return "GL_REPLACE"; + case 0x2100: + return "GL_MODULATE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::LightModelParameter: + { + switch (value) + { + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::LightName: + { + switch (value) + { + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::LightParameter: + { + switch (value) + { + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ListNameType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::LogicOp: + { + switch (value) + { + case 0x1500: + return "GL_CLEAR"; + case 0x1501: + return "GL_AND"; + case 0x1502: + return "GL_AND_REVERSE"; + case 0x1503: + return "GL_COPY"; + case 0x1504: + return "GL_AND_INVERTED"; + case 0x1505: + return "GL_NOOP"; + case 0x1506: + return "GL_XOR"; + case 0x1507: + return "GL_OR"; + case 0x1508: + return "GL_NOR"; + case 0x1509: + return "GL_EQUIV"; + case 0x150A: + return "GL_INVERT"; + case 0x150B: + return "GL_OR_REVERSE"; + case 0x150C: + return "GL_COPY_INVERTED"; + case 0x150D: + return "GL_OR_INVERTED"; + case 0x150E: + return "GL_NAND"; + case 0x150F: + return "GL_SET"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MapBufferAccessMask: + { + switch (value) + { + case 0x1: + return "GL_MAP_READ_BIT"; + case 0x2: + return "GL_MAP_WRITE_BIT"; + case 0x4: + return "GL_MAP_INVALIDATE_RANGE_BIT"; + case 0x8: + return "GL_MAP_INVALIDATE_BUFFER_BIT"; + case 0x10: + return "GL_MAP_FLUSH_EXPLICIT_BIT"; + case 0x20: + return "GL_MAP_UNSYNCHRONIZED_BIT"; + case 0x40: + return "GL_MAP_PERSISTENT_BIT_EXT"; + case 0x80: + return "GL_MAP_COHERENT_BIT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MapTypeNV: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MaterialFace: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MaterialParameter: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1600: + return "GL_EMISSION"; + case 0x1601: + return "GL_SHININESS"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MatrixIndexPointerTypeARB: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MatrixMode: + { + switch (value) + { + case 0x1700: + return "GL_MODELVIEW"; + case 0x1701: + return "GL_PROJECTION"; + case 0x1702: + return "GL_TEXTURE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MemoryBarrierMask: + { + switch (value) + { + case 0x1: + return "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT"; + case 0x2: + return "GL_ELEMENT_ARRAY_BARRIER_BIT"; + case 0x4: + return "GL_UNIFORM_BARRIER_BIT"; + case 0x8: + return "GL_TEXTURE_FETCH_BARRIER_BIT"; + case 0x20: + return "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT"; + case 0x40: + return "GL_COMMAND_BARRIER_BIT"; + case 0x80: + return "GL_PIXEL_BUFFER_BARRIER_BIT"; + case 0x100: + return "GL_TEXTURE_UPDATE_BARRIER_BIT"; + case 0x200: + return "GL_BUFFER_UPDATE_BARRIER_BIT"; + case 0x400: + return "GL_FRAMEBUFFER_BARRIER_BIT"; + case 0x800: + return "GL_TRANSFORM_FEEDBACK_BARRIER_BIT"; + case 0x1000: + return "GL_ATOMIC_COUNTER_BARRIER_BIT"; + case 0x2000: + return "GL_SHADER_STORAGE_BARRIER_BIT"; + case 0x4000: + return "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT_EXT"; + case 0xFFFFFFFF: + return "GL_ALL_BARRIER_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::MemoryObjectParameterName: + { + switch (value) + { + case 0x9581: + return "GL_DEDICATED_MEMORY_OBJECT_EXT"; + case 0x959B: + return "GL_PROTECTED_MEMORY_OBJECT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::NormalPointerType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ObjectIdentifier: + { + switch (value) + { + case 0x1702: + return "GL_TEXTURE"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x82E0: + return "GL_BUFFER"; + case 0x82E1: + return "GL_SHADER"; + case 0x82E2: + return "GL_PROGRAM"; + case 0x82E3: + return "GL_QUERY"; + case 0x82E4: + return "GL_PROGRAM_PIPELINE"; + case 0x82E6: + return "GL_SAMPLER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PatchParameterName: + { + switch (value) + { + case 0x8E72: + return "GL_PATCH_VERTICES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathColor: + { + switch (value) + { + case 0x8577: + return "GL_PRIMARY_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathColorFormat: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathFillMode: + { + switch (value) + { + case 0x150A: + return "GL_INVERT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathFontStyle: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathGenMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x8576: + return "GL_CONSTANT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PathTransformType: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PipelineParameterName: + { + switch (value) + { + case 0x8259: + return "GL_ACTIVE_PROGRAM"; + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelCopyType: + { + switch (value) + { + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelFormat: + { + switch (value) + { + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + case 0x80E1: + return "GL_BGRA_EXT"; + case 0x8227: + return "GL_RG"; + case 0x8228: + return "GL_RG_INTEGER"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; + case 0x8D94: + return "GL_RED_INTEGER"; + case 0x8D98: + return "GL_RGB_INTEGER"; + case 0x8D99: + return "GL_RGBA_INTEGER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelStoreParameter: + { + switch (value) + { + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelTexGenMode: + { + switch (value) + { + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelTexGenModeSGIX: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelTransferParameter: + { + switch (value) + { + case 0xD1C: + return "GL_ALPHA_SCALE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PixelType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x8033: + return "GL_UNSIGNED_SHORT_4_4_4_4"; + case 0x8034: + return "GL_UNSIGNED_SHORT_5_5_5_1"; + case 0x8363: + return "GL_UNSIGNED_SHORT_5_6_5"; + case 0x8365: + return "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT"; + case 0x8366: + return "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PointParameterNameARB: + { + switch (value) + { + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PointParameterNameSGIS: + { + switch (value) + { + case 0x8126: + return "GL_POINT_SIZE_MIN"; + case 0x8127: + return "GL_POINT_SIZE_MAX"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x8129: + return "GL_POINT_DISTANCE_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PrecisionType: + { + switch (value) + { + case 0x8DF0: + return "GL_LOW_FLOAT"; + case 0x8DF1: + return "GL_MEDIUM_FLOAT"; + case 0x8DF2: + return "GL_HIGH_FLOAT"; + case 0x8DF3: + return "GL_LOW_INT"; + case 0x8DF4: + return "GL_MEDIUM_INT"; + case 0x8DF5: + return "GL_HIGH_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::PrimitiveType: + { + switch (value) + { + case 0x0: + return "GL_POINTS"; + case 0x1: + return "GL_LINES"; + case 0x2: + return "GL_LINE_LOOP"; + case 0x3: + return "GL_LINE_STRIP"; + case 0x4: + return "GL_TRIANGLES"; + case 0x5: + return "GL_TRIANGLE_STRIP"; + case 0x6: + return "GL_TRIANGLE_FAN"; + case 0x7: + return "GL_QUADS"; + case 0xA: + return "GL_LINES_ADJACENCY"; + case 0xB: + return "GL_LINE_STRIP_ADJACENCY"; + case 0xC: + return "GL_TRIANGLES_ADJACENCY"; + case 0xD: + return "GL_TRIANGLE_STRIP_ADJACENCY"; + case 0xE: + return "GL_PATCHES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ProgramInterface: + { + switch (value) + { + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E2: + return "GL_UNIFORM_BLOCK"; + case 0x92E3: + return "GL_PROGRAM_INPUT"; + case 0x92E4: + return "GL_PROGRAM_OUTPUT"; + case 0x92E5: + return "GL_BUFFER_VARIABLE"; + case 0x92E6: + return "GL_SHADER_STORAGE_BLOCK"; + case 0x92F4: + return "GL_TRANSFORM_FEEDBACK_VARYING"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ProgramInterfacePName: + { + switch (value) + { + case 0x92F5: + return "GL_ACTIVE_RESOURCES"; + case 0x92F6: + return "GL_MAX_NAME_LENGTH"; + case 0x92F7: + return "GL_MAX_NUM_ACTIVE_VARIABLES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ProgramParameterPName: + { + switch (value) + { + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; + case 0x8258: + return "GL_PROGRAM_SEPARABLE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ProgramPropertyARB: + { + switch (value) + { + case 0x8267: + return "GL_COMPUTE_WORK_GROUP_SIZE"; + case 0x8741: + return "GL_PROGRAM_BINARY_LENGTH"; + case 0x8916: + return "GL_GEOMETRY_VERTICES_OUT"; + case 0x8917: + return "GL_GEOMETRY_INPUT_TYPE"; + case 0x8918: + return "GL_GEOMETRY_OUTPUT_TYPE"; + case 0x8A35: + return "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"; + case 0x8A36: + return "GL_ACTIVE_UNIFORM_BLOCKS"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B82: + return "GL_LINK_STATUS"; + case 0x8B83: + return "GL_VALIDATE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B85: + return "GL_ATTACHED_SHADERS"; + case 0x8B86: + return "GL_ACTIVE_UNIFORMS"; + case 0x8B87: + return "GL_ACTIVE_UNIFORM_MAX_LENGTH"; + case 0x8B89: + return "GL_ACTIVE_ATTRIBUTES"; + case 0x8B8A: + return "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"; + case 0x8C76: + return "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"; + case 0x8C7F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"; + case 0x8C83: + return "GL_TRANSFORM_FEEDBACK_VARYINGS"; + case 0x92D9: + return "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ProgramResourceProperty: + { + switch (value) + { + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E7: + return "GL_IS_PER_PATCH"; + case 0x92F9: + return "GL_NAME_LENGTH"; + case 0x92FA: + return "GL_TYPE"; + case 0x92FB: + return "GL_ARRAY_SIZE"; + case 0x92FC: + return "GL_OFFSET"; + case 0x92FD: + return "GL_BLOCK_INDEX"; + case 0x92FE: + return "GL_ARRAY_STRIDE"; + case 0x92FF: + return "GL_MATRIX_STRIDE"; + case 0x9300: + return "GL_IS_ROW_MAJOR"; + case 0x9301: + return "GL_ATOMIC_COUNTER_BUFFER_INDEX"; + case 0x9302: + return "GL_BUFFER_BINDING"; + case 0x9303: + return "GL_BUFFER_DATA_SIZE"; + case 0x9304: + return "GL_NUM_ACTIVE_VARIABLES"; + case 0x9305: + return "GL_ACTIVE_VARIABLES"; + case 0x9306: + return "GL_REFERENCED_BY_VERTEX_SHADER"; + case 0x9307: + return "GL_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x9308: + return "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x9309: + return "GL_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x930A: + return "GL_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x930B: + return "GL_REFERENCED_BY_COMPUTE_SHADER"; + case 0x930C: + return "GL_TOP_LEVEL_ARRAY_SIZE"; + case 0x930D: + return "GL_TOP_LEVEL_ARRAY_STRIDE"; + case 0x930E: + return "GL_LOCATION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::QueryCounterTarget: + { + switch (value) + { + case 0x8E28: + return "GL_TIMESTAMP_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::QueryObjectParameterName: + { + switch (value) + { + case 0x8866: + return "GL_QUERY_RESULT"; + case 0x8867: + return "GL_QUERY_RESULT_AVAILABLE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::QueryParameterName: + { + switch (value) + { + case 0x8865: + return "GL_CURRENT_QUERY"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::QueryTarget: + { + switch (value) + { + case 0x8C2F: + return "GL_ANY_SAMPLES_PASSED"; + case 0x8C87: + return "GL_PRIMITIVES_GENERATED"; + case 0x8C88: + return "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; + case 0x8D6A: + return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ReadBufferMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::RegisterCombinerPname: + { + switch (value) + { + case 0x8570: + return "GL_COMBINE"; + case 0x8571: + return "GL_COMBINE_RGB"; + case 0x8572: + return "GL_COMBINE_ALPHA"; + case 0x8573: + return "GL_RGB_SCALE"; + case 0x8574: + return "GL_ADD_SIGNED"; + case 0x8575: + return "GL_INTERPOLATE"; + case 0x8576: + return "GL_CONSTANT"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + case 0x8578: + return "GL_PREVIOUS"; + case 0x8580: + return "GL_SRC0_RGB"; + case 0x8581: + return "GL_SRC1_RGB"; + case 0x8582: + return "GL_SRC2_RGB"; + case 0x8588: + return "GL_SRC0_ALPHA"; + case 0x8589: + return "GL_SRC1_ALPHA"; + case 0x858A: + return "GL_SRC2_ALPHA"; + case 0x8590: + return "GL_OPERAND0_RGB"; + case 0x8591: + return "GL_OPERAND1_RGB"; + case 0x8592: + return "GL_OPERAND2_RGB"; + case 0x8598: + return "GL_OPERAND0_ALPHA"; + case 0x8599: + return "GL_OPERAND1_ALPHA"; + case 0x859A: + return "GL_OPERAND2_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::RenderbufferParameterName: + { + switch (value) + { + case 0x8CAB: + return "GL_RENDERBUFFER_SAMPLES"; + case 0x8D42: + return "GL_RENDERBUFFER_WIDTH"; + case 0x8D43: + return "GL_RENDERBUFFER_HEIGHT"; + case 0x8D44: + return "GL_RENDERBUFFER_INTERNAL_FORMAT"; + case 0x8D50: + return "GL_RENDERBUFFER_RED_SIZE"; + case 0x8D51: + return "GL_RENDERBUFFER_GREEN_SIZE"; + case 0x8D52: + return "GL_RENDERBUFFER_BLUE_SIZE"; + case 0x8D53: + return "GL_RENDERBUFFER_ALPHA_SIZE"; + case 0x8D54: + return "GL_RENDERBUFFER_DEPTH_SIZE"; + case 0x8D55: + return "GL_RENDERBUFFER_STENCIL_SIZE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::RenderbufferTarget: + { + switch (value) + { + case 0x8D41: + return "GL_RENDERBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ReplacementCodeTypeSUN: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SamplerParameterF: + { + switch (value) + { + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SamplerParameterI: + { + switch (value) + { + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; + case 0x884C: + return "GL_TEXTURE_COMPARE_MODE"; + case 0x884D: + return "GL_TEXTURE_COMPARE_FUNC"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ScalarType: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SecondaryColorPointerTypeIBM: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ShaderParameterName: + { + switch (value) + { + case 0x8B4F: + return "GL_SHADER_TYPE"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B81: + return "GL_COMPILE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B88: + return "GL_SHADER_SOURCE_LENGTH"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ShaderType: + { + switch (value) + { + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + case 0x91B9: + return "GL_COMPUTE_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ShadingModel: + { + switch (value) + { + case 0x1D00: + return "GL_FLAT"; + case 0x1D01: + return "GL_SMOOTH"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::ShadingRateQCOM: + { + switch (value) + { + case 0x96A6: + return "GL_SHADING_RATE_1X1_PIXELS_QCOM"; + case 0x96A7: + return "GL_SHADING_RATE_1X2_PIXELS_QCOM"; + case 0x96A8: + return "GL_SHADING_RATE_2X1_PIXELS_QCOM"; + case 0x96A9: + return "GL_SHADING_RATE_2X2_PIXELS_QCOM"; + case 0x96AC: + return "GL_SHADING_RATE_4X2_PIXELS_QCOM"; + case 0x96AE: + return "GL_SHADING_RATE_4X4_PIXELS_QCOM"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SizedInternalFormat: + { + switch (value) + { + case 0x803C: + return "GL_ALPHA8_EXT"; + case 0x8040: + return "GL_LUMINANCE8_EXT"; + case 0x8045: + return "GL_LUMINANCE8_ALPHA8_EXT"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10_EXT"; + case 0x8054: + return "GL_RGB16_EXT"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805B: + return "GL_RGBA16_EXT"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; + case 0x81A6: + return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32_OES"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16_EXT"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16_EXT"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE"; + case 0x8814: + return "GL_RGBA32F"; + case 0x8815: + return "GL_RGB32F"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3D: + return "GL_RGB9_E5"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8C4C: + return "GL_COMPRESSED_SRGB_S3TC_DXT1_EXT"; + case 0x8C4D: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT"; + case 0x8C4E: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT"; + case 0x8C4F: + return "GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D62: + return "GL_RGB565"; + case 0x8D64: + return "GL_ETC1_RGB8_OES"; + case 0x8D70: + return "GL_RGBA32UI"; + case 0x8D71: + return "GL_RGB32UI"; + case 0x8D76: + return "GL_RGBA16UI"; + case 0x8D77: + return "GL_RGB16UI"; + case 0x8D7C: + return "GL_RGBA8UI"; + case 0x8D7D: + return "GL_RGB8UI"; + case 0x8D82: + return "GL_RGBA32I"; + case 0x8D83: + return "GL_RGB32I"; + case 0x8D88: + return "GL_RGBA16I"; + case 0x8D89: + return "GL_RGB16I"; + case 0x8D8E: + return "GL_RGBA8I"; + case 0x8D8F: + return "GL_RGB8I"; + case 0x8DBB: + return "GL_COMPRESSED_RED_RGTC1_EXT"; + case 0x8DBC: + return "GL_COMPRESSED_SIGNED_RED_RGTC1_EXT"; + case 0x8DBD: + return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; + case 0x8DBE: + return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8E8C: + return "GL_COMPRESSED_RGBA_BPTC_UNORM_EXT"; + case 0x8E8D: + return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT"; + case 0x8E8E: + return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_EXT"; + case 0x8E8F: + return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_EXT"; + case 0x8F94: + return "GL_R8_SNORM"; + case 0x8F95: + return "GL_RG8_SNORM"; + case 0x8F96: + return "GL_RGB8_SNORM"; + case 0x8F97: + return "GL_RGBA8_SNORM"; + case 0x8F98: + return "GL_R16_SNORM_EXT"; + case 0x8F99: + return "GL_RG16_SNORM_EXT"; + case 0x8F9A: + return "GL_RGB16_SNORM_EXT"; + case 0x8F9B: + return "GL_RGBA16_SNORM_EXT"; + case 0x906F: + return "GL_RGB10_A2UI"; + case 0x9270: + return "GL_COMPRESSED_R11_EAC"; + case 0x9271: + return "GL_COMPRESSED_SIGNED_R11_EAC"; + case 0x9272: + return "GL_COMPRESSED_RG11_EAC"; + case 0x9273: + return "GL_COMPRESSED_SIGNED_RG11_EAC"; + case 0x9274: + return "GL_COMPRESSED_RGB8_ETC2"; + case 0x9275: + return "GL_COMPRESSED_SRGB8_ETC2"; + case 0x9276: + return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9277: + return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9278: + return "GL_COMPRESSED_RGBA8_ETC2_EAC"; + case 0x9279: + return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x93B0: + return "GL_COMPRESSED_RGBA_ASTC_4x4"; + case 0x93B1: + return "GL_COMPRESSED_RGBA_ASTC_5x4"; + case 0x93B2: + return "GL_COMPRESSED_RGBA_ASTC_5x5"; + case 0x93B3: + return "GL_COMPRESSED_RGBA_ASTC_6x5"; + case 0x93B4: + return "GL_COMPRESSED_RGBA_ASTC_6x6"; + case 0x93B5: + return "GL_COMPRESSED_RGBA_ASTC_8x5"; + case 0x93B6: + return "GL_COMPRESSED_RGBA_ASTC_8x6"; + case 0x93B7: + return "GL_COMPRESSED_RGBA_ASTC_8x8"; + case 0x93B8: + return "GL_COMPRESSED_RGBA_ASTC_10x5"; + case 0x93B9: + return "GL_COMPRESSED_RGBA_ASTC_10x6"; + case 0x93BA: + return "GL_COMPRESSED_RGBA_ASTC_10x8"; + case 0x93BB: + return "GL_COMPRESSED_RGBA_ASTC_10x10"; + case 0x93BC: + return "GL_COMPRESSED_RGBA_ASTC_12x10"; + case 0x93BD: + return "GL_COMPRESSED_RGBA_ASTC_12x12"; + case 0x93C0: + return "GL_COMPRESSED_RGBA_ASTC_3x3x3_OES"; + case 0x93C1: + return "GL_COMPRESSED_RGBA_ASTC_4x3x3_OES"; + case 0x93C2: + return "GL_COMPRESSED_RGBA_ASTC_4x4x3_OES"; + case 0x93C3: + return "GL_COMPRESSED_RGBA_ASTC_4x4x4_OES"; + case 0x93C4: + return "GL_COMPRESSED_RGBA_ASTC_5x4x4_OES"; + case 0x93C5: + return "GL_COMPRESSED_RGBA_ASTC_5x5x4_OES"; + case 0x93C6: + return "GL_COMPRESSED_RGBA_ASTC_5x5x5_OES"; + case 0x93C7: + return "GL_COMPRESSED_RGBA_ASTC_6x5x5_OES"; + case 0x93C8: + return "GL_COMPRESSED_RGBA_ASTC_6x6x5_OES"; + case 0x93C9: + return "GL_COMPRESSED_RGBA_ASTC_6x6x6_OES"; + case 0x93D0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4"; + case 0x93D1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4"; + case 0x93D2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5"; + case 0x93D3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5"; + case 0x93D4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6"; + case 0x93D5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5"; + case 0x93D6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6"; + case 0x93D7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8"; + case 0x93D8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5"; + case 0x93D9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6"; + case 0x93DA: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8"; + case 0x93DB: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10"; + case 0x93DC: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10"; + case 0x93DD: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12"; + case 0x93E0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES"; + case 0x93E1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES"; + case 0x93E2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES"; + case 0x93E3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES"; + case 0x93E4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES"; + case 0x93E5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES"; + case 0x93E6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES"; + case 0x93E7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES"; + case 0x93E8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES"; + case 0x93E9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::StencilFaceDirection: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::StencilFunction: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::StencilOp: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x150A: + return "GL_INVERT"; + case 0x1E00: + return "GL_KEEP"; + case 0x1E01: + return "GL_REPLACE"; + case 0x1E02: + return "GL_INCR"; + case 0x1E03: + return "GL_DECR"; + case 0x8507: + return "GL_INCR_WRAP"; + case 0x8508: + return "GL_DECR_WRAP"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::StringName: + { + switch (value) + { + case 0x1F00: + return "GL_VENDOR"; + case 0x1F01: + return "GL_RENDERER"; + case 0x1F02: + return "GL_VERSION"; + case 0x1F03: + return "GL_EXTENSIONS"; + case 0x8B8C: + return "GL_SHADING_LANGUAGE_VERSION"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SubroutineParameterName: + { + switch (value) + { + case 0x8A38: + return "GL_UNIFORM_SIZE"; + case 0x8A39: + return "GL_UNIFORM_NAME_LENGTH"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SyncBehaviorFlags: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SyncCondition: + { + switch (value) + { + case 0x9117: + return "GL_SYNC_GPU_COMMANDS_COMPLETE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SyncObjectMask: + { + switch (value) + { + case 0x1: + return "GL_SYNC_FLUSH_COMMANDS_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SyncParameterName: + { + switch (value) + { + case 0x9112: + return "GL_OBJECT_TYPE"; + case 0x9113: + return "GL_SYNC_CONDITION"; + case 0x9114: + return "GL_SYNC_STATUS"; + case 0x9115: + return "GL_SYNC_FLAGS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::SyncStatus: + { + switch (value) + { + case 0x911A: + return "GL_ALREADY_SIGNALED"; + case 0x911B: + return "GL_TIMEOUT_EXPIRED"; + case 0x911C: + return "GL_CONDITION_SATISFIED"; + case 0x911D: + return "GL_WAIT_FAILED"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TangentPointerTypeEXT: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TexCoordPointerType: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureCompareMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x884E: + return "GL_COMPARE_REF_TO_TEXTURE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureCoordName: + { + switch (value) + { + case 0x8D60: + return "GL_TEXTURE_GEN_STR_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureEnvMode: + { + switch (value) + { + case 0x104: + return "GL_ADD"; + case 0xBE2: + return "GL_BLEND"; + case 0x2100: + return "GL_MODULATE"; + case 0x2101: + return "GL_DECAL"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureEnvParameter: + { + switch (value) + { + case 0x2200: + return "GL_TEXTURE_ENV_MODE"; + case 0x2201: + return "GL_TEXTURE_ENV_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureEnvTarget: + { + switch (value) + { + case 0x2300: + return "GL_TEXTURE_ENV"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureGenParameter: + { + switch (value) + { + case 0x2500: + return "GL_TEXTURE_GEN_MODE_OES"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureLayout: + { + switch (value) + { + case 0x9530: + return "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT"; + case 0x9531: + return "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT"; + case 0x958D: + return "GL_LAYOUT_GENERAL_EXT"; + case 0x958E: + return "GL_LAYOUT_COLOR_ATTACHMENT_EXT"; + case 0x958F: + return "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT"; + case 0x9590: + return "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT"; + case 0x9591: + return "GL_LAYOUT_SHADER_READ_ONLY_EXT"; + case 0x9592: + return "GL_LAYOUT_TRANSFER_SRC_EXT"; + case 0x9593: + return "GL_LAYOUT_TRANSFER_DST_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureMagFilter: + { + switch (value) + { + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureMinFilter: + { + switch (value) + { + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + case 0x2700: + return "GL_NEAREST_MIPMAP_NEAREST"; + case 0x2701: + return "GL_LINEAR_MIPMAP_NEAREST"; + case 0x2702: + return "GL_NEAREST_MIPMAP_LINEAR"; + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureParameterName: + { + switch (value) + { + case 0x1000: + return "GL_TEXTURE_WIDTH"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_INTERNAL_FORMAT"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + case 0x813C: + return "GL_TEXTURE_BASE_LEVEL"; + case 0x813D: + return "GL_TEXTURE_MAX_LEVEL"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x884C: + return "GL_TEXTURE_COMPARE_MODE"; + case 0x884D: + return "GL_TEXTURE_COMPARE_FUNC"; + case 0x8E42: + return "GL_TEXTURE_SWIZZLE_R"; + case 0x8E43: + return "GL_TEXTURE_SWIZZLE_G"; + case 0x8E44: + return "GL_TEXTURE_SWIZZLE_B"; + case 0x8E45: + return "GL_TEXTURE_SWIZZLE_A"; + case 0x90EA: + return "GL_DEPTH_STENCIL_TEXTURE_MODE"; + case 0x9580: + return "GL_TEXTURE_TILING_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureSwizzle: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureTarget: + { + switch (value) + { + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x806F: + return "GL_TEXTURE_3D"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8515: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; + case 0x8516: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; + case 0x8517: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; + case 0x8518: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; + case 0x8519: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; + case 0x851A: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; + case 0x8C1A: + return "GL_TEXTURE_2D_ARRAY"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x9009: + return "GL_TEXTURE_CUBE_MAP_ARRAY"; + case 0x9100: + return "GL_TEXTURE_2D_MULTISAMPLE"; + case 0x9102: + return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureUnit: + { + switch (value) + { + case 0x84C0: + return "GL_TEXTURE0"; + case 0x84C1: + return "GL_TEXTURE1"; + case 0x84C2: + return "GL_TEXTURE2"; + case 0x84C3: + return "GL_TEXTURE3"; + case 0x84C4: + return "GL_TEXTURE4"; + case 0x84C5: + return "GL_TEXTURE5"; + case 0x84C6: + return "GL_TEXTURE6"; + case 0x84C7: + return "GL_TEXTURE7"; + case 0x84C8: + return "GL_TEXTURE8"; + case 0x84C9: + return "GL_TEXTURE9"; + case 0x84CA: + return "GL_TEXTURE10"; + case 0x84CB: + return "GL_TEXTURE11"; + case 0x84CC: + return "GL_TEXTURE12"; + case 0x84CD: + return "GL_TEXTURE13"; + case 0x84CE: + return "GL_TEXTURE14"; + case 0x84CF: + return "GL_TEXTURE15"; + case 0x84D0: + return "GL_TEXTURE16"; + case 0x84D1: + return "GL_TEXTURE17"; + case 0x84D2: + return "GL_TEXTURE18"; + case 0x84D3: + return "GL_TEXTURE19"; + case 0x84D4: + return "GL_TEXTURE20"; + case 0x84D5: + return "GL_TEXTURE21"; + case 0x84D6: + return "GL_TEXTURE22"; + case 0x84D7: + return "GL_TEXTURE23"; + case 0x84D8: + return "GL_TEXTURE24"; + case 0x84D9: + return "GL_TEXTURE25"; + case 0x84DA: + return "GL_TEXTURE26"; + case 0x84DB: + return "GL_TEXTURE27"; + case 0x84DC: + return "GL_TEXTURE28"; + case 0x84DD: + return "GL_TEXTURE29"; + case 0x84DE: + return "GL_TEXTURE30"; + case 0x84DF: + return "GL_TEXTURE31"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TextureWrapMode: + { + switch (value) + { + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; case 0x2901: return "GL_REPEAT"; case 0x812D: return "GL_CLAMP_TO_BORDER"; case 0x812F: return "GL_CLAMP_TO_EDGE"; + case 0x8370: + return "GL_MIRRORED_REPEAT"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::TransformFeedbackPName: + case GLESEnum::TransformFeedbackBufferMode: + { + switch (value) + { + case 0x8C8C: + return "GL_INTERLEAVED_ATTRIBS"; + case 0x8C8D: + return "GL_SEPARATE_ATTRIBS"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::TransformFeedbackPName: { switch (value) { @@ -4126,11 +7767,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8E24: return "GL_TRANSFORM_FEEDBACK_ACTIVE"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::UniformBlockPName: + case GLESEnum::UniformBlockPName: { switch (value) { @@ -4149,11 +7790,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8A46: return "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::UniformPName: + case GLESEnum::UniformPName: { switch (value) { @@ -4174,11 +7815,126 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8A3E: return "GL_UNIFORM_IS_ROW_MAJOR"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::UseProgramStageMask: + case GLESEnum::UniformType: + { + switch (value) + { + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::UseProgramStageMask: { switch (value) { @@ -4197,11 +7953,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0xFFFFFFFF: return "GL_ALL_SHADER_BITS"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexArrayPName: + case GLESEnum::VertexArrayPName: { switch (value) { @@ -4222,11 +7978,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x88FE: return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexAttribEnum: + case GLESEnum::VertexAttribEnum: { switch (value) { @@ -4249,11 +8005,43 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x88FE: return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexAttribPointerType: + case GLESEnum::VertexAttribIType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexAttribPointerPropertyARB: + { + switch (value) + { + case 0x8645: + return "GL_VERTEX_ATTRIB_ARRAY_POINTER"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexAttribPointerType: { switch (value) { @@ -4282,11 +8070,42 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8D9F: return "GL_INT_2_10_10_10_REV"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexAttribType: + case GLESEnum::VertexAttribPropertyARB: + { + switch (value) + { + case 0x82D4: + return "GL_VERTEX_ATTRIB_BINDING"; + case 0x82D5: + return "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x8626: + return "GL_CURRENT_VERTEX_ATTRIB"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; + case 0x889F: + return "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; + case 0x88FE: + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexAttribType: { switch (value) { @@ -4315,11 +8134,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8D9F: return "GL_INT_2_10_10_10_REV"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexBufferObjectParameter: + case GLESEnum::VertexBufferObjectParameter: { switch (value) { @@ -4336,11 +8155,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x9121: return "GL_BUFFER_MAP_OFFSET"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexBufferObjectUsage: + case GLESEnum::VertexBufferObjectUsage: { switch (value) { @@ -4363,11 +8182,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x88EA: return "GL_DYNAMIC_COPY"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexPointerType: + case GLESEnum::VertexPointerType: { switch (value) { @@ -4378,11 +8197,11 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x1406: return "GL_FLOAT"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); } } - case GLenumGroup::VertexProvokingMode: + case GLESEnum::VertexProvokingMode: { switch (value) { @@ -4391,12 +8210,11024 @@ const char *GLenumToString(GLenumGroup enumGroup, unsigned int value) case 0x8E4E: return "GL_LAST_VERTEX_CONVENTION"; default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexShaderTextureUnitParameter: + { + switch (value) + { + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexShaderWriteMaskEXT: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::VertexWeightPointerTypeEXT: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case GLESEnum::WeightPointerTypeARB: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); } } default: - return UnknownGLenumToString(value); + return UnknownEnumToString(value); + } +} + +const char *GLenumToString(BigGLEnum enumGroup, unsigned int value) +{ + switch (enumGroup) + { + case BigGLEnum::AccumOp: + { + switch (value) + { + case 0x100: + return "GL_ACCUM"; + case 0x101: + return "GL_LOAD"; + case 0x102: + return "GL_RETURN"; + case 0x103: + return "GL_MULT"; + case 0x104: + return "GL_ADD"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::AllEnums: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_CLIENT_PIXEL_STORE_BIT"; + case 0x2: + return "GL_CLIENT_VERTEX_ARRAY_BIT"; + case 0x3: + return "GL_LINE_STRIP"; + case 0x4: + return "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"; + case 0x5: + return "GL_TRIANGLE_STRIP"; + case 0x6: + return "GL_TRIANGLE_FAN"; + case 0x7: + return "GL_QUADS"; + case 0x8: + return "GL_CONTEXT_FLAG_NO_ERROR_BIT"; + case 0x9: + return "GL_POLYGON"; + case 0xA: + return "GL_LINES_ADJACENCY"; + case 0xB: + return "GL_LINE_STRIP_ADJACENCY"; + case 0xC: + return "GL_TRIANGLES_ADJACENCY"; + case 0xD: + return "GL_TRIANGLE_STRIP_ADJACENCY"; + case 0xE: + return "GL_PATCHES"; + case 0x10: + return "GL_CREATE_CUBE_COMPATIBLE_BIT_ANGLE"; + case 0x16: + return "GL_UUID_SIZE_EXT"; + case 0x20: + return "GL_COMPUTE_SHADER_BIT"; + case 0x40: + return "GL_COMMAND_BARRIER_BIT"; + case 0x80: + return "GL_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_ANGLE"; + case 0x100: + return "GL_ACCUM"; + case 0x101: + return "GL_LOAD"; + case 0x102: + return "GL_RETURN"; + case 0x103: + return "GL_MULT"; + case 0x104: + return "GL_ADD"; + case 0x200: + return "GL_ACCUM_BUFFER_BIT"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + case 0x300: + return "GL_SRC_COLOR"; + case 0x301: + return "GL_ONE_MINUS_SRC_COLOR"; + case 0x302: + return "GL_SRC_ALPHA"; + case 0x303: + return "GL_ONE_MINUS_SRC_ALPHA"; + case 0x304: + return "GL_DST_ALPHA"; + case 0x305: + return "GL_ONE_MINUS_DST_ALPHA"; + case 0x306: + return "GL_DST_COLOR"; + case 0x307: + return "GL_ONE_MINUS_DST_COLOR"; + case 0x308: + return "GL_SRC_ALPHA_SATURATE"; + case 0x400: + return "GL_CREATE_ALIAS_BIT_ANGLE"; + case 0x401: + return "GL_FRONT_RIGHT"; + case 0x402: + return "GL_BACK_LEFT"; + case 0x403: + return "GL_BACK_RIGHT"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x406: + return "GL_LEFT"; + case 0x407: + return "GL_RIGHT"; + case 0x408: + return "GL_FRONT_AND_BACK"; + case 0x409: + return "GL_AUX0"; + case 0x40A: + return "GL_AUX1"; + case 0x40B: + return "GL_AUX2"; + case 0x40C: + return "GL_AUX3"; + case 0x500: + return "GL_INVALID_ENUM"; + case 0x501: + return "GL_INVALID_VALUE"; + case 0x502: + return "GL_INVALID_OPERATION"; + case 0x503: + return "GL_STACK_OVERFLOW"; + case 0x504: + return "GL_STACK_UNDERFLOW"; + case 0x505: + return "GL_OUT_OF_MEMORY"; + case 0x506: + return "GL_INVALID_FRAMEBUFFER_OPERATION"; + case 0x507: + return "GL_CONTEXT_LOST"; + case 0x600: + return "GL_2D"; + case 0x601: + return "GL_3D"; + case 0x602: + return "GL_3D_COLOR"; + case 0x603: + return "GL_3D_COLOR_TEXTURE"; + case 0x604: + return "GL_4D_COLOR_TEXTURE"; + case 0x700: + return "GL_PASS_THROUGH_TOKEN"; + case 0x701: + return "GL_POINT_TOKEN"; + case 0x702: + return "GL_LINE_TOKEN"; + case 0x703: + return "GL_POLYGON_TOKEN"; + case 0x704: + return "GL_BITMAP_TOKEN"; + case 0x705: + return "GL_DRAW_PIXEL_TOKEN"; + case 0x706: + return "GL_COPY_PIXEL_TOKEN"; + case 0x707: + return "GL_LINE_RESET_TOKEN"; + case 0x800: + return "GL_CREATE_PROTECTED_BIT_ANGLE"; + case 0x801: + return "GL_EXP2"; + case 0x900: + return "GL_CW"; + case 0x901: + return "GL_CCW"; + case 0xA00: + return "GL_COEFF"; + case 0xA01: + return "GL_ORDER"; + case 0xA02: + return "GL_DOMAIN"; + case 0xB00: + return "GL_CURRENT_COLOR"; + case 0xB01: + return "GL_CURRENT_INDEX"; + case 0xB02: + return "GL_CURRENT_NORMAL"; + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xB04: + return "GL_CURRENT_RASTER_COLOR"; + case 0xB05: + return "GL_CURRENT_RASTER_INDEX"; + case 0xB06: + return "GL_CURRENT_RASTER_TEXTURE_COORDS"; + case 0xB07: + return "GL_CURRENT_RASTER_POSITION"; + case 0xB08: + return "GL_CURRENT_RASTER_POSITION_VALID"; + case 0xB09: + return "GL_CURRENT_RASTER_DISTANCE"; + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB11: + return "GL_POINT_SIZE"; + case 0xB12: + return "GL_POINT_SIZE_RANGE"; + case 0xB13: + return "GL_POINT_SIZE_GRANULARITY"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB21: + return "GL_LINE_WIDTH"; + case 0xB22: + return "GL_LINE_WIDTH_RANGE"; + case 0xB23: + return "GL_LINE_WIDTH_GRANULARITY"; + case 0xB24: + return "GL_LINE_STIPPLE"; + case 0xB25: + return "GL_LINE_STIPPLE_PATTERN"; + case 0xB26: + return "GL_LINE_STIPPLE_REPEAT"; + case 0xB30: + return "GL_LIST_MODE"; + case 0xB31: + return "GL_MAX_LIST_NESTING"; + case 0xB32: + return "GL_LIST_BASE"; + case 0xB33: + return "GL_LIST_INDEX"; + case 0xB40: + return "GL_POLYGON_MODE"; + case 0xB41: + return "GL_POLYGON_SMOOTH"; + case 0xB42: + return "GL_POLYGON_STIPPLE"; + case 0xB43: + return "GL_EDGE_FLAG"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB45: + return "GL_CULL_FACE_MODE"; + case 0xB46: + return "GL_FRONT_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB51: + return "GL_LIGHT_MODEL_LOCAL_VIEWER"; + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + case 0xB54: + return "GL_SHADE_MODEL"; + case 0xB55: + return "GL_COLOR_MATERIAL_FACE"; + case 0xB56: + return "GL_COLOR_MATERIAL_PARAMETER"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB61: + return "GL_FOG_INDEX"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + case 0xB70: + return "GL_DEPTH_RANGE"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB72: + return "GL_DEPTH_WRITEMASK"; + case 0xB73: + return "GL_DEPTH_CLEAR_VALUE"; + case 0xB74: + return "GL_DEPTH_FUNC"; + case 0xB80: + return "GL_ACCUM_CLEAR_VALUE"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xB91: + return "GL_STENCIL_CLEAR_VALUE"; + case 0xB92: + return "GL_STENCIL_FUNC"; + case 0xB93: + return "GL_STENCIL_VALUE_MASK"; + case 0xB94: + return "GL_STENCIL_FAIL"; + case 0xB95: + return "GL_STENCIL_PASS_DEPTH_FAIL"; + case 0xB96: + return "GL_STENCIL_PASS_DEPTH_PASS"; + case 0xB97: + return "GL_STENCIL_REF"; + case 0xB98: + return "GL_STENCIL_WRITEMASK"; + case 0xBA0: + return "GL_MATRIX_MODE"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBA2: + return "GL_VIEWPORT"; + case 0xBA3: + return "GL_MODELVIEW_STACK_DEPTH"; + case 0xBA4: + return "GL_PROJECTION_STACK_DEPTH"; + case 0xBA5: + return "GL_TEXTURE_STACK_DEPTH"; + case 0xBA6: + return "GL_MODELVIEW_MATRIX"; + case 0xBA7: + return "GL_PROJECTION_MATRIX"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + case 0xBB0: + return "GL_ATTRIB_STACK_DEPTH"; + case 0xBB1: + return "GL_CLIENT_ATTRIB_STACK_DEPTH"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBC1: + return "GL_ALPHA_TEST_FUNC"; + case 0xBC2: + return "GL_ALPHA_TEST_REF"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE0: + return "GL_BLEND_DST"; + case 0xBE1: + return "GL_BLEND_SRC"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF0: + return "GL_LOGIC_OP_MODE"; + case 0xBF1: + return "GL_INDEX_LOGIC_OP"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC00: + return "GL_AUX_BUFFERS"; + case 0xC01: + return "GL_DRAW_BUFFER"; + case 0xC02: + return "GL_READ_BUFFER"; + case 0xC10: + return "GL_SCISSOR_BOX"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xC20: + return "GL_INDEX_CLEAR_VALUE"; + case 0xC21: + return "GL_INDEX_WRITEMASK"; + case 0xC22: + return "GL_COLOR_CLEAR_VALUE"; + case 0xC23: + return "GL_COLOR_WRITEMASK"; + case 0xC30: + return "GL_INDEX_MODE"; + case 0xC31: + return "GL_RGBA_MODE"; + case 0xC32: + return "GL_DOUBLEBUFFER"; + case 0xC33: + return "GL_STEREO"; + case 0xC40: + return "GL_RENDER_MODE"; + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC53: + return "GL_POLYGON_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0xC60: + return "GL_TEXTURE_GEN_S"; + case 0xC61: + return "GL_TEXTURE_GEN_T"; + case 0xC62: + return "GL_TEXTURE_GEN_R"; + case 0xC63: + return "GL_TEXTURE_GEN_Q"; + case 0xC70: + return "GL_PIXEL_MAP_I_TO_I"; + case 0xC71: + return "GL_PIXEL_MAP_S_TO_S"; + case 0xC72: + return "GL_PIXEL_MAP_I_TO_R"; + case 0xC73: + return "GL_PIXEL_MAP_I_TO_G"; + case 0xC74: + return "GL_PIXEL_MAP_I_TO_B"; + case 0xC75: + return "GL_PIXEL_MAP_I_TO_A"; + case 0xC76: + return "GL_PIXEL_MAP_R_TO_R"; + case 0xC77: + return "GL_PIXEL_MAP_G_TO_G"; + case 0xC78: + return "GL_PIXEL_MAP_B_TO_B"; + case 0xC79: + return "GL_PIXEL_MAP_A_TO_A"; + case 0xCB0: + return "GL_PIXEL_MAP_I_TO_I_SIZE"; + case 0xCB1: + return "GL_PIXEL_MAP_S_TO_S_SIZE"; + case 0xCB2: + return "GL_PIXEL_MAP_I_TO_R_SIZE"; + case 0xCB3: + return "GL_PIXEL_MAP_I_TO_G_SIZE"; + case 0xCB4: + return "GL_PIXEL_MAP_I_TO_B_SIZE"; + case 0xCB5: + return "GL_PIXEL_MAP_I_TO_A_SIZE"; + case 0xCB6: + return "GL_PIXEL_MAP_R_TO_R_SIZE"; + case 0xCB7: + return "GL_PIXEL_MAP_G_TO_G_SIZE"; + case 0xCB8: + return "GL_PIXEL_MAP_B_TO_B_SIZE"; + case 0xCB9: + return "GL_PIXEL_MAP_A_TO_A_SIZE"; + case 0xCF0: + return "GL_UNPACK_SWAP_BYTES"; + case 0xCF1: + return "GL_UNPACK_LSB_FIRST"; + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD00: + return "GL_PACK_SWAP_BYTES"; + case 0xD01: + return "GL_PACK_LSB_FIRST"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0xD10: + return "GL_MAP_COLOR"; + case 0xD11: + return "GL_MAP_STENCIL"; + case 0xD12: + return "GL_INDEX_SHIFT"; + case 0xD13: + return "GL_INDEX_OFFSET"; + case 0xD14: + return "GL_RED_SCALE"; + case 0xD15: + return "GL_RED_BIAS"; + case 0xD16: + return "GL_ZOOM_X"; + case 0xD17: + return "GL_ZOOM_Y"; + case 0xD18: + return "GL_GREEN_SCALE"; + case 0xD19: + return "GL_GREEN_BIAS"; + case 0xD1A: + return "GL_BLUE_SCALE"; + case 0xD1B: + return "GL_BLUE_BIAS"; + case 0xD1C: + return "GL_ALPHA_SCALE"; + case 0xD1D: + return "GL_ALPHA_BIAS"; + case 0xD1E: + return "GL_DEPTH_SCALE"; + case 0xD1F: + return "GL_DEPTH_BIAS"; + case 0xD30: + return "GL_MAX_EVAL_ORDER"; + case 0xD31: + return "GL_MAX_LIGHTS"; + case 0xD32: + return "GL_MAX_CLIP_DISTANCES"; + case 0xD33: + return "GL_MAX_TEXTURE_SIZE"; + case 0xD34: + return "GL_MAX_PIXEL_MAP_TABLE"; + case 0xD35: + return "GL_MAX_ATTRIB_STACK_DEPTH"; + case 0xD36: + return "GL_MAX_MODELVIEW_STACK_DEPTH"; + case 0xD37: + return "GL_MAX_NAME_STACK_DEPTH"; + case 0xD38: + return "GL_MAX_PROJECTION_STACK_DEPTH"; + case 0xD39: + return "GL_MAX_TEXTURE_STACK_DEPTH"; + case 0xD3A: + return "GL_MAX_VIEWPORT_DIMS"; + case 0xD3B: + return "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH"; + case 0xD50: + return "GL_SUBPIXEL_BITS"; + case 0xD51: + return "GL_INDEX_BITS"; + case 0xD52: + return "GL_RED_BITS"; + case 0xD53: + return "GL_GREEN_BITS"; + case 0xD54: + return "GL_BLUE_BITS"; + case 0xD55: + return "GL_ALPHA_BITS"; + case 0xD56: + return "GL_DEPTH_BITS"; + case 0xD57: + return "GL_STENCIL_BITS"; + case 0xD58: + return "GL_ACCUM_RED_BITS"; + case 0xD59: + return "GL_ACCUM_GREEN_BITS"; + case 0xD5A: + return "GL_ACCUM_BLUE_BITS"; + case 0xD5B: + return "GL_ACCUM_ALPHA_BITS"; + case 0xD70: + return "GL_NAME_STACK_DEPTH"; + case 0xD80: + return "GL_AUTO_NORMAL"; + case 0xD90: + return "GL_MAP1_COLOR_4"; + case 0xD91: + return "GL_MAP1_INDEX"; + case 0xD92: + return "GL_MAP1_NORMAL"; + case 0xD93: + return "GL_MAP1_TEXTURE_COORD_1"; + case 0xD94: + return "GL_MAP1_TEXTURE_COORD_2"; + case 0xD95: + return "GL_MAP1_TEXTURE_COORD_3"; + case 0xD96: + return "GL_MAP1_TEXTURE_COORD_4"; + case 0xD97: + return "GL_MAP1_VERTEX_3"; + case 0xD98: + return "GL_MAP1_VERTEX_4"; + case 0xDB0: + return "GL_MAP2_COLOR_4"; + case 0xDB1: + return "GL_MAP2_INDEX"; + case 0xDB2: + return "GL_MAP2_NORMAL"; + case 0xDB3: + return "GL_MAP2_TEXTURE_COORD_1"; + case 0xDB4: + return "GL_MAP2_TEXTURE_COORD_2"; + case 0xDB5: + return "GL_MAP2_TEXTURE_COORD_3"; + case 0xDB6: + return "GL_MAP2_TEXTURE_COORD_4"; + case 0xDB7: + return "GL_MAP2_VERTEX_3"; + case 0xDB8: + return "GL_MAP2_VERTEX_4"; + case 0xDD0: + return "GL_MAP1_GRID_DOMAIN"; + case 0xDD1: + return "GL_MAP1_GRID_SEGMENTS"; + case 0xDD2: + return "GL_MAP2_GRID_DOMAIN"; + case 0xDD3: + return "GL_MAP2_GRID_SEGMENTS"; + case 0xDE0: + return "GL_TEXTURE_1D"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0xDF0: + return "GL_FEEDBACK_BUFFER_POINTER"; + case 0xDF1: + return "GL_FEEDBACK_BUFFER_SIZE"; + case 0xDF2: + return "GL_FEEDBACK_BUFFER_TYPE"; + case 0xDF3: + return "GL_SELECTION_BUFFER_POINTER"; + case 0xDF4: + return "GL_SELECTION_BUFFER_SIZE"; + case 0x1000: + return "GL_ATOMIC_COUNTER_BARRIER_BIT"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_COMPONENTS"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x1005: + return "GL_TEXTURE_BORDER"; + case 0x1006: + return "GL_TEXTURE_TARGET"; + case 0x1100: + return "GL_DONT_CARE"; + case 0x1101: + return "GL_FASTEST"; + case 0x1102: + return "GL_NICEST"; + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; + case 0x1300: + return "GL_COMPILE"; + case 0x1301: + return "GL_COMPILE_AND_EXECUTE"; + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x1407: + return "GL_2_BYTES"; + case 0x1408: + return "GL_3_BYTES"; + case 0x1409: + return "GL_4_BYTES"; + case 0x140A: + return "GL_DOUBLE"; + case 0x140B: + return "GL_HALF_FLOAT"; + case 0x140C: + return "GL_FIXED"; + case 0x1500: + return "GL_CLEAR"; + case 0x1501: + return "GL_AND"; + case 0x1502: + return "GL_AND_REVERSE"; + case 0x1503: + return "GL_COPY"; + case 0x1504: + return "GL_AND_INVERTED"; + case 0x1505: + return "GL_NOOP"; + case 0x1506: + return "GL_XOR"; + case 0x1507: + return "GL_OR"; + case 0x1508: + return "GL_NOR"; + case 0x1509: + return "GL_EQUIV"; + case 0x150A: + return "GL_INVERT"; + case 0x150B: + return "GL_OR_REVERSE"; + case 0x150C: + return "GL_COPY_INVERTED"; + case 0x150D: + return "GL_OR_INVERTED"; + case 0x150E: + return "GL_NAND"; + case 0x150F: + return "GL_SET"; + case 0x1600: + return "GL_EMISSION"; + case 0x1601: + return "GL_SHININESS"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + case 0x1603: + return "GL_COLOR_INDEXES"; + case 0x1700: + return "GL_MODELVIEW"; + case 0x1701: + return "GL_PROJECTION"; + case 0x1702: + return "GL_TEXTURE"; + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + case 0x1900: + return "GL_COLOR_INDEX"; + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + case 0x1A00: + return "GL_BITMAP"; + case 0x1B00: + return "GL_POINT"; + case 0x1B01: + return "GL_LINE"; + case 0x1B02: + return "GL_FILL"; + case 0x1C00: + return "GL_RENDER"; + case 0x1C01: + return "GL_FEEDBACK"; + case 0x1C02: + return "GL_SELECT"; + case 0x1D00: + return "GL_FLAT"; + case 0x1D01: + return "GL_SMOOTH"; + case 0x1E00: + return "GL_KEEP"; + case 0x1E01: + return "GL_REPLACE"; + case 0x1E02: + return "GL_INCR"; + case 0x1E03: + return "GL_DECR"; + case 0x1F00: + return "GL_VENDOR"; + case 0x1F01: + return "GL_RENDERER"; + case 0x1F02: + return "GL_VERSION"; + case 0x1F03: + return "GL_EXTENSIONS"; + case 0x2000: + return "GL_CREATE_CORNER_SAMPLED_BIT_ANGLE"; + case 0x2001: + return "GL_T"; + case 0x2002: + return "GL_R"; + case 0x2003: + return "GL_Q"; + case 0x2100: + return "GL_MODULATE"; + case 0x2101: + return "GL_DECAL"; + case 0x2200: + return "GL_TEXTURE_ENV_MODE"; + case 0x2201: + return "GL_TEXTURE_ENV_COLOR"; + case 0x2300: + return "GL_TEXTURE_ENV"; + case 0x2400: + return "GL_EYE_LINEAR"; + case 0x2401: + return "GL_OBJECT_LINEAR"; + case 0x2402: + return "GL_SPHERE_MAP"; + case 0x2500: + return "GL_TEXTURE_GEN_MODE"; + case 0x2501: + return "GL_OBJECT_PLANE"; + case 0x2502: + return "GL_EYE_PLANE"; + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + case 0x2700: + return "GL_NEAREST_MIPMAP_NEAREST"; + case 0x2701: + return "GL_LINEAR_MIPMAP_NEAREST"; + case 0x2702: + return "GL_NEAREST_MIPMAP_LINEAR"; + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x2900: + return "GL_CLAMP"; + case 0x2901: + return "GL_REPEAT"; + case 0x2A00: + return "GL_POLYGON_OFFSET_UNITS"; + case 0x2A01: + return "GL_POLYGON_OFFSET_POINT"; + case 0x2A02: + return "GL_POLYGON_OFFSET_LINE"; + case 0x2A10: + return "GL_R3_G3_B2"; + case 0x2A20: + return "GL_V2F"; + case 0x2A21: + return "GL_V3F"; + case 0x2A22: + return "GL_C4UB_V2F"; + case 0x2A23: + return "GL_C4UB_V3F"; + case 0x2A24: + return "GL_C3F_V3F"; + case 0x2A25: + return "GL_N3F_V3F"; + case 0x2A26: + return "GL_C4F_N3F_V3F"; + case 0x2A27: + return "GL_T2F_V3F"; + case 0x2A28: + return "GL_T4F_V4F"; + case 0x2A29: + return "GL_T2F_C4UB_V3F"; + case 0x2A2A: + return "GL_T2F_C3F_V3F"; + case 0x2A2B: + return "GL_T2F_N3F_V3F"; + case 0x2A2C: + return "GL_T2F_C4F_N3F_V3F"; + case 0x2A2D: + return "GL_T4F_C4F_N3F_V4F"; + case 0x3000: + return "GL_CLIP_DISTANCE0"; + case 0x3001: + return "GL_CLIP_DISTANCE1"; + case 0x3002: + return "GL_CLIP_DISTANCE2"; + case 0x3003: + return "GL_CLIP_DISTANCE3"; + case 0x3004: + return "GL_CLIP_DISTANCE4"; + case 0x3005: + return "GL_CLIP_DISTANCE5"; + case 0x3006: + return "GL_CLIP_DISTANCE6"; + case 0x3007: + return "GL_CLIP_DISTANCE7"; + case 0x4000: + return "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8000: + return "GL_HINT_BIT"; + case 0x8001: + return "GL_CONSTANT_COLOR"; + case 0x8002: + return "GL_ONE_MINUS_CONSTANT_COLOR"; + case 0x8003: + return "GL_CONSTANT_ALPHA"; + case 0x8004: + return "GL_ONE_MINUS_CONSTANT_ALPHA"; + case 0x8005: + return "GL_BLEND_COLOR"; + case 0x8006: + return "GL_FUNC_ADD"; + case 0x8007: + return "GL_MIN"; + case 0x8008: + return "GL_MAX"; + case 0x8009: + return "GL_BLEND_EQUATION"; + case 0x800A: + return "GL_FUNC_SUBTRACT"; + case 0x800B: + return "GL_FUNC_REVERSE_SUBTRACT"; + case 0x8010: + return "GL_CONVOLUTION_1D"; + case 0x8011: + return "GL_CONVOLUTION_2D"; + case 0x8012: + return "GL_SEPARABLE_2D"; + case 0x8024: + return "GL_HISTOGRAM"; + case 0x8025: + return "GL_PROXY_HISTOGRAM"; + case 0x802E: + return "GL_MINMAX"; + case 0x8032: + return "GL_UNSIGNED_BYTE_3_3_2"; + case 0x8033: + return "GL_UNSIGNED_SHORT_4_4_4_4"; + case 0x8034: + return "GL_UNSIGNED_SHORT_5_5_5_1"; + case 0x8035: + return "GL_UNSIGNED_INT_8_8_8_8"; + case 0x8036: + return "GL_UNSIGNED_INT_10_10_10_2"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8038: + return "GL_POLYGON_OFFSET_FACTOR"; + case 0x803A: + return "GL_RESCALE_NORMAL"; + case 0x803B: + return "GL_ALPHA4"; + case 0x803C: + return "GL_ALPHA8"; + case 0x803D: + return "GL_ALPHA12"; + case 0x803E: + return "GL_ALPHA16"; + case 0x803F: + return "GL_LUMINANCE4"; + case 0x8040: + return "GL_LUMINANCE8"; + case 0x8041: + return "GL_LUMINANCE12"; + case 0x8042: + return "GL_LUMINANCE16"; + case 0x8043: + return "GL_LUMINANCE4_ALPHA4"; + case 0x8044: + return "GL_LUMINANCE6_ALPHA2"; + case 0x8045: + return "GL_LUMINANCE8_ALPHA8"; + case 0x8046: + return "GL_LUMINANCE12_ALPHA4"; + case 0x8047: + return "GL_LUMINANCE12_ALPHA12"; + case 0x8048: + return "GL_LUMINANCE16_ALPHA16"; + case 0x8049: + return "GL_INTENSITY"; + case 0x804A: + return "GL_INTENSITY4"; + case 0x804B: + return "GL_INTENSITY8"; + case 0x804C: + return "GL_INTENSITY12"; + case 0x804D: + return "GL_INTENSITY16"; + case 0x804F: + return "GL_RGB4"; + case 0x8050: + return "GL_RGB5"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10"; + case 0x8053: + return "GL_RGB12"; + case 0x8054: + return "GL_RGB16"; + case 0x8055: + return "GL_RGBA2"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805A: + return "GL_RGBA12"; + case 0x805B: + return "GL_RGBA16"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8060: + return "GL_TEXTURE_LUMINANCE_SIZE"; + case 0x8061: + return "GL_TEXTURE_INTENSITY_SIZE"; + case 0x8063: + return "GL_PROXY_TEXTURE_1D"; + case 0x8064: + return "GL_PROXY_TEXTURE_2D"; + case 0x8066: + return "GL_TEXTURE_PRIORITY"; + case 0x8067: + return "GL_TEXTURE_RESIDENT"; + case 0x8068: + return "GL_TEXTURE_BINDING_1D"; + case 0x8069: + return "GL_TEXTURE_BINDING_2D"; + case 0x806A: + return "GL_TEXTURE_BINDING_3D"; + case 0x806B: + return "GL_PACK_SKIP_IMAGES"; + case 0x806C: + return "GL_PACK_IMAGE_HEIGHT"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + case 0x806F: + return "GL_TEXTURE_3D"; + case 0x8070: + return "GL_PROXY_TEXTURE_3D"; + case 0x8071: + return "GL_TEXTURE_DEPTH"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; + case 0x8073: + return "GL_MAX_3D_TEXTURE_SIZE"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8077: + return "GL_INDEX_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x8079: + return "GL_EDGE_FLAG_ARRAY"; + case 0x807A: + return "GL_VERTEX_ARRAY_SIZE"; + case 0x807B: + return "GL_VERTEX_ARRAY_TYPE"; + case 0x807C: + return "GL_VERTEX_ARRAY_STRIDE"; + case 0x807E: + return "GL_NORMAL_ARRAY_TYPE"; + case 0x807F: + return "GL_NORMAL_ARRAY_STRIDE"; + case 0x8081: + return "GL_COLOR_ARRAY_SIZE"; + case 0x8082: + return "GL_COLOR_ARRAY_TYPE"; + case 0x8083: + return "GL_COLOR_ARRAY_STRIDE"; + case 0x8085: + return "GL_INDEX_ARRAY_TYPE"; + case 0x8086: + return "GL_INDEX_ARRAY_STRIDE"; + case 0x8088: + return "GL_TEXTURE_COORD_ARRAY_SIZE"; + case 0x8089: + return "GL_TEXTURE_COORD_ARRAY_TYPE"; + case 0x808A: + return "GL_TEXTURE_COORD_ARRAY_STRIDE"; + case 0x808C: + return "GL_EDGE_FLAG_ARRAY_STRIDE"; + case 0x808E: + return "GL_VERTEX_ARRAY_POINTER"; + case 0x808F: + return "GL_NORMAL_ARRAY_POINTER"; + case 0x8090: + return "GL_COLOR_ARRAY_POINTER"; + case 0x8091: + return "GL_INDEX_ARRAY_POINTER"; + case 0x8092: + return "GL_TEXTURE_COORD_ARRAY_POINTER"; + case 0x8093: + return "GL_EDGE_FLAG_ARRAY_POINTER"; + case 0x809D: + return "GL_MULTISAMPLE"; + case 0x809E: + return "GL_SAMPLE_ALPHA_TO_COVERAGE"; + case 0x809F: + return "GL_SAMPLE_ALPHA_TO_ONE"; + case 0x80A0: + return "GL_SAMPLE_COVERAGE"; + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; + case 0x80AA: + return "GL_SAMPLE_COVERAGE_VALUE"; + case 0x80AB: + return "GL_SAMPLE_COVERAGE_INVERT"; + case 0x80C8: + return "GL_BLEND_DST_RGB"; + case 0x80C9: + return "GL_BLEND_SRC_RGB"; + case 0x80CA: + return "GL_BLEND_DST_ALPHA"; + case 0x80CB: + return "GL_BLEND_SRC_ALPHA"; + case 0x80D0: + return "GL_COLOR_TABLE"; + case 0x80D1: + return "GL_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D2: + return "GL_POST_COLOR_MATRIX_COLOR_TABLE"; + case 0x80D3: + return "GL_PROXY_COLOR_TABLE"; + case 0x80D4: + return "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D5: + return "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE"; + case 0x80E0: + return "GL_BGR"; + case 0x80E1: + return "GL_BGRA"; + case 0x80E8: + return "GL_MAX_ELEMENTS_VERTICES"; + case 0x80E9: + return "GL_MAX_ELEMENTS_INDICES"; + case 0x80EE: + return "GL_PARAMETER_BUFFER"; + case 0x80EF: + return "GL_PARAMETER_BUFFER_BINDING"; + case 0x8126: + return "GL_POINT_SIZE_MIN"; + case 0x8127: + return "GL_POINT_SIZE_MAX"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x8129: + return "GL_POINT_DISTANCE_ATTENUATION"; + case 0x812D: + return "GL_CLAMP_TO_BORDER"; + case 0x812F: + return "GL_CLAMP_TO_EDGE"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + case 0x813C: + return "GL_TEXTURE_BASE_LEVEL"; + case 0x813D: + return "GL_TEXTURE_MAX_LEVEL"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x8192: + return "GL_GENERATE_MIPMAP_HINT"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; + case 0x81A6: + return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32"; + case 0x81F8: + return "GL_LIGHT_MODEL_COLOR_CONTROL"; + case 0x81F9: + return "GL_SINGLE_COLOR"; + case 0x81FA: + return "GL_SEPARATE_SPECULAR_COLOR"; + case 0x8210: + return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; + case 0x8211: + return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; + case 0x8212: + return "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"; + case 0x8213: + return "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; + case 0x8214: + return "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; + case 0x8215: + return "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; + case 0x8216: + return "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; + case 0x8217: + return "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; + case 0x8218: + return "GL_FRAMEBUFFER_DEFAULT"; + case 0x8219: + return "GL_FRAMEBUFFER_UNDEFINED"; + case 0x821A: + return "GL_DEPTH_STENCIL_ATTACHMENT"; + case 0x821B: + return "GL_MAJOR_VERSION"; + case 0x821C: + return "GL_MINOR_VERSION"; + case 0x821D: + return "GL_NUM_EXTENSIONS"; + case 0x821E: + return "GL_CONTEXT_FLAGS"; + case 0x821F: + return "GL_BUFFER_IMMUTABLE_STORAGE"; + case 0x8220: + return "GL_BUFFER_STORAGE_FLAGS"; + case 0x8221: + return "GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED"; + case 0x8222: + return "GL_INDEX"; + case 0x8225: + return "GL_COMPRESSED_RED"; + case 0x8226: + return "GL_COMPRESSED_RG"; + case 0x8227: + return "GL_RG"; + case 0x8228: + return "GL_RG_INTEGER"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; + case 0x8242: + return "GL_DEBUG_OUTPUT_SYNCHRONOUS"; + case 0x8243: + return "GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH"; + case 0x8244: + return "GL_DEBUG_CALLBACK_FUNCTION"; + case 0x8245: + return "GL_DEBUG_CALLBACK_USER_PARAM"; + case 0x8246: + return "GL_DEBUG_SOURCE_API"; + case 0x8247: + return "GL_DEBUG_SOURCE_WINDOW_SYSTEM"; + case 0x8248: + return "GL_DEBUG_SOURCE_SHADER_COMPILER"; + case 0x8249: + return "GL_DEBUG_SOURCE_THIRD_PARTY"; + case 0x824A: + return "GL_DEBUG_SOURCE_APPLICATION"; + case 0x824B: + return "GL_DEBUG_SOURCE_OTHER"; + case 0x824C: + return "GL_DEBUG_TYPE_ERROR"; + case 0x824D: + return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"; + case 0x824E: + return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"; + case 0x824F: + return "GL_DEBUG_TYPE_PORTABILITY"; + case 0x8250: + return "GL_DEBUG_TYPE_PERFORMANCE"; + case 0x8251: + return "GL_DEBUG_TYPE_OTHER"; + case 0x8252: + return "GL_LOSE_CONTEXT_ON_RESET"; + case 0x8253: + return "GL_GUILTY_CONTEXT_RESET"; + case 0x8254: + return "GL_INNOCENT_CONTEXT_RESET"; + case 0x8255: + return "GL_UNKNOWN_CONTEXT_RESET"; + case 0x8256: + return "GL_RESET_NOTIFICATION_STRATEGY"; + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; + case 0x8258: + return "GL_PROGRAM_SEPARABLE"; + case 0x8259: + return "GL_ACTIVE_PROGRAM"; + case 0x825A: + return "GL_PROGRAM_PIPELINE_BINDING"; + case 0x825B: + return "GL_MAX_VIEWPORTS"; + case 0x825C: + return "GL_VIEWPORT_SUBPIXEL_BITS"; + case 0x825D: + return "GL_VIEWPORT_BOUNDS_RANGE"; + case 0x825E: + return "GL_LAYER_PROVOKING_VERTEX"; + case 0x825F: + return "GL_VIEWPORT_INDEX_PROVOKING_VERTEX"; + case 0x8260: + return "GL_UNDEFINED_VERTEX"; + case 0x8261: + return "GL_NO_RESET_NOTIFICATION"; + case 0x8262: + return "GL_MAX_COMPUTE_SHARED_MEMORY_SIZE"; + case 0x8263: + return "GL_MAX_COMPUTE_UNIFORM_COMPONENTS"; + case 0x8264: + return "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS"; + case 0x8265: + return "GL_MAX_COMPUTE_ATOMIC_COUNTERS"; + case 0x8266: + return "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS"; + case 0x8267: + return "GL_COMPUTE_WORK_GROUP_SIZE"; + case 0x8268: + return "GL_DEBUG_TYPE_MARKER"; + case 0x8269: + return "GL_DEBUG_TYPE_PUSH_GROUP"; + case 0x826A: + return "GL_DEBUG_TYPE_POP_GROUP"; + case 0x826B: + return "GL_DEBUG_SEVERITY_NOTIFICATION"; + case 0x826C: + return "GL_MAX_DEBUG_GROUP_STACK_DEPTH"; + case 0x826D: + return "GL_DEBUG_GROUP_STACK_DEPTH"; + case 0x826E: + return "GL_MAX_UNIFORM_LOCATIONS"; + case 0x826F: + return "GL_INTERNALFORMAT_SUPPORTED"; + case 0x8270: + return "GL_INTERNALFORMAT_PREFERRED"; + case 0x8271: + return "GL_INTERNALFORMAT_RED_SIZE"; + case 0x8272: + return "GL_INTERNALFORMAT_GREEN_SIZE"; + case 0x8273: + return "GL_INTERNALFORMAT_BLUE_SIZE"; + case 0x8274: + return "GL_INTERNALFORMAT_ALPHA_SIZE"; + case 0x8275: + return "GL_INTERNALFORMAT_DEPTH_SIZE"; + case 0x8276: + return "GL_INTERNALFORMAT_STENCIL_SIZE"; + case 0x8277: + return "GL_INTERNALFORMAT_SHARED_SIZE"; + case 0x8278: + return "GL_INTERNALFORMAT_RED_TYPE"; + case 0x8279: + return "GL_INTERNALFORMAT_GREEN_TYPE"; + case 0x827A: + return "GL_INTERNALFORMAT_BLUE_TYPE"; + case 0x827B: + return "GL_INTERNALFORMAT_ALPHA_TYPE"; + case 0x827C: + return "GL_INTERNALFORMAT_DEPTH_TYPE"; + case 0x827D: + return "GL_INTERNALFORMAT_STENCIL_TYPE"; + case 0x827E: + return "GL_MAX_WIDTH"; + case 0x827F: + return "GL_MAX_HEIGHT"; + case 0x8280: + return "GL_MAX_DEPTH"; + case 0x8281: + return "GL_MAX_LAYERS"; + case 0x8282: + return "GL_MAX_COMBINED_DIMENSIONS"; + case 0x8283: + return "GL_COLOR_COMPONENTS"; + case 0x8284: + return "GL_DEPTH_COMPONENTS"; + case 0x8285: + return "GL_STENCIL_COMPONENTS"; + case 0x8286: + return "GL_COLOR_RENDERABLE"; + case 0x8287: + return "GL_DEPTH_RENDERABLE"; + case 0x8288: + return "GL_STENCIL_RENDERABLE"; + case 0x8289: + return "GL_FRAMEBUFFER_RENDERABLE"; + case 0x828A: + return "GL_FRAMEBUFFER_RENDERABLE_LAYERED"; + case 0x828B: + return "GL_FRAMEBUFFER_BLEND"; + case 0x828C: + return "GL_READ_PIXELS"; + case 0x828D: + return "GL_READ_PIXELS_FORMAT"; + case 0x828E: + return "GL_READ_PIXELS_TYPE"; + case 0x828F: + return "GL_TEXTURE_IMAGE_FORMAT"; + case 0x8290: + return "GL_TEXTURE_IMAGE_TYPE"; + case 0x8291: + return "GL_GET_TEXTURE_IMAGE_FORMAT"; + case 0x8292: + return "GL_GET_TEXTURE_IMAGE_TYPE"; + case 0x8293: + return "GL_MIPMAP"; + case 0x8294: + return "GL_MANUAL_GENERATE_MIPMAP"; + case 0x8295: + return "GL_AUTO_GENERATE_MIPMAP"; + case 0x8296: + return "GL_COLOR_ENCODING"; + case 0x8297: + return "GL_SRGB_READ"; + case 0x8298: + return "GL_SRGB_WRITE"; + case 0x829A: + return "GL_FILTER"; + case 0x829B: + return "GL_VERTEX_TEXTURE"; + case 0x829C: + return "GL_TESS_CONTROL_TEXTURE"; + case 0x829D: + return "GL_TESS_EVALUATION_TEXTURE"; + case 0x829E: + return "GL_GEOMETRY_TEXTURE"; + case 0x829F: + return "GL_FRAGMENT_TEXTURE"; + case 0x82A0: + return "GL_COMPUTE_TEXTURE"; + case 0x82A1: + return "GL_TEXTURE_SHADOW"; + case 0x82A2: + return "GL_TEXTURE_GATHER"; + case 0x82A3: + return "GL_TEXTURE_GATHER_SHADOW"; + case 0x82A4: + return "GL_SHADER_IMAGE_LOAD"; + case 0x82A5: + return "GL_SHADER_IMAGE_STORE"; + case 0x82A6: + return "GL_SHADER_IMAGE_ATOMIC"; + case 0x82A7: + return "GL_IMAGE_TEXEL_SIZE"; + case 0x82A8: + return "GL_IMAGE_COMPATIBILITY_CLASS"; + case 0x82A9: + return "GL_IMAGE_PIXEL_FORMAT"; + case 0x82AA: + return "GL_IMAGE_PIXEL_TYPE"; + case 0x82AC: + return "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST"; + case 0x82AD: + return "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST"; + case 0x82AE: + return "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE"; + case 0x82AF: + return "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE"; + case 0x82B1: + return "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH"; + case 0x82B2: + return "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT"; + case 0x82B3: + return "GL_TEXTURE_COMPRESSED_BLOCK_SIZE"; + case 0x82B4: + return "GL_CLEAR_BUFFER"; + case 0x82B5: + return "GL_TEXTURE_VIEW"; + case 0x82B6: + return "GL_VIEW_COMPATIBILITY_CLASS"; + case 0x82B7: + return "GL_FULL_SUPPORT"; + case 0x82B8: + return "GL_CAVEAT_SUPPORT"; + case 0x82B9: + return "GL_IMAGE_CLASS_4_X_32"; + case 0x82BA: + return "GL_IMAGE_CLASS_2_X_32"; + case 0x82BB: + return "GL_IMAGE_CLASS_1_X_32"; + case 0x82BC: + return "GL_IMAGE_CLASS_4_X_16"; + case 0x82BD: + return "GL_IMAGE_CLASS_2_X_16"; + case 0x82BE: + return "GL_IMAGE_CLASS_1_X_16"; + case 0x82BF: + return "GL_IMAGE_CLASS_4_X_8"; + case 0x82C0: + return "GL_IMAGE_CLASS_2_X_8"; + case 0x82C1: + return "GL_IMAGE_CLASS_1_X_8"; + case 0x82C2: + return "GL_IMAGE_CLASS_11_11_10"; + case 0x82C3: + return "GL_IMAGE_CLASS_10_10_10_2"; + case 0x82C4: + return "GL_VIEW_CLASS_128_BITS"; + case 0x82C5: + return "GL_VIEW_CLASS_96_BITS"; + case 0x82C6: + return "GL_VIEW_CLASS_64_BITS"; + case 0x82C7: + return "GL_VIEW_CLASS_48_BITS"; + case 0x82C8: + return "GL_VIEW_CLASS_32_BITS"; + case 0x82C9: + return "GL_VIEW_CLASS_24_BITS"; + case 0x82CA: + return "GL_VIEW_CLASS_16_BITS"; + case 0x82CB: + return "GL_VIEW_CLASS_8_BITS"; + case 0x82CC: + return "GL_VIEW_CLASS_S3TC_DXT1_RGB"; + case 0x82CD: + return "GL_VIEW_CLASS_S3TC_DXT1_RGBA"; + case 0x82CE: + return "GL_VIEW_CLASS_S3TC_DXT3_RGBA"; + case 0x82CF: + return "GL_VIEW_CLASS_S3TC_DXT5_RGBA"; + case 0x82D0: + return "GL_VIEW_CLASS_RGTC1_RED"; + case 0x82D1: + return "GL_VIEW_CLASS_RGTC2_RG"; + case 0x82D2: + return "GL_VIEW_CLASS_BPTC_UNORM"; + case 0x82D3: + return "GL_VIEW_CLASS_BPTC_FLOAT"; + case 0x82D4: + return "GL_VERTEX_ATTRIB_BINDING"; + case 0x82D5: + return "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x82D6: + return "GL_VERTEX_BINDING_DIVISOR"; + case 0x82D7: + return "GL_VERTEX_BINDING_OFFSET"; + case 0x82D8: + return "GL_VERTEX_BINDING_STRIDE"; + case 0x82D9: + return "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x82DA: + return "GL_MAX_VERTEX_ATTRIB_BINDINGS"; + case 0x82DB: + return "GL_TEXTURE_VIEW_MIN_LEVEL"; + case 0x82DC: + return "GL_TEXTURE_VIEW_NUM_LEVELS"; + case 0x82DD: + return "GL_TEXTURE_VIEW_MIN_LAYER"; + case 0x82DE: + return "GL_TEXTURE_VIEW_NUM_LAYERS"; + case 0x82DF: + return "GL_TEXTURE_IMMUTABLE_LEVELS"; + case 0x82E0: + return "GL_BUFFER"; + case 0x82E1: + return "GL_SHADER"; + case 0x82E2: + return "GL_PROGRAM"; + case 0x82E3: + return "GL_QUERY"; + case 0x82E4: + return "GL_PROGRAM_PIPELINE"; + case 0x82E5: + return "GL_MAX_VERTEX_ATTRIB_STRIDE"; + case 0x82E6: + return "GL_SAMPLER"; + case 0x82E7: + return "GL_DISPLAY_LIST"; + case 0x82E8: + return "GL_MAX_LABEL_LENGTH"; + case 0x82E9: + return "GL_NUM_SHADING_LANGUAGE_VERSIONS"; + case 0x82EA: + return "GL_QUERY_TARGET"; + case 0x82EC: + return "GL_TRANSFORM_FEEDBACK_OVERFLOW"; + case 0x82ED: + return "GL_TRANSFORM_FEEDBACK_STREAM_OVERFLOW"; + case 0x82EE: + return "GL_VERTICES_SUBMITTED"; + case 0x82EF: + return "GL_PRIMITIVES_SUBMITTED"; + case 0x82F0: + return "GL_VERTEX_SHADER_INVOCATIONS"; + case 0x82F1: + return "GL_TESS_CONTROL_SHADER_PATCHES"; + case 0x82F2: + return "GL_TESS_EVALUATION_SHADER_INVOCATIONS"; + case 0x82F3: + return "GL_GEOMETRY_SHADER_PRIMITIVES_EMITTED"; + case 0x82F4: + return "GL_FRAGMENT_SHADER_INVOCATIONS"; + case 0x82F5: + return "GL_COMPUTE_SHADER_INVOCATIONS"; + case 0x82F6: + return "GL_CLIPPING_INPUT_PRIMITIVES"; + case 0x82F7: + return "GL_CLIPPING_OUTPUT_PRIMITIVES"; + case 0x82F9: + return "GL_MAX_CULL_DISTANCES"; + case 0x82FA: + return "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES"; + case 0x82FB: + return "GL_CONTEXT_RELEASE_BEHAVIOR"; + case 0x82FC: + return "GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH"; + case 0x8362: + return "GL_UNSIGNED_BYTE_2_3_3_REV"; + case 0x8363: + return "GL_UNSIGNED_SHORT_5_6_5"; + case 0x8364: + return "GL_UNSIGNED_SHORT_5_6_5_REV"; + case 0x8365: + return "GL_UNSIGNED_SHORT_4_4_4_4_REV"; + case 0x8366: + return "GL_UNSIGNED_SHORT_1_5_5_5_REV"; + case 0x8367: + return "GL_UNSIGNED_INT_8_8_8_8_REV"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; + case 0x8370: + return "GL_MIRRORED_REPEAT"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; + case 0x8450: + return "GL_FOG_COORDINATE_SOURCE"; + case 0x8451: + return "GL_FOG_COORD"; + case 0x8452: + return "GL_FRAGMENT_DEPTH"; + case 0x8453: + return "GL_CURRENT_FOG_COORD"; + case 0x8454: + return "GL_FOG_COORDINATE_ARRAY_TYPE"; + case 0x8455: + return "GL_FOG_COORDINATE_ARRAY_STRIDE"; + case 0x8456: + return "GL_FOG_COORDINATE_ARRAY_POINTER"; + case 0x8457: + return "GL_FOG_COORDINATE_ARRAY"; + case 0x8458: + return "GL_COLOR_SUM"; + case 0x8459: + return "GL_CURRENT_SECONDARY_COLOR"; + case 0x845A: + return "GL_SECONDARY_COLOR_ARRAY_SIZE"; + case 0x845B: + return "GL_SECONDARY_COLOR_ARRAY_TYPE"; + case 0x845C: + return "GL_SECONDARY_COLOR_ARRAY_STRIDE"; + case 0x845D: + return "GL_SECONDARY_COLOR_ARRAY_POINTER"; + case 0x845E: + return "GL_SECONDARY_COLOR_ARRAY"; + case 0x845F: + return "GL_CURRENT_RASTER_SECONDARY_COLOR"; + case 0x846D: + return "GL_ALIASED_POINT_SIZE_RANGE"; + case 0x846E: + return "GL_ALIASED_LINE_WIDTH_RANGE"; + case 0x84C0: + return "GL_TEXTURE0"; + case 0x84C1: + return "GL_TEXTURE1"; + case 0x84C2: + return "GL_TEXTURE2"; + case 0x84C3: + return "GL_TEXTURE3"; + case 0x84C4: + return "GL_TEXTURE4"; + case 0x84C5: + return "GL_TEXTURE5"; + case 0x84C6: + return "GL_TEXTURE6"; + case 0x84C7: + return "GL_TEXTURE7"; + case 0x84C8: + return "GL_TEXTURE8"; + case 0x84C9: + return "GL_TEXTURE9"; + case 0x84CA: + return "GL_TEXTURE10"; + case 0x84CB: + return "GL_TEXTURE11"; + case 0x84CC: + return "GL_TEXTURE12"; + case 0x84CD: + return "GL_TEXTURE13"; + case 0x84CE: + return "GL_TEXTURE14"; + case 0x84CF: + return "GL_TEXTURE15"; + case 0x84D0: + return "GL_TEXTURE16"; + case 0x84D1: + return "GL_TEXTURE17"; + case 0x84D2: + return "GL_TEXTURE18"; + case 0x84D3: + return "GL_TEXTURE19"; + case 0x84D4: + return "GL_TEXTURE20"; + case 0x84D5: + return "GL_TEXTURE21"; + case 0x84D6: + return "GL_TEXTURE22"; + case 0x84D7: + return "GL_TEXTURE23"; + case 0x84D8: + return "GL_TEXTURE24"; + case 0x84D9: + return "GL_TEXTURE25"; + case 0x84DA: + return "GL_TEXTURE26"; + case 0x84DB: + return "GL_TEXTURE27"; + case 0x84DC: + return "GL_TEXTURE28"; + case 0x84DD: + return "GL_TEXTURE29"; + case 0x84DE: + return "GL_TEXTURE30"; + case 0x84DF: + return "GL_TEXTURE31"; + case 0x84E0: + return "GL_ACTIVE_TEXTURE"; + case 0x84E1: + return "GL_CLIENT_ACTIVE_TEXTURE"; + case 0x84E2: + return "GL_MAX_TEXTURE_UNITS"; + case 0x84E3: + return "GL_TRANSPOSE_MODELVIEW_MATRIX"; + case 0x84E4: + return "GL_TRANSPOSE_PROJECTION_MATRIX"; + case 0x84E5: + return "GL_TRANSPOSE_TEXTURE_MATRIX"; + case 0x84E6: + return "GL_TRANSPOSE_COLOR_MATRIX"; + case 0x84E7: + return "GL_SUBTRACT"; + case 0x84E8: + return "GL_MAX_RENDERBUFFER_SIZE"; + case 0x84E9: + return "GL_COMPRESSED_ALPHA"; + case 0x84EA: + return "GL_COMPRESSED_LUMINANCE"; + case 0x84EB: + return "GL_COMPRESSED_LUMINANCE_ALPHA"; + case 0x84EC: + return "GL_COMPRESSED_INTENSITY"; + case 0x84ED: + return "GL_COMPRESSED_RGB"; + case 0x84EE: + return "GL_COMPRESSED_RGBA"; + case 0x84EF: + return "GL_TEXTURE_COMPRESSION_HINT"; + case 0x84F0: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x84F1: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x84F2: + return "GL_ALL_COMPLETED_NV"; + case 0x84F3: + return "GL_FENCE_STATUS_NV"; + case 0x84F4: + return "GL_FENCE_CONDITION_NV"; + case 0x84F5: + return "GL_TEXTURE_RECTANGLE"; + case 0x84F6: + return "GL_TEXTURE_BINDING_RECTANGLE"; + case 0x84F7: + return "GL_PROXY_TEXTURE_RECTANGLE"; + case 0x84F8: + return "GL_MAX_RECTANGLE_TEXTURE_SIZE"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; + case 0x84FA: + return "GL_UNSIGNED_INT_24_8"; + case 0x84FD: + return "GL_MAX_TEXTURE_LOD_BIAS"; + case 0x84FE: + return "GL_TEXTURE_MAX_ANISOTROPY"; + case 0x84FF: + return "GL_MAX_TEXTURE_MAX_ANISOTROPY"; + case 0x8500: + return "GL_TEXTURE_FILTER_CONTROL"; + case 0x8501: + return "GL_TEXTURE_LOD_BIAS"; + case 0x8507: + return "GL_INCR_WRAP"; + case 0x8508: + return "GL_DECR_WRAP"; + case 0x8511: + return "GL_NORMAL_MAP"; + case 0x8512: + return "GL_REFLECTION_MAP"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8514: + return "GL_TEXTURE_BINDING_CUBE_MAP"; + case 0x8515: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; + case 0x8516: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; + case 0x8517: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; + case 0x8518: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; + case 0x8519: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; + case 0x851A: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; + case 0x851B: + return "GL_PROXY_TEXTURE_CUBE_MAP"; + case 0x851C: + return "GL_MAX_CUBE_MAP_TEXTURE_SIZE"; + case 0x8570: + return "GL_COMBINE"; + case 0x8571: + return "GL_COMBINE_RGB"; + case 0x8572: + return "GL_COMBINE_ALPHA"; + case 0x8573: + return "GL_RGB_SCALE"; + case 0x8574: + return "GL_ADD_SIGNED"; + case 0x8575: + return "GL_INTERPOLATE"; + case 0x8576: + return "GL_CONSTANT"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + case 0x8578: + return "GL_PREVIOUS"; + case 0x8580: + return "GL_SOURCE0_RGB"; + case 0x8581: + return "GL_SOURCE1_RGB"; + case 0x8582: + return "GL_SOURCE2_RGB"; + case 0x8588: + return "GL_SOURCE0_ALPHA"; + case 0x8589: + return "GL_SOURCE1_ALPHA"; + case 0x858A: + return "GL_SOURCE2_ALPHA"; + case 0x8590: + return "GL_OPERAND0_RGB"; + case 0x8591: + return "GL_OPERAND1_RGB"; + case 0x8592: + return "GL_OPERAND2_RGB"; + case 0x8598: + return "GL_OPERAND0_ALPHA"; + case 0x8599: + return "GL_OPERAND1_ALPHA"; + case 0x859A: + return "GL_OPERAND2_ALPHA"; + case 0x85B5: + return "GL_VERTEX_ARRAY_BINDING"; + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x8626: + return "GL_CURRENT_VERTEX_ATTRIB"; + case 0x8642: + return "GL_PROGRAM_POINT_SIZE"; + case 0x8643: + return "GL_VERTEX_PROGRAM_TWO_SIDE"; + case 0x8645: + return "GL_VERTEX_ATTRIB_ARRAY_POINTER"; + case 0x864F: + return "GL_DEPTH_CLAMP"; + case 0x86A0: + return "GL_TEXTURE_COMPRESSED_IMAGE_SIZE"; + case 0x86A1: + return "GL_TEXTURE_COMPRESSED"; + case 0x86A2: + return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; + case 0x86A3: + return "GL_COMPRESSED_TEXTURE_FORMATS"; + case 0x86AE: + return "GL_DOT3_RGB"; + case 0x86AF: + return "GL_DOT3_RGBA"; + case 0x8741: + return "GL_PROGRAM_BINARY_LENGTH"; + case 0x8743: + return "GL_MIRROR_CLAMP_TO_EDGE"; + case 0x874E: + return "GL_VERTEX_ATTRIB_ARRAY_LONG"; + case 0x8764: + return "GL_BUFFER_SIZE"; + case 0x8765: + return "GL_BUFFER_USAGE"; + case 0x87FE: + return "GL_NUM_PROGRAM_BINARY_FORMATS"; + case 0x87FF: + return "GL_PROGRAM_BINARY_FORMATS"; + case 0x8800: + return "GL_STENCIL_BACK_FUNC"; + case 0x8801: + return "GL_STENCIL_BACK_FAIL"; + case 0x8802: + return "GL_STENCIL_BACK_PASS_DEPTH_FAIL"; + case 0x8803: + return "GL_STENCIL_BACK_PASS_DEPTH_PASS"; + case 0x8814: + return "GL_RGBA32F"; + case 0x8815: + return "GL_RGB32F"; + case 0x8816: + return "GL_ALPHA32F_EXT"; + case 0x8818: + return "GL_LUMINANCE32F_EXT"; + case 0x8819: + return "GL_LUMINANCE_ALPHA32F_EXT"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; + case 0x881C: + return "GL_ALPHA16F_EXT"; + case 0x881E: + return "GL_LUMINANCE16F_EXT"; + case 0x881F: + return "GL_LUMINANCE_ALPHA16F_EXT"; + case 0x8824: + return "GL_MAX_DRAW_BUFFERS"; + case 0x8825: + return "GL_DRAW_BUFFER0"; + case 0x8826: + return "GL_DRAW_BUFFER1"; + case 0x8827: + return "GL_DRAW_BUFFER2"; + case 0x8828: + return "GL_DRAW_BUFFER3"; + case 0x8829: + return "GL_DRAW_BUFFER4"; + case 0x882A: + return "GL_DRAW_BUFFER5"; + case 0x882B: + return "GL_DRAW_BUFFER6"; + case 0x882C: + return "GL_DRAW_BUFFER7"; + case 0x882D: + return "GL_DRAW_BUFFER8"; + case 0x882E: + return "GL_DRAW_BUFFER9"; + case 0x882F: + return "GL_DRAW_BUFFER10"; + case 0x8830: + return "GL_DRAW_BUFFER11"; + case 0x8831: + return "GL_DRAW_BUFFER12"; + case 0x8832: + return "GL_DRAW_BUFFER13"; + case 0x8833: + return "GL_DRAW_BUFFER14"; + case 0x8834: + return "GL_DRAW_BUFFER15"; + case 0x883D: + return "GL_BLEND_EQUATION_ALPHA"; + case 0x884A: + return "GL_TEXTURE_DEPTH_SIZE"; + case 0x884B: + return "GL_DEPTH_TEXTURE_MODE"; + case 0x884C: + return "GL_TEXTURE_COMPARE_MODE"; + case 0x884D: + return "GL_TEXTURE_COMPARE_FUNC"; + case 0x884E: + return "GL_COMPARE_REF_TO_TEXTURE"; + case 0x884F: + return "GL_TEXTURE_CUBE_MAP_SEAMLESS"; + case 0x8861: + return "GL_POINT_SPRITE"; + case 0x8862: + return "GL_COORD_REPLACE"; + case 0x8864: + return "GL_QUERY_COUNTER_BITS"; + case 0x8865: + return "GL_CURRENT_QUERY"; + case 0x8866: + return "GL_QUERY_RESULT"; + case 0x8867: + return "GL_QUERY_RESULT_AVAILABLE"; + case 0x8869: + return "GL_MAX_VERTEX_ATTRIBS"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; + case 0x886C: + return "GL_MAX_TESS_CONTROL_INPUT_COMPONENTS"; + case 0x886D: + return "GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS"; + case 0x8871: + return "GL_MAX_TEXTURE_COORDS"; + case 0x8872: + return "GL_MAX_TEXTURE_IMAGE_UNITS"; + case 0x887F: + return "GL_GEOMETRY_SHADER_INVOCATIONS"; + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x8894: + return "GL_ARRAY_BUFFER_BINDING"; + case 0x8895: + return "GL_ELEMENT_ARRAY_BUFFER_BINDING"; + case 0x8896: + return "GL_VERTEX_ARRAY_BUFFER_BINDING"; + case 0x8897: + return "GL_NORMAL_ARRAY_BUFFER_BINDING"; + case 0x8898: + return "GL_COLOR_ARRAY_BUFFER_BINDING"; + case 0x8899: + return "GL_INDEX_ARRAY_BUFFER_BINDING"; + case 0x889A: + return "GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING"; + case 0x889B: + return "GL_EDGE_FLAG_ARRAY_BUFFER_BINDING"; + case 0x889C: + return "GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING"; + case 0x889D: + return "GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING"; + case 0x889E: + return "GL_WEIGHT_ARRAY_BUFFER_BINDING"; + case 0x889F: + return "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + case 0x88B8: + return "GL_READ_ONLY"; + case 0x88B9: + return "GL_WRITE_ONLY"; + case 0x88BA: + return "GL_READ_WRITE"; + case 0x88BB: + return "GL_BUFFER_ACCESS"; + case 0x88BC: + return "GL_BUFFER_MAPPED"; + case 0x88BD: + return "GL_BUFFER_MAP_POINTER"; + case 0x88BF: + return "GL_TIME_ELAPSED"; + case 0x88E0: + return "GL_STREAM_DRAW"; + case 0x88E1: + return "GL_STREAM_READ"; + case 0x88E2: + return "GL_STREAM_COPY"; + case 0x88E4: + return "GL_STATIC_DRAW"; + case 0x88E5: + return "GL_STATIC_READ"; + case 0x88E6: + return "GL_STATIC_COPY"; + case 0x88E8: + return "GL_DYNAMIC_DRAW"; + case 0x88E9: + return "GL_DYNAMIC_READ"; + case 0x88EA: + return "GL_DYNAMIC_COPY"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x88ED: + return "GL_PIXEL_PACK_BUFFER_BINDING"; + case 0x88EF: + return "GL_PIXEL_UNPACK_BUFFER_BINDING"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; + case 0x88F1: + return "GL_TEXTURE_STENCIL_SIZE"; + case 0x88F9: + return "GL_SRC1_COLOR"; + case 0x88FA: + return "GL_ONE_MINUS_SRC1_COLOR"; + case 0x88FB: + return "GL_ONE_MINUS_SRC1_ALPHA"; + case 0x88FC: + return "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; + case 0x88FE: + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; + case 0x88FF: + return "GL_MAX_ARRAY_TEXTURE_LAYERS"; + case 0x8904: + return "GL_MIN_PROGRAM_TEXEL_OFFSET"; + case 0x8905: + return "GL_MAX_PROGRAM_TEXEL_OFFSET"; + case 0x8914: + return "GL_SAMPLES_PASSED"; + case 0x8916: + return "GL_GEOMETRY_VERTICES_OUT"; + case 0x8917: + return "GL_GEOMETRY_INPUT_TYPE"; + case 0x8918: + return "GL_GEOMETRY_OUTPUT_TYPE"; + case 0x8919: + return "GL_SAMPLER_BINDING"; + case 0x891A: + return "GL_CLAMP_VERTEX_COLOR"; + case 0x891B: + return "GL_CLAMP_FRAGMENT_COLOR"; + case 0x891C: + return "GL_CLAMP_READ_COLOR"; + case 0x891D: + return "GL_FIXED_ONLY"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8A28: + return "GL_UNIFORM_BUFFER_BINDING"; + case 0x8A29: + return "GL_UNIFORM_BUFFER_START"; + case 0x8A2A: + return "GL_UNIFORM_BUFFER_SIZE"; + case 0x8A2B: + return "GL_MAX_VERTEX_UNIFORM_BLOCKS"; + case 0x8A2C: + return "GL_MAX_GEOMETRY_UNIFORM_BLOCKS"; + case 0x8A2D: + return "GL_MAX_FRAGMENT_UNIFORM_BLOCKS"; + case 0x8A2E: + return "GL_MAX_COMBINED_UNIFORM_BLOCKS"; + case 0x8A2F: + return "GL_MAX_UNIFORM_BUFFER_BINDINGS"; + case 0x8A30: + return "GL_MAX_UNIFORM_BLOCK_SIZE"; + case 0x8A31: + return "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"; + case 0x8A32: + return "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8A33: + return "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8A34: + return "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT"; + case 0x8A35: + return "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"; + case 0x8A36: + return "GL_ACTIVE_UNIFORM_BLOCKS"; + case 0x8A37: + return "GL_UNIFORM_TYPE"; + case 0x8A38: + return "GL_UNIFORM_SIZE"; + case 0x8A39: + return "GL_UNIFORM_NAME_LENGTH"; + case 0x8A3A: + return "GL_UNIFORM_BLOCK_INDEX"; + case 0x8A3B: + return "GL_UNIFORM_OFFSET"; + case 0x8A3C: + return "GL_UNIFORM_ARRAY_STRIDE"; + case 0x8A3D: + return "GL_UNIFORM_MATRIX_STRIDE"; + case 0x8A3E: + return "GL_UNIFORM_IS_ROW_MAJOR"; + case 0x8A3F: + return "GL_UNIFORM_BLOCK_BINDING"; + case 0x8A40: + return "GL_UNIFORM_BLOCK_DATA_SIZE"; + case 0x8A41: + return "GL_UNIFORM_BLOCK_NAME_LENGTH"; + case 0x8A42: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS"; + case 0x8A43: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"; + case 0x8A44: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"; + case 0x8A45: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x8A46: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x8A48: + return "GL_TEXTURE_SRGB_DECODE_EXT"; + case 0x8A49: + return "GL_DECODE_EXT"; + case 0x8A4A: + return "GL_SKIP_DECODE_EXT"; + case 0x8A4F: + return "GL_PROGRAM_PIPELINE_OBJECT_EXT"; + case 0x8A52: + return "GL_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT"; + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; + case 0x8B40: + return "GL_PROGRAM_OBJECT_EXT"; + case 0x8B48: + return "GL_SHADER_OBJECT_EXT"; + case 0x8B49: + return "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8B4A: + return "GL_MAX_VERTEX_UNIFORM_COMPONENTS"; + case 0x8B4B: + return "GL_MAX_VARYING_COMPONENTS"; + case 0x8B4C: + return "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"; + case 0x8B4D: + return "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"; + case 0x8B4F: + return "GL_SHADER_TYPE"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5D: + return "GL_SAMPLER_1D"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B61: + return "GL_SAMPLER_1D_SHADOW"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B63: + return "GL_SAMPLER_2D_RECT"; + case 0x8B64: + return "GL_SAMPLER_2D_RECT_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B81: + return "GL_COMPILE_STATUS"; + case 0x8B82: + return "GL_LINK_STATUS"; + case 0x8B83: + return "GL_VALIDATE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B85: + return "GL_ATTACHED_SHADERS"; + case 0x8B86: + return "GL_ACTIVE_UNIFORMS"; + case 0x8B87: + return "GL_ACTIVE_UNIFORM_MAX_LENGTH"; + case 0x8B88: + return "GL_SHADER_SOURCE_LENGTH"; + case 0x8B89: + return "GL_ACTIVE_ATTRIBUTES"; + case 0x8B8A: + return "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + case 0x8B8C: + return "GL_SHADING_LANGUAGE_VERSION"; + case 0x8B8D: + return "GL_CURRENT_PROGRAM"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; + case 0x8BBB: + return "GL_FRAMEBUFFER_FLIP_Y_MESA"; + case 0x8BC0: + return "GL_COUNTER_TYPE_AMD"; + case 0x8BC1: + return "GL_COUNTER_RANGE_AMD"; + case 0x8BC2: + return "GL_UNSIGNED_INT64_AMD"; + case 0x8BC3: + return "GL_PERCENTAGE_AMD"; + case 0x8BC4: + return "GL_PERFMON_RESULT_AVAILABLE_AMD"; + case 0x8BC5: + return "GL_PERFMON_RESULT_SIZE_AMD"; + case 0x8BC6: + return "GL_PERFMON_RESULT_AMD"; + case 0x8C10: + return "GL_TEXTURE_RED_TYPE"; + case 0x8C11: + return "GL_TEXTURE_GREEN_TYPE"; + case 0x8C12: + return "GL_TEXTURE_BLUE_TYPE"; + case 0x8C13: + return "GL_TEXTURE_ALPHA_TYPE"; + case 0x8C14: + return "GL_TEXTURE_LUMINANCE_TYPE"; + case 0x8C15: + return "GL_TEXTURE_INTENSITY_TYPE"; + case 0x8C16: + return "GL_TEXTURE_DEPTH_TYPE"; + case 0x8C17: + return "GL_UNSIGNED_NORMALIZED"; + case 0x8C18: + return "GL_TEXTURE_1D_ARRAY"; + case 0x8C19: + return "GL_PROXY_TEXTURE_1D_ARRAY"; + case 0x8C1A: + return "GL_TEXTURE_2D_ARRAY"; + case 0x8C1B: + return "GL_PROXY_TEXTURE_2D_ARRAY"; + case 0x8C1C: + return "GL_TEXTURE_BINDING_1D_ARRAY"; + case 0x8C1D: + return "GL_TEXTURE_BINDING_2D_ARRAY"; + case 0x8C29: + return "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C2B: + return "GL_MAX_TEXTURE_BUFFER_SIZE"; + case 0x8C2C: + return "GL_TEXTURE_BINDING_BUFFER"; + case 0x8C2D: + return "GL_TEXTURE_BUFFER_DATA_STORE_BINDING"; + case 0x8C2F: + return "GL_ANY_SAMPLES_PASSED"; + case 0x8C36: + return "GL_SAMPLE_SHADING"; + case 0x8C37: + return "GL_MIN_SAMPLE_SHADING_VALUE"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3B: + return "GL_UNSIGNED_INT_10F_11F_11F_REV"; + case 0x8C3D: + return "GL_RGB9_E5"; + case 0x8C3E: + return "GL_UNSIGNED_INT_5_9_9_9_REV"; + case 0x8C3F: + return "GL_TEXTURE_SHARED_SIZE"; + case 0x8C40: + return "GL_SRGB"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C42: + return "GL_SRGB_ALPHA"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8C44: + return "GL_SLUMINANCE_ALPHA"; + case 0x8C45: + return "GL_SLUMINANCE8_ALPHA8"; + case 0x8C46: + return "GL_SLUMINANCE"; + case 0x8C47: + return "GL_SLUMINANCE8"; + case 0x8C48: + return "GL_COMPRESSED_SRGB"; + case 0x8C49: + return "GL_COMPRESSED_SRGB_ALPHA"; + case 0x8C4A: + return "GL_COMPRESSED_SLUMINANCE"; + case 0x8C4B: + return "GL_COMPRESSED_SLUMINANCE_ALPHA"; + case 0x8C76: + return "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"; + case 0x8C7F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"; + case 0x8C80: + return "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS"; + case 0x8C83: + return "GL_TRANSFORM_FEEDBACK_VARYINGS"; + case 0x8C84: + return "GL_TRANSFORM_FEEDBACK_BUFFER_START"; + case 0x8C85: + return "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"; + case 0x8C87: + return "GL_PRIMITIVES_GENERATED"; + case 0x8C88: + return "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; + case 0x8C89: + return "GL_RASTERIZER_DISCARD"; + case 0x8C8A: + return "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS"; + case 0x8C8B: + return "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS"; + case 0x8C8C: + return "GL_INTERLEAVED_ATTRIBS"; + case 0x8C8D: + return "GL_SEPARATE_ATTRIBS"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8C8F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"; + case 0x8CA0: + return "GL_POINT_SPRITE_COORD_ORIGIN"; + case 0x8CA1: + return "GL_LOWER_LEFT"; + case 0x8CA2: + return "GL_UPPER_LEFT"; + case 0x8CA3: + return "GL_STENCIL_BACK_REF"; + case 0x8CA4: + return "GL_STENCIL_BACK_VALUE_MASK"; + case 0x8CA5: + return "GL_STENCIL_BACK_WRITEMASK"; + case 0x8CA6: + return "GL_DRAW_FRAMEBUFFER_BINDING"; + case 0x8CA7: + return "GL_RENDERBUFFER_BINDING"; + case 0x8CA8: + return "GL_READ_FRAMEBUFFER"; + case 0x8CA9: + return "GL_DRAW_FRAMEBUFFER"; + case 0x8CAA: + return "GL_READ_FRAMEBUFFER_BINDING"; + case 0x8CAB: + return "GL_RENDERBUFFER_SAMPLES"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; + case 0x8CD0: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; + case 0x8CD1: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; + case 0x8CD2: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; + case 0x8CD3: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; + case 0x8CD4: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"; + case 0x8CD5: + return "GL_FRAMEBUFFER_COMPLETE"; + case 0x8CD6: + return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; + case 0x8CD7: + return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; + case 0x8CDB: + return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"; + case 0x8CDC: + return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"; + case 0x8CDD: + return "GL_FRAMEBUFFER_UNSUPPORTED"; + case 0x8CDF: + return "GL_MAX_COLOR_ATTACHMENTS"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + case 0x8D00: + return "GL_DEPTH_ATTACHMENT"; + case 0x8D20: + return "GL_STENCIL_ATTACHMENT"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x8D42: + return "GL_RENDERBUFFER_WIDTH"; + case 0x8D43: + return "GL_RENDERBUFFER_HEIGHT"; + case 0x8D44: + return "GL_RENDERBUFFER_INTERNAL_FORMAT"; + case 0x8D46: + return "GL_STENCIL_INDEX1"; + case 0x8D47: + return "GL_STENCIL_INDEX4"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D49: + return "GL_STENCIL_INDEX16"; + case 0x8D50: + return "GL_RENDERBUFFER_RED_SIZE"; + case 0x8D51: + return "GL_RENDERBUFFER_GREEN_SIZE"; + case 0x8D52: + return "GL_RENDERBUFFER_BLUE_SIZE"; + case 0x8D53: + return "GL_RENDERBUFFER_ALPHA_SIZE"; + case 0x8D54: + return "GL_RENDERBUFFER_DEPTH_SIZE"; + case 0x8D55: + return "GL_RENDERBUFFER_STENCIL_SIZE"; + case 0x8D56: + return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; + case 0x8D57: + return "GL_MAX_SAMPLES"; + case 0x8D62: + return "GL_RGB565"; + case 0x8D69: + return "GL_PRIMITIVE_RESTART_FIXED_INDEX"; + case 0x8D6A: + return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"; + case 0x8D6B: + return "GL_MAX_ELEMENT_INDEX"; + case 0x8D70: + return "GL_RGBA32UI"; + case 0x8D71: + return "GL_RGB32UI"; + case 0x8D76: + return "GL_RGBA16UI"; + case 0x8D77: + return "GL_RGB16UI"; + case 0x8D7C: + return "GL_RGBA8UI"; + case 0x8D7D: + return "GL_RGB8UI"; + case 0x8D82: + return "GL_RGBA32I"; + case 0x8D83: + return "GL_RGB32I"; + case 0x8D88: + return "GL_RGBA16I"; + case 0x8D89: + return "GL_RGB16I"; + case 0x8D8E: + return "GL_RGBA8I"; + case 0x8D8F: + return "GL_RGB8I"; + case 0x8D94: + return "GL_RED_INTEGER"; + case 0x8D95: + return "GL_GREEN_INTEGER"; + case 0x8D96: + return "GL_BLUE_INTEGER"; + case 0x8D97: + return "GL_ALPHA_INTEGER"; + case 0x8D98: + return "GL_RGB_INTEGER"; + case 0x8D99: + return "GL_RGBA_INTEGER"; + case 0x8D9A: + return "GL_BGR_INTEGER"; + case 0x8D9B: + return "GL_BGRA_INTEGER"; + case 0x8D9F: + return "GL_INT_2_10_10_10_REV"; + case 0x8DA7: + return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"; + case 0x8DA8: + return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; + case 0x8DAD: + return "GL_FLOAT_32_UNSIGNED_INT_24_8_REV"; + case 0x8DB9: + return "GL_FRAMEBUFFER_SRGB"; + case 0x8DBB: + return "GL_COMPRESSED_RED_RGTC1"; + case 0x8DBC: + return "GL_COMPRESSED_SIGNED_RED_RGTC1"; + case 0x8DBD: + return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; + case 0x8DBE: + return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8DC0: + return "GL_SAMPLER_1D_ARRAY"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC3: + return "GL_SAMPLER_1D_ARRAY_SHADOW"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DC9: + return "GL_INT_SAMPLER_1D"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCD: + return "GL_INT_SAMPLER_2D_RECT"; + case 0x8DCE: + return "GL_INT_SAMPLER_1D_ARRAY"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD1: + return "GL_UNSIGNED_INT_SAMPLER_1D"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD5: + return "GL_UNSIGNED_INT_SAMPLER_2D_RECT"; + case 0x8DD6: + return "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8DDF: + return "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8DE0: + return "GL_MAX_GEOMETRY_OUTPUT_VERTICES"; + case 0x8DE1: + return "GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS"; + case 0x8DE5: + return "GL_ACTIVE_SUBROUTINES"; + case 0x8DE6: + return "GL_ACTIVE_SUBROUTINE_UNIFORMS"; + case 0x8DE7: + return "GL_MAX_SUBROUTINES"; + case 0x8DE8: + return "GL_MAX_SUBROUTINE_UNIFORM_LOCATIONS"; + case 0x8DF0: + return "GL_LOW_FLOAT"; + case 0x8DF1: + return "GL_MEDIUM_FLOAT"; + case 0x8DF2: + return "GL_HIGH_FLOAT"; + case 0x8DF3: + return "GL_LOW_INT"; + case 0x8DF4: + return "GL_MEDIUM_INT"; + case 0x8DF5: + return "GL_HIGH_INT"; + case 0x8DF8: + return "GL_SHADER_BINARY_FORMATS"; + case 0x8DF9: + return "GL_NUM_SHADER_BINARY_FORMATS"; + case 0x8DFA: + return "GL_SHADER_COMPILER"; + case 0x8DFB: + return "GL_MAX_VERTEX_UNIFORM_VECTORS"; + case 0x8DFC: + return "GL_MAX_VARYING_VECTORS"; + case 0x8DFD: + return "GL_MAX_FRAGMENT_UNIFORM_VECTORS"; + case 0x8E13: + return "GL_QUERY_WAIT"; + case 0x8E14: + return "GL_QUERY_NO_WAIT"; + case 0x8E15: + return "GL_QUERY_BY_REGION_WAIT"; + case 0x8E16: + return "GL_QUERY_BY_REGION_NO_WAIT"; + case 0x8E17: + return "GL_QUERY_WAIT_INVERTED"; + case 0x8E18: + return "GL_QUERY_NO_WAIT_INVERTED"; + case 0x8E19: + return "GL_QUERY_BY_REGION_WAIT_INVERTED"; + case 0x8E1A: + return "GL_QUERY_BY_REGION_NO_WAIT_INVERTED"; + case 0x8E1B: + return "GL_POLYGON_OFFSET_CLAMP"; + case 0x8E1E: + return "GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS"; + case 0x8E1F: + return "GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS"; + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; + case 0x8E23: + return "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED"; + case 0x8E24: + return "GL_TRANSFORM_FEEDBACK_ACTIVE"; + case 0x8E25: + return "GL_TRANSFORM_FEEDBACK_BINDING"; + case 0x8E28: + return "GL_TIMESTAMP"; + case 0x8E42: + return "GL_TEXTURE_SWIZZLE_R"; + case 0x8E43: + return "GL_TEXTURE_SWIZZLE_G"; + case 0x8E44: + return "GL_TEXTURE_SWIZZLE_B"; + case 0x8E45: + return "GL_TEXTURE_SWIZZLE_A"; + case 0x8E46: + return "GL_TEXTURE_SWIZZLE_RGBA"; + case 0x8E47: + return "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS"; + case 0x8E48: + return "GL_ACTIVE_SUBROUTINE_MAX_LENGTH"; + case 0x8E49: + return "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH"; + case 0x8E4A: + return "GL_NUM_COMPATIBLE_SUBROUTINES"; + case 0x8E4B: + return "GL_COMPATIBLE_SUBROUTINES"; + case 0x8E4C: + return "GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION"; + case 0x8E4D: + return "GL_FIRST_VERTEX_CONVENTION"; + case 0x8E4E: + return "GL_LAST_VERTEX_CONVENTION"; + case 0x8E4F: + return "GL_PROVOKING_VERTEX"; + case 0x8E50: + return "GL_SAMPLE_POSITION"; + case 0x8E51: + return "GL_SAMPLE_MASK"; + case 0x8E52: + return "GL_SAMPLE_MASK_VALUE"; + case 0x8E59: + return "GL_MAX_SAMPLE_MASK_WORDS"; + case 0x8E5A: + return "GL_MAX_GEOMETRY_SHADER_INVOCATIONS"; + case 0x8E5B: + return "GL_MIN_FRAGMENT_INTERPOLATION_OFFSET"; + case 0x8E5C: + return "GL_MAX_FRAGMENT_INTERPOLATION_OFFSET"; + case 0x8E5D: + return "GL_FRAGMENT_INTERPOLATION_OFFSET_BITS"; + case 0x8E5E: + return "GL_MIN_PROGRAM_TEXTURE_GATHER_OFFSET"; + case 0x8E5F: + return "GL_MAX_PROGRAM_TEXTURE_GATHER_OFFSET"; + case 0x8E70: + return "GL_MAX_TRANSFORM_FEEDBACK_BUFFERS"; + case 0x8E71: + return "GL_MAX_VERTEX_STREAMS"; + case 0x8E72: + return "GL_PATCH_VERTICES"; + case 0x8E73: + return "GL_PATCH_DEFAULT_INNER_LEVEL"; + case 0x8E74: + return "GL_PATCH_DEFAULT_OUTER_LEVEL"; + case 0x8E75: + return "GL_TESS_CONTROL_OUTPUT_VERTICES"; + case 0x8E76: + return "GL_TESS_GEN_MODE"; + case 0x8E77: + return "GL_TESS_GEN_SPACING"; + case 0x8E78: + return "GL_TESS_GEN_VERTEX_ORDER"; + case 0x8E79: + return "GL_TESS_GEN_POINT_MODE"; + case 0x8E7A: + return "GL_ISOLINES"; + case 0x8E7B: + return "GL_FRACTIONAL_ODD"; + case 0x8E7C: + return "GL_FRACTIONAL_EVEN"; + case 0x8E7D: + return "GL_MAX_PATCH_VERTICES"; + case 0x8E7E: + return "GL_MAX_TESS_GEN_LEVEL"; + case 0x8E7F: + return "GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS"; + case 0x8E80: + return "GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS"; + case 0x8E81: + return "GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS"; + case 0x8E82: + return "GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS"; + case 0x8E83: + return "GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS"; + case 0x8E84: + return "GL_MAX_TESS_PATCH_COMPONENTS"; + case 0x8E85: + return "GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS"; + case 0x8E86: + return "GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + case 0x8E89: + return "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"; + case 0x8E8A: + return "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"; + case 0x8E8C: + return "GL_COMPRESSED_RGBA_BPTC_UNORM"; + case 0x8E8D: + return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM"; + case 0x8E8E: + return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT"; + case 0x8E8F: + return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F38: + return "GL_MAX_IMAGE_UNITS"; + case 0x8F39: + return "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS"; + case 0x8F3A: + return "GL_IMAGE_BINDING_NAME"; + case 0x8F3B: + return "GL_IMAGE_BINDING_LEVEL"; + case 0x8F3C: + return "GL_IMAGE_BINDING_LAYERED"; + case 0x8F3D: + return "GL_IMAGE_BINDING_LAYER"; + case 0x8F3E: + return "GL_IMAGE_BINDING_ACCESS"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x8F43: + return "GL_DRAW_INDIRECT_BUFFER_BINDING"; + case 0x8F46: + return "GL_DOUBLE_MAT2"; + case 0x8F47: + return "GL_DOUBLE_MAT3"; + case 0x8F48: + return "GL_DOUBLE_MAT4"; + case 0x8F49: + return "GL_DOUBLE_MAT2x3"; + case 0x8F4A: + return "GL_DOUBLE_MAT2x4"; + case 0x8F4B: + return "GL_DOUBLE_MAT3x2"; + case 0x8F4C: + return "GL_DOUBLE_MAT3x4"; + case 0x8F4D: + return "GL_DOUBLE_MAT4x2"; + case 0x8F4E: + return "GL_DOUBLE_MAT4x3"; + case 0x8F4F: + return "GL_VERTEX_BINDING_BUFFER"; + case 0x8F94: + return "GL_R8_SNORM"; + case 0x8F95: + return "GL_RG8_SNORM"; + case 0x8F96: + return "GL_RGB8_SNORM"; + case 0x8F97: + return "GL_RGBA8_SNORM"; + case 0x8F98: + return "GL_R16_SNORM"; + case 0x8F99: + return "GL_RG16_SNORM"; + case 0x8F9A: + return "GL_RGB16_SNORM"; + case 0x8F9B: + return "GL_RGBA16_SNORM"; + case 0x8F9C: + return "GL_SIGNED_NORMALIZED"; + case 0x8F9D: + return "GL_PRIMITIVE_RESTART"; + case 0x8F9E: + return "GL_PRIMITIVE_RESTART_INDEX"; + case 0x8FBD: + return "GL_SR8_EXT"; + case 0x8FBE: + return "GL_SRG8_EXT"; + case 0x8FFC: + return "GL_DOUBLE_VEC2"; + case 0x8FFD: + return "GL_DOUBLE_VEC3"; + case 0x8FFE: + return "GL_DOUBLE_VEC4"; + case 0x9009: + return "GL_TEXTURE_CUBE_MAP_ARRAY"; + case 0x900A: + return "GL_TEXTURE_BINDING_CUBE_MAP_ARRAY"; + case 0x900B: + return "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904C: + return "GL_IMAGE_1D"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x904F: + return "GL_IMAGE_2D_RECT"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9052: + return "GL_IMAGE_1D_ARRAY"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9055: + return "GL_IMAGE_2D_MULTISAMPLE"; + case 0x9056: + return "GL_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9057: + return "GL_INT_IMAGE_1D"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905A: + return "GL_INT_IMAGE_2D_RECT"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905D: + return "GL_INT_IMAGE_1D_ARRAY"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9060: + return "GL_INT_IMAGE_2D_MULTISAMPLE"; + case 0x9061: + return "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9062: + return "GL_UNSIGNED_INT_IMAGE_1D"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9065: + return "GL_UNSIGNED_INT_IMAGE_2D_RECT"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9068: + return "GL_UNSIGNED_INT_IMAGE_1D_ARRAY"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x906B: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE"; + case 0x906C: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x906D: + return "GL_MAX_IMAGE_SAMPLES"; + case 0x906E: + return "GL_IMAGE_BINDING_FORMAT"; + case 0x906F: + return "GL_RGB10_A2UI"; + case 0x90BC: + return "GL_MIN_MAP_BUFFER_ALIGNMENT"; + case 0x90C7: + return "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"; + case 0x90C8: + return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE"; + case 0x90C9: + return "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS"; + case 0x90CA: + return "GL_MAX_VERTEX_IMAGE_UNIFORMS"; + case 0x90CB: + return "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS"; + case 0x90CC: + return "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS"; + case 0x90CD: + return "GL_MAX_GEOMETRY_IMAGE_UNIFORMS"; + case 0x90CE: + return "GL_MAX_FRAGMENT_IMAGE_UNIFORMS"; + case 0x90CF: + return "GL_MAX_COMBINED_IMAGE_UNIFORMS"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90D3: + return "GL_SHADER_STORAGE_BUFFER_BINDING"; + case 0x90D4: + return "GL_SHADER_STORAGE_BUFFER_START"; + case 0x90D5: + return "GL_SHADER_STORAGE_BUFFER_SIZE"; + case 0x90D6: + return "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"; + case 0x90D7: + return "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"; + case 0x90D8: + return "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"; + case 0x90D9: + return "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"; + case 0x90DA: + return "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; + case 0x90DB: + return "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"; + case 0x90DC: + return "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"; + case 0x90DD: + return "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"; + case 0x90DE: + return "GL_MAX_SHADER_STORAGE_BLOCK_SIZE"; + case 0x90DF: + return "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"; + case 0x90EA: + return "GL_DEPTH_STENCIL_TEXTURE_MODE"; + case 0x90EB: + return "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"; + case 0x90EC: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER"; + case 0x90ED: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x90EF: + return "GL_DISPATCH_INDIRECT_BUFFER_BINDING"; + case 0x9100: + return "GL_TEXTURE_2D_MULTISAMPLE"; + case 0x9101: + return "GL_PROXY_TEXTURE_2D_MULTISAMPLE"; + case 0x9102: + return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; + case 0x9103: + return "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY"; + case 0x9104: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE"; + case 0x9105: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"; + case 0x9106: + return "GL_TEXTURE_SAMPLES"; + case 0x9107: + return "GL_TEXTURE_FIXED_SAMPLE_LOCATIONS"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910E: + return "GL_MAX_COLOR_TEXTURE_SAMPLES"; + case 0x910F: + return "GL_MAX_DEPTH_TEXTURE_SAMPLES"; + case 0x9110: + return "GL_MAX_INTEGER_SAMPLES"; + case 0x9111: + return "GL_MAX_SERVER_WAIT_TIMEOUT"; + case 0x9112: + return "GL_OBJECT_TYPE"; + case 0x9113: + return "GL_SYNC_CONDITION"; + case 0x9114: + return "GL_SYNC_STATUS"; + case 0x9115: + return "GL_SYNC_FLAGS"; + case 0x9116: + return "GL_SYNC_FENCE"; + case 0x9117: + return "GL_SYNC_GPU_COMMANDS_COMPLETE"; + case 0x9118: + return "GL_UNSIGNALED"; + case 0x9119: + return "GL_SIGNALED"; + case 0x911A: + return "GL_ALREADY_SIGNALED"; + case 0x911B: + return "GL_TIMEOUT_EXPIRED"; + case 0x911C: + return "GL_CONDITION_SATISFIED"; + case 0x911D: + return "GL_WAIT_FAILED"; + case 0x911F: + return "GL_BUFFER_ACCESS_FLAGS"; + case 0x9120: + return "GL_BUFFER_MAP_LENGTH"; + case 0x9121: + return "GL_BUFFER_MAP_OFFSET"; + case 0x9122: + return "GL_MAX_VERTEX_OUTPUT_COMPONENTS"; + case 0x9123: + return "GL_MAX_GEOMETRY_INPUT_COMPONENTS"; + case 0x9124: + return "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"; + case 0x9125: + return "GL_MAX_FRAGMENT_INPUT_COMPONENTS"; + case 0x9126: + return "GL_CONTEXT_PROFILE_MASK"; + case 0x9127: + return "GL_UNPACK_COMPRESSED_BLOCK_WIDTH"; + case 0x9128: + return "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT"; + case 0x9129: + return "GL_UNPACK_COMPRESSED_BLOCK_DEPTH"; + case 0x912A: + return "GL_UNPACK_COMPRESSED_BLOCK_SIZE"; + case 0x912B: + return "GL_PACK_COMPRESSED_BLOCK_WIDTH"; + case 0x912C: + return "GL_PACK_COMPRESSED_BLOCK_HEIGHT"; + case 0x912D: + return "GL_PACK_COMPRESSED_BLOCK_DEPTH"; + case 0x912E: + return "GL_PACK_COMPRESSED_BLOCK_SIZE"; + case 0x912F: + return "GL_TEXTURE_IMMUTABLE_FORMAT"; + case 0x9143: + return "GL_MAX_DEBUG_MESSAGE_LENGTH"; + case 0x9144: + return "GL_MAX_DEBUG_LOGGED_MESSAGES"; + case 0x9145: + return "GL_DEBUG_LOGGED_MESSAGES"; + case 0x9146: + return "GL_DEBUG_SEVERITY_HIGH"; + case 0x9147: + return "GL_DEBUG_SEVERITY_MEDIUM"; + case 0x9148: + return "GL_DEBUG_SEVERITY_LOW"; + case 0x9151: + return "GL_BUFFER_OBJECT_EXT"; + case 0x9153: + return "GL_QUERY_OBJECT_EXT"; + case 0x9154: + return "GL_VERTEX_ARRAY_OBJECT_EXT"; + case 0x9192: + return "GL_QUERY_BUFFER"; + case 0x9193: + return "GL_QUERY_BUFFER_BINDING"; + case 0x9194: + return "GL_QUERY_RESULT_NO_WAIT"; + case 0x919D: + return "GL_TEXTURE_BUFFER_OFFSET"; + case 0x919E: + return "GL_TEXTURE_BUFFER_SIZE"; + case 0x919F: + return "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"; + case 0x91B0: + return "GL_MAX_SHADER_COMPILER_THREADS_KHR"; + case 0x91B1: + return "GL_COMPLETION_STATUS_KHR"; + case 0x91B9: + return "GL_COMPUTE_SHADER"; + case 0x91BB: + return "GL_MAX_COMPUTE_UNIFORM_BLOCKS"; + case 0x91BC: + return "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"; + case 0x91BD: + return "GL_MAX_COMPUTE_IMAGE_UNIFORMS"; + case 0x91BE: + return "GL_MAX_COMPUTE_WORK_GROUP_COUNT"; + case 0x91BF: + return "GL_MAX_COMPUTE_WORK_GROUP_SIZE"; + case 0x9270: + return "GL_COMPRESSED_R11_EAC"; + case 0x9271: + return "GL_COMPRESSED_SIGNED_R11_EAC"; + case 0x9272: + return "GL_COMPRESSED_RG11_EAC"; + case 0x9273: + return "GL_COMPRESSED_SIGNED_RG11_EAC"; + case 0x9274: + return "GL_COMPRESSED_RGB8_ETC2"; + case 0x9275: + return "GL_COMPRESSED_SRGB8_ETC2"; + case 0x9276: + return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9277: + return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9278: + return "GL_COMPRESSED_RGBA8_ETC2_EAC"; + case 0x9279: + return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x9294: + return "GL_MULTIPLY_KHR"; + case 0x9295: + return "GL_SCREEN_KHR"; + case 0x9296: + return "GL_OVERLAY_KHR"; + case 0x9297: + return "GL_DARKEN_KHR"; + case 0x9298: + return "GL_LIGHTEN_KHR"; + case 0x9299: + return "GL_COLORDODGE_KHR"; + case 0x929A: + return "GL_COLORBURN_KHR"; + case 0x929B: + return "GL_HARDLIGHT_KHR"; + case 0x929C: + return "GL_SOFTLIGHT_KHR"; + case 0x929E: + return "GL_DIFFERENCE_KHR"; + case 0x92A0: + return "GL_EXCLUSION_KHR"; + case 0x92AD: + return "GL_HSL_HUE_KHR"; + case 0x92AE: + return "GL_HSL_SATURATION_KHR"; + case 0x92AF: + return "GL_HSL_COLOR_KHR"; + case 0x92B0: + return "GL_HSL_LUMINOSITY_KHR"; + case 0x92BB: + return "GL_PURGED_CONTEXT_RESET_NV"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + case 0x92C1: + return "GL_ATOMIC_COUNTER_BUFFER_BINDING"; + case 0x92C2: + return "GL_ATOMIC_COUNTER_BUFFER_START"; + case 0x92C3: + return "GL_ATOMIC_COUNTER_BUFFER_SIZE"; + case 0x92C4: + return "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE"; + case 0x92C5: + return "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS"; + case 0x92C6: + return "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES"; + case 0x92C7: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER"; + case 0x92C8: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x92C9: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x92CA: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x92CB: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x92CC: + return "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS"; + case 0x92CD: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS"; + case 0x92CE: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS"; + case 0x92CF: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS"; + case 0x92D0: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS"; + case 0x92D1: + return "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS"; + case 0x92D2: + return "GL_MAX_VERTEX_ATOMIC_COUNTERS"; + case 0x92D3: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"; + case 0x92D4: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"; + case 0x92D5: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"; + case 0x92D6: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"; + case 0x92D7: + return "GL_MAX_COMBINED_ATOMIC_COUNTERS"; + case 0x92D8: + return "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE"; + case 0x92D9: + return "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"; + case 0x92DA: + return "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX"; + case 0x92DB: + return "GL_UNSIGNED_INT_ATOMIC_COUNTER"; + case 0x92DC: + return "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS"; + case 0x92E0: + return "GL_DEBUG_OUTPUT"; + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E2: + return "GL_UNIFORM_BLOCK"; + case 0x92E3: + return "GL_PROGRAM_INPUT"; + case 0x92E4: + return "GL_PROGRAM_OUTPUT"; + case 0x92E5: + return "GL_BUFFER_VARIABLE"; + case 0x92E6: + return "GL_SHADER_STORAGE_BLOCK"; + case 0x92E7: + return "GL_IS_PER_PATCH"; + case 0x92E8: + return "GL_VERTEX_SUBROUTINE"; + case 0x92E9: + return "GL_TESS_CONTROL_SUBROUTINE"; + case 0x92EA: + return "GL_TESS_EVALUATION_SUBROUTINE"; + case 0x92EB: + return "GL_GEOMETRY_SUBROUTINE"; + case 0x92EC: + return "GL_FRAGMENT_SUBROUTINE"; + case 0x92ED: + return "GL_COMPUTE_SUBROUTINE"; + case 0x92EE: + return "GL_VERTEX_SUBROUTINE_UNIFORM"; + case 0x92EF: + return "GL_TESS_CONTROL_SUBROUTINE_UNIFORM"; + case 0x92F0: + return "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM"; + case 0x92F1: + return "GL_GEOMETRY_SUBROUTINE_UNIFORM"; + case 0x92F2: + return "GL_FRAGMENT_SUBROUTINE_UNIFORM"; + case 0x92F3: + return "GL_COMPUTE_SUBROUTINE_UNIFORM"; + case 0x92F4: + return "GL_TRANSFORM_FEEDBACK_VARYING"; + case 0x92F5: + return "GL_ACTIVE_RESOURCES"; + case 0x92F6: + return "GL_MAX_NAME_LENGTH"; + case 0x92F7: + return "GL_MAX_NUM_ACTIVE_VARIABLES"; + case 0x92F8: + return "GL_MAX_NUM_COMPATIBLE_SUBROUTINES"; + case 0x92F9: + return "GL_NAME_LENGTH"; + case 0x92FA: + return "GL_TYPE"; + case 0x92FB: + return "GL_ARRAY_SIZE"; + case 0x92FC: + return "GL_OFFSET"; + case 0x92FD: + return "GL_BLOCK_INDEX"; + case 0x92FE: + return "GL_ARRAY_STRIDE"; + case 0x92FF: + return "GL_MATRIX_STRIDE"; + case 0x9300: + return "GL_IS_ROW_MAJOR"; + case 0x9301: + return "GL_ATOMIC_COUNTER_BUFFER_INDEX"; + case 0x9302: + return "GL_BUFFER_BINDING"; + case 0x9303: + return "GL_BUFFER_DATA_SIZE"; + case 0x9304: + return "GL_NUM_ACTIVE_VARIABLES"; + case 0x9305: + return "GL_ACTIVE_VARIABLES"; + case 0x9306: + return "GL_REFERENCED_BY_VERTEX_SHADER"; + case 0x9307: + return "GL_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x9308: + return "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x9309: + return "GL_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x930A: + return "GL_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x930B: + return "GL_REFERENCED_BY_COMPUTE_SHADER"; + case 0x930C: + return "GL_TOP_LEVEL_ARRAY_SIZE"; + case 0x930D: + return "GL_TOP_LEVEL_ARRAY_STRIDE"; + case 0x930E: + return "GL_LOCATION"; + case 0x930F: + return "GL_LOCATION_INDEX"; + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + case 0x9315: + return "GL_MAX_FRAMEBUFFER_WIDTH"; + case 0x9316: + return "GL_MAX_FRAMEBUFFER_HEIGHT"; + case 0x9317: + return "GL_MAX_FRAMEBUFFER_LAYERS"; + case 0x9318: + return "GL_MAX_FRAMEBUFFER_SAMPLES"; + case 0x934A: + return "GL_LOCATION_COMPONENT"; + case 0x934B: + return "GL_TRANSFORM_FEEDBACK_BUFFER_INDEX"; + case 0x934C: + return "GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE"; + case 0x935C: + return "GL_CLIP_ORIGIN"; + case 0x935D: + return "GL_CLIP_DEPTH_MODE"; + case 0x935E: + return "GL_NEGATIVE_ONE_TO_ONE"; + case 0x935F: + return "GL_ZERO_TO_ONE"; + case 0x9365: + return "GL_CLEAR_TEXTURE"; + case 0x9380: + return "GL_NUM_SAMPLE_COUNTS"; + case 0x93A1: + return "GL_BGRA8_EXT"; + case 0x93AE: + return "GL_HANDLE_TYPE_ZIRCON_VMO_ANGLE"; + case 0x93AF: + return "GL_HANDLE_TYPE_ZIRCON_EVENT_ANGLE"; + case 0x93B0: + return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; + case 0x93B1: + return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; + case 0x93B2: + return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; + case 0x93B3: + return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; + case 0x93B4: + return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; + case 0x93B5: + return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; + case 0x93B6: + return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; + case 0x93B7: + return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; + case 0x93B8: + return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; + case 0x93B9: + return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; + case 0x93BA: + return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; + case 0x93BB: + return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; + case 0x93BC: + return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; + case 0x93BD: + return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; + case 0x93D0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; + case 0x93D1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; + case 0x93D2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; + case 0x93D3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; + case 0x93D4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; + case 0x93D5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; + case 0x93D6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; + case 0x93D7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; + case 0x93D8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; + case 0x93D9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; + case 0x93DA: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; + case 0x93DB: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; + case 0x93DC: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; + case 0x93DD: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; + case 0x9530: + return "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT"; + case 0x9531: + return "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT"; + case 0x9551: + return "GL_SHADER_BINARY_FORMAT_SPIR_V"; + case 0x9552: + return "GL_SPIR_V_BINARY"; + case 0x9553: + return "GL_SPIR_V_EXTENSIONS"; + case 0x9554: + return "GL_NUM_SPIR_V_EXTENSIONS"; + case 0x9580: + return "GL_TEXTURE_TILING_EXT"; + case 0x9581: + return "GL_DEDICATED_MEMORY_OBJECT_EXT"; + case 0x9582: + return "GL_NUM_TILING_TYPES_EXT"; + case 0x9583: + return "GL_TILING_TYPES_EXT"; + case 0x9584: + return "GL_OPTIMAL_TILING_EXT"; + case 0x9585: + return "GL_LINEAR_TILING_EXT"; + case 0x9586: + return "GL_HANDLE_TYPE_OPAQUE_FD_EXT"; + case 0x958D: + return "GL_LAYOUT_GENERAL_EXT"; + case 0x958E: + return "GL_LAYOUT_COLOR_ATTACHMENT_EXT"; + case 0x958F: + return "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT"; + case 0x9590: + return "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT"; + case 0x9591: + return "GL_LAYOUT_SHADER_READ_ONLY_EXT"; + case 0x9592: + return "GL_LAYOUT_TRANSFER_SRC_EXT"; + case 0x9593: + return "GL_LAYOUT_TRANSFER_DST_EXT"; + case 0x9596: + return "GL_NUM_DEVICE_UUIDS_EXT"; + case 0x9597: + return "GL_DEVICE_UUID_EXT"; + case 0x9598: + return "GL_DRIVER_UUID_EXT"; + case 0x959B: + return "GL_PROTECTED_MEMORY_OBJECT_EXT"; + case 0x9630: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"; + case 0x9631: + return "GL_MAX_VIEWS_OVR"; + case 0x9632: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"; + case 0x9633: + return "GL_FRAMEBUFFER_INCOMPLETE_VIEW_TARGETS_OVR"; + case 0x10000: + return "GL_EVAL_BIT"; + case 0x20000: + return "GL_LIST_BIT"; + case 0x40000: + return "GL_TEXTURE_BIT"; + case 0x80000: + return "GL_SCISSOR_BIT"; + case 0x20000000: + return "GL_MULTISAMPLE_BIT"; + case 0xFFFFFFFF: + return "GL_ALL_ATTRIB_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::AlphaFunction: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::AtomicCounterBufferPName: + { + switch (value) + { + case 0x90ED: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER"; + case 0x92C1: + return "GL_ATOMIC_COUNTER_BUFFER_BINDING"; + case 0x92C4: + return "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE"; + case 0x92C5: + return "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS"; + case 0x92C6: + return "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES"; + case 0x92C7: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER"; + case 0x92C8: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x92C9: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x92CA: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x92CB: + return "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::AttribMask: + { + switch (value) + { + case 0x1: + return "GL_CURRENT_BIT"; + case 0x2: + return "GL_POINT_BIT"; + case 0x4: + return "GL_LINE_BIT"; + case 0x8: + return "GL_POLYGON_BIT"; + case 0x10: + return "GL_POLYGON_STIPPLE_BIT"; + case 0x20: + return "GL_PIXEL_MODE_BIT"; + case 0x40: + return "GL_LIGHTING_BIT"; + case 0x80: + return "GL_FOG_BIT"; + case 0x100: + return "GL_DEPTH_BUFFER_BIT"; + case 0x200: + return "GL_ACCUM_BUFFER_BIT"; + case 0x400: + return "GL_STENCIL_BUFFER_BIT"; + case 0x800: + return "GL_VIEWPORT_BIT"; + case 0x1000: + return "GL_TRANSFORM_BIT"; + case 0x2000: + return "GL_ENABLE_BIT"; + case 0x4000: + return "GL_COLOR_BUFFER_BIT"; + case 0x8000: + return "GL_HINT_BIT"; + case 0x10000: + return "GL_EVAL_BIT"; + case 0x20000: + return "GL_LIST_BIT"; + case 0x40000: + return "GL_TEXTURE_BIT"; + case 0x80000: + return "GL_SCISSOR_BIT"; + case 0x20000000: + return "GL_MULTISAMPLE_BIT"; + case 0xFFFFFFFF: + return "GL_ALL_ATTRIB_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::AttributeType: + { + switch (value) + { + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5D: + return "GL_SAMPLER_1D"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B61: + return "GL_SAMPLER_1D_SHADOW"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B63: + return "GL_SAMPLER_2D_RECT"; + case 0x8B64: + return "GL_SAMPLER_2D_RECT_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC3: + return "GL_SAMPLER_1D_ARRAY_SHADOW"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DC9: + return "GL_INT_SAMPLER_1D"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCD: + return "GL_INT_SAMPLER_2D_RECT"; + case 0x8DCE: + return "GL_INT_SAMPLER_1D_ARRAY"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD1: + return "GL_UNSIGNED_INT_SAMPLER_1D"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD5: + return "GL_UNSIGNED_INT_SAMPLER_2D_RECT"; + case 0x8DD6: + return "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x8F46: + return "GL_DOUBLE_MAT2"; + case 0x8F47: + return "GL_DOUBLE_MAT3"; + case 0x8F48: + return "GL_DOUBLE_MAT4"; + case 0x8F49: + return "GL_DOUBLE_MAT2x3"; + case 0x8F4A: + return "GL_DOUBLE_MAT2x4"; + case 0x8F4B: + return "GL_DOUBLE_MAT3x2"; + case 0x8F4C: + return "GL_DOUBLE_MAT3x4"; + case 0x8F4D: + return "GL_DOUBLE_MAT4x2"; + case 0x8F4E: + return "GL_DOUBLE_MAT4x3"; + case 0x8FFC: + return "GL_DOUBLE_VEC2"; + case 0x8FFD: + return "GL_DOUBLE_VEC3"; + case 0x8FFE: + return "GL_DOUBLE_VEC4"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904C: + return "GL_IMAGE_1D"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x904F: + return "GL_IMAGE_2D_RECT"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9052: + return "GL_IMAGE_1D_ARRAY"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9055: + return "GL_IMAGE_2D_MULTISAMPLE"; + case 0x9056: + return "GL_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9057: + return "GL_INT_IMAGE_1D"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905A: + return "GL_INT_IMAGE_2D_RECT"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905D: + return "GL_INT_IMAGE_1D_ARRAY"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9060: + return "GL_INT_IMAGE_2D_MULTISAMPLE"; + case 0x9061: + return "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9062: + return "GL_UNSIGNED_INT_IMAGE_1D"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9065: + return "GL_UNSIGNED_INT_IMAGE_2D_RECT"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9068: + return "GL_UNSIGNED_INT_IMAGE_1D_ARRAY"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x906B: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE"; + case 0x906C: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BindTransformFeedbackTarget: + { + switch (value) + { + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BinormalPointerTypeEXT: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BlendEquationModeEXT: + { + switch (value) + { + case 0x8006: + return "GL_FUNC_ADD"; + case 0x8007: + return "GL_MIN"; + case 0x8008: + return "GL_MAX"; + case 0x800A: + return "GL_FUNC_SUBTRACT"; + case 0x800B: + return "GL_FUNC_REVERSE_SUBTRACT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BlendingFactor: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x300: + return "GL_SRC_COLOR"; + case 0x301: + return "GL_ONE_MINUS_SRC_COLOR"; + case 0x302: + return "GL_SRC_ALPHA"; + case 0x303: + return "GL_ONE_MINUS_SRC_ALPHA"; + case 0x304: + return "GL_DST_ALPHA"; + case 0x305: + return "GL_ONE_MINUS_DST_ALPHA"; + case 0x306: + return "GL_DST_COLOR"; + case 0x307: + return "GL_ONE_MINUS_DST_COLOR"; + case 0x308: + return "GL_SRC_ALPHA_SATURATE"; + case 0x8001: + return "GL_CONSTANT_COLOR"; + case 0x8002: + return "GL_ONE_MINUS_CONSTANT_COLOR"; + case 0x8003: + return "GL_CONSTANT_ALPHA"; + case 0x8004: + return "GL_ONE_MINUS_CONSTANT_ALPHA"; + case 0x8589: + return "GL_SRC1_ALPHA"; + case 0x88F9: + return "GL_SRC1_COLOR"; + case 0x88FA: + return "GL_ONE_MINUS_SRC1_COLOR"; + case 0x88FB: + return "GL_ONE_MINUS_SRC1_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BlitFramebufferFilter: + { + switch (value) + { + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::Boolean: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::Buffer: + { + switch (value) + { + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferAccessARB: + { + switch (value) + { + case 0x88B8: + return "GL_READ_ONLY"; + case 0x88B9: + return "GL_WRITE_ONLY"; + case 0x88BA: + return "GL_READ_WRITE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferPNameARB: + { + switch (value) + { + case 0x821F: + return "GL_BUFFER_IMMUTABLE_STORAGE"; + case 0x8220: + return "GL_BUFFER_STORAGE_FLAGS"; + case 0x8764: + return "GL_BUFFER_SIZE"; + case 0x8765: + return "GL_BUFFER_USAGE"; + case 0x88BB: + return "GL_BUFFER_ACCESS"; + case 0x88BC: + return "GL_BUFFER_MAPPED"; + case 0x911F: + return "GL_BUFFER_ACCESS_FLAGS"; + case 0x9120: + return "GL_BUFFER_MAP_LENGTH"; + case 0x9121: + return "GL_BUFFER_MAP_OFFSET"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferPointerNameARB: + { + switch (value) + { + case 0x88BD: + return "GL_BUFFER_MAP_POINTER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferStorageMask: + { + switch (value) + { + case 0x1: + return "GL_MAP_READ_BIT"; + case 0x2: + return "GL_MAP_WRITE_BIT"; + case 0x40: + return "GL_MAP_PERSISTENT_BIT"; + case 0x80: + return "GL_MAP_COHERENT_BIT"; + case 0x100: + return "GL_DYNAMIC_STORAGE_BIT"; + case 0x200: + return "GL_CLIENT_STORAGE_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferStorageTarget: + { + switch (value) + { + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x9192: + return "GL_QUERY_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferTargetARB: + { + switch (value) + { + case 0x80EE: + return "GL_PARAMETER_BUFFER"; + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x9192: + return "GL_QUERY_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::BufferUsageARB: + { + switch (value) + { + case 0x88E0: + return "GL_STREAM_DRAW"; + case 0x88E1: + return "GL_STREAM_READ"; + case 0x88E2: + return "GL_STREAM_COPY"; + case 0x88E4: + return "GL_STATIC_DRAW"; + case 0x88E5: + return "GL_STATIC_READ"; + case 0x88E6: + return "GL_STATIC_COPY"; + case 0x88E8: + return "GL_DYNAMIC_DRAW"; + case 0x88E9: + return "GL_DYNAMIC_READ"; + case 0x88EA: + return "GL_DYNAMIC_COPY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CheckFramebufferStatusTarget: + { + switch (value) + { + case 0x8CA8: + return "GL_READ_FRAMEBUFFER"; + case 0x8CA9: + return "GL_DRAW_FRAMEBUFFER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClampColorModeARB: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; + case 0x891D: + return "GL_FIXED_ONLY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClampColorTargetARB: + { + switch (value) + { + case 0x891C: + return "GL_CLAMP_READ_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClearBufferMask: + { + switch (value) + { + case 0x100: + return "GL_DEPTH_BUFFER_BIT"; + case 0x200: + return "GL_ACCUM_BUFFER_BIT"; + case 0x400: + return "GL_STENCIL_BUFFER_BIT"; + case 0x4000: + return "GL_COLOR_BUFFER_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClientAttribMask: + { + switch (value) + { + case 0x1: + return "GL_CLIENT_PIXEL_STORE_BIT"; + case 0x2: + return "GL_CLIENT_VERTEX_ARRAY_BIT"; + case 0xFFFFFFFF: + return "GL_CLIENT_ALL_ATTRIB_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClipControlDepth: + { + switch (value) + { + case 0x935E: + return "GL_NEGATIVE_ONE_TO_ONE"; + case 0x935F: + return "GL_ZERO_TO_ONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClipControlOrigin: + { + switch (value) + { + case 0x8CA1: + return "GL_LOWER_LEFT"; + case 0x8CA2: + return "GL_UPPER_LEFT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ClipPlaneName: + { + switch (value) + { + case 0x3000: + return "GL_CLIP_DISTANCE0"; + case 0x3001: + return "GL_CLIP_DISTANCE1"; + case 0x3002: + return "GL_CLIP_DISTANCE2"; + case 0x3003: + return "GL_CLIP_DISTANCE3"; + case 0x3004: + return "GL_CLIP_DISTANCE4"; + case 0x3005: + return "GL_CLIP_DISTANCE5"; + case 0x3006: + return "GL_CLIP_DISTANCE6"; + case 0x3007: + return "GL_CLIP_DISTANCE7"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorBuffer: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x400: + return "GL_FRONT_LEFT"; + case 0x401: + return "GL_FRONT_RIGHT"; + case 0x402: + return "GL_BACK_LEFT"; + case 0x403: + return "GL_BACK_RIGHT"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x406: + return "GL_LEFT"; + case 0x407: + return "GL_RIGHT"; + case 0x408: + return "GL_FRONT_AND_BACK"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorMaterialFace: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorMaterialParameter: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1600: + return "GL_EMISSION"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorPointerType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorTableTarget: + { + switch (value) + { + case 0x80D0: + return "GL_COLOR_TABLE"; + case 0x80D1: + return "GL_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D2: + return "GL_POST_COLOR_MATRIX_COLOR_TABLE"; + case 0x80D3: + return "GL_PROXY_COLOR_TABLE"; + case 0x80D4: + return "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D5: + return "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ColorTableTargetSGI: + { + switch (value) + { + case 0x80D0: + return "GL_COLOR_TABLE"; + case 0x80D1: + return "GL_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D2: + return "GL_POST_COLOR_MATRIX_COLOR_TABLE"; + case 0x80D3: + return "GL_PROXY_COLOR_TABLE"; + case 0x80D4: + return "GL_PROXY_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D5: + return "GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CombinerBiasNV: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CombinerComponentUsageNV: + { + switch (value) + { + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CombinerPortionNV: + { + switch (value) + { + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CombinerScaleNV: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ConditionalRenderMode: + { + switch (value) + { + case 0x8E13: + return "GL_QUERY_WAIT"; + case 0x8E14: + return "GL_QUERY_NO_WAIT"; + case 0x8E15: + return "GL_QUERY_BY_REGION_WAIT"; + case 0x8E16: + return "GL_QUERY_BY_REGION_NO_WAIT"; + case 0x8E17: + return "GL_QUERY_WAIT_INVERTED"; + case 0x8E18: + return "GL_QUERY_NO_WAIT_INVERTED"; + case 0x8E19: + return "GL_QUERY_BY_REGION_WAIT_INVERTED"; + case 0x8E1A: + return "GL_QUERY_BY_REGION_NO_WAIT_INVERTED"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ContainerType: + { + switch (value) + { + case 0x8B40: + return "GL_PROGRAM_OBJECT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ContextFlagMask: + { + switch (value) + { + case 0x1: + return "GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT"; + case 0x2: + return "GL_CONTEXT_FLAG_DEBUG_BIT"; + case 0x4: + return "GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT"; + case 0x8: + return "GL_CONTEXT_FLAG_NO_ERROR_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ContextProfileMask: + { + switch (value) + { + case 0x1: + return "GL_CONTEXT_CORE_PROFILE_BIT"; + case 0x2: + return "GL_CONTEXT_COMPATIBILITY_PROFILE_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ConvolutionTarget: + { + switch (value) + { + case 0x8010: + return "GL_CONVOLUTION_1D"; + case 0x8011: + return "GL_CONVOLUTION_2D"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ConvolutionTargetEXT: + { + switch (value) + { + case 0x8010: + return "GL_CONVOLUTION_1D"; + case 0x8011: + return "GL_CONVOLUTION_2D"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CopyBufferSubDataTarget: + { + switch (value) + { + case 0x8892: + return "GL_ARRAY_BUFFER"; + case 0x8893: + return "GL_ELEMENT_ARRAY_BUFFER"; + case 0x88EB: + return "GL_PIXEL_PACK_BUFFER"; + case 0x88EC: + return "GL_PIXEL_UNPACK_BUFFER"; + case 0x8A11: + return "GL_UNIFORM_BUFFER"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x8F36: + return "GL_COPY_READ_BUFFER"; + case 0x8F37: + return "GL_COPY_WRITE_BUFFER"; + case 0x8F3F: + return "GL_DRAW_INDIRECT_BUFFER"; + case 0x90D2: + return "GL_SHADER_STORAGE_BUFFER"; + case 0x90EE: + return "GL_DISPATCH_INDIRECT_BUFFER"; + case 0x9192: + return "GL_QUERY_BUFFER"; + case 0x92C0: + return "GL_ATOMIC_COUNTER_BUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CopyImageSubDataTarget: + { + switch (value) + { + case 0xDE0: + return "GL_TEXTURE_1D"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x806F: + return "GL_TEXTURE_3D"; + case 0x84F5: + return "GL_TEXTURE_RECTANGLE"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8C18: + return "GL_TEXTURE_1D_ARRAY"; + case 0x8C1A: + return "GL_TEXTURE_2D_ARRAY"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x9009: + return "GL_TEXTURE_CUBE_MAP_ARRAY"; + case 0x9100: + return "GL_TEXTURE_2D_MULTISAMPLE"; + case 0x9102: + return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::CullFaceMode: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DebugSeverity: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x826B: + return "GL_DEBUG_SEVERITY_NOTIFICATION"; + case 0x9146: + return "GL_DEBUG_SEVERITY_HIGH"; + case 0x9147: + return "GL_DEBUG_SEVERITY_MEDIUM"; + case 0x9148: + return "GL_DEBUG_SEVERITY_LOW"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DebugSource: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x8246: + return "GL_DEBUG_SOURCE_API"; + case 0x8247: + return "GL_DEBUG_SOURCE_WINDOW_SYSTEM"; + case 0x8248: + return "GL_DEBUG_SOURCE_SHADER_COMPILER"; + case 0x8249: + return "GL_DEBUG_SOURCE_THIRD_PARTY"; + case 0x824A: + return "GL_DEBUG_SOURCE_APPLICATION"; + case 0x824B: + return "GL_DEBUG_SOURCE_OTHER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DebugType: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x824C: + return "GL_DEBUG_TYPE_ERROR"; + case 0x824D: + return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR"; + case 0x824E: + return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR"; + case 0x824F: + return "GL_DEBUG_TYPE_PORTABILITY"; + case 0x8250: + return "GL_DEBUG_TYPE_PERFORMANCE"; + case 0x8251: + return "GL_DEBUG_TYPE_OTHER"; + case 0x8268: + return "GL_DEBUG_TYPE_MARKER"; + case 0x8269: + return "GL_DEBUG_TYPE_PUSH_GROUP"; + case 0x826A: + return "GL_DEBUG_TYPE_POP_GROUP"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DepthFunction: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DepthStencilTextureMode: + { + switch (value) + { + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DrawBufferMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x400: + return "GL_FRONT_LEFT"; + case 0x401: + return "GL_FRONT_RIGHT"; + case 0x402: + return "GL_BACK_LEFT"; + case 0x403: + return "GL_BACK_RIGHT"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x406: + return "GL_LEFT"; + case 0x407: + return "GL_RIGHT"; + case 0x408: + return "GL_FRONT_AND_BACK"; + case 0x409: + return "GL_AUX0"; + case 0x40A: + return "GL_AUX1"; + case 0x40B: + return "GL_AUX2"; + case 0x40C: + return "GL_AUX3"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::DrawElementsType: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ElementPointerTypeATI: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::EnableCap: + { + switch (value) + { + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB24: + return "GL_LINE_STIPPLE"; + case 0xB41: + return "GL_POLYGON_SMOOTH"; + case 0xB42: + return "GL_POLYGON_STIPPLE"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF1: + return "GL_INDEX_LOGIC_OP"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xC60: + return "GL_TEXTURE_GEN_S"; + case 0xC61: + return "GL_TEXTURE_GEN_T"; + case 0xC62: + return "GL_TEXTURE_GEN_R"; + case 0xC63: + return "GL_TEXTURE_GEN_Q"; + case 0xD80: + return "GL_AUTO_NORMAL"; + case 0xD90: + return "GL_MAP1_COLOR_4"; + case 0xD91: + return "GL_MAP1_INDEX"; + case 0xD92: + return "GL_MAP1_NORMAL"; + case 0xD93: + return "GL_MAP1_TEXTURE_COORD_1"; + case 0xD94: + return "GL_MAP1_TEXTURE_COORD_2"; + case 0xD95: + return "GL_MAP1_TEXTURE_COORD_3"; + case 0xD96: + return "GL_MAP1_TEXTURE_COORD_4"; + case 0xD97: + return "GL_MAP1_VERTEX_3"; + case 0xD98: + return "GL_MAP1_VERTEX_4"; + case 0xDB0: + return "GL_MAP2_COLOR_4"; + case 0xDB1: + return "GL_MAP2_INDEX"; + case 0xDB2: + return "GL_MAP2_NORMAL"; + case 0xDB3: + return "GL_MAP2_TEXTURE_COORD_1"; + case 0xDB4: + return "GL_MAP2_TEXTURE_COORD_2"; + case 0xDB5: + return "GL_MAP2_TEXTURE_COORD_3"; + case 0xDB6: + return "GL_MAP2_TEXTURE_COORD_4"; + case 0xDB7: + return "GL_MAP2_VERTEX_3"; + case 0xDB8: + return "GL_MAP2_VERTEX_4"; + case 0xDE0: + return "GL_TEXTURE_1D"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x2A01: + return "GL_POLYGON_OFFSET_POINT"; + case 0x2A02: + return "GL_POLYGON_OFFSET_LINE"; + case 0x3000: + return "GL_CLIP_DISTANCE0"; + case 0x3001: + return "GL_CLIP_DISTANCE1"; + case 0x3002: + return "GL_CLIP_DISTANCE2"; + case 0x3003: + return "GL_CLIP_DISTANCE3"; + case 0x3004: + return "GL_CLIP_DISTANCE4"; + case 0x3005: + return "GL_CLIP_DISTANCE5"; + case 0x3006: + return "GL_CLIP_DISTANCE6"; + case 0x3007: + return "GL_CLIP_DISTANCE7"; + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8077: + return "GL_INDEX_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x8079: + return "GL_EDGE_FLAG_ARRAY"; + case 0x809D: + return "GL_MULTISAMPLE"; + case 0x809E: + return "GL_SAMPLE_ALPHA_TO_COVERAGE"; + case 0x809F: + return "GL_SAMPLE_ALPHA_TO_ONE"; + case 0x80A0: + return "GL_SAMPLE_COVERAGE"; + case 0x80D0: + return "GL_COLOR_TABLE"; + case 0x80D1: + return "GL_POST_CONVOLUTION_COLOR_TABLE"; + case 0x80D2: + return "GL_POST_COLOR_MATRIX_COLOR_TABLE"; + case 0x8242: + return "GL_DEBUG_OUTPUT_SYNCHRONOUS"; + case 0x84F5: + return "GL_TEXTURE_RECTANGLE"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8642: + return "GL_PROGRAM_POINT_SIZE"; + case 0x864F: + return "GL_DEPTH_CLAMP"; + case 0x884F: + return "GL_TEXTURE_CUBE_MAP_SEAMLESS"; + case 0x8C36: + return "GL_SAMPLE_SHADING"; + case 0x8C89: + return "GL_RASTERIZER_DISCARD"; + case 0x8D69: + return "GL_PRIMITIVE_RESTART_FIXED_INDEX"; + case 0x8DB9: + return "GL_FRAMEBUFFER_SRGB"; + case 0x8E51: + return "GL_SAMPLE_MASK"; + case 0x8F9D: + return "GL_PRIMITIVE_RESTART"; + case 0x92E0: + return "GL_DEBUG_OUTPUT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ErrorCode: + { + switch (value) + { + case 0x0: + return "GL_NO_ERROR"; + case 0x500: + return "GL_INVALID_ENUM"; + case 0x501: + return "GL_INVALID_VALUE"; + case 0x502: + return "GL_INVALID_OPERATION"; + case 0x503: + return "GL_STACK_OVERFLOW"; + case 0x504: + return "GL_STACK_UNDERFLOW"; + case 0x505: + return "GL_OUT_OF_MEMORY"; + case 0x506: + return "GL_INVALID_FRAMEBUFFER_OPERATION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ExternalHandleType: + { + switch (value) + { + case 0x9586: + return "GL_HANDLE_TYPE_OPAQUE_FD_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FeedBackToken: + { + switch (value) + { + case 0x700: + return "GL_PASS_THROUGH_TOKEN"; + case 0x701: + return "GL_POINT_TOKEN"; + case 0x702: + return "GL_LINE_TOKEN"; + case 0x703: + return "GL_POLYGON_TOKEN"; + case 0x704: + return "GL_BITMAP_TOKEN"; + case 0x705: + return "GL_DRAW_PIXEL_TOKEN"; + case 0x706: + return "GL_COPY_PIXEL_TOKEN"; + case 0x707: + return "GL_LINE_RESET_TOKEN"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FeedbackType: + { + switch (value) + { + case 0x600: + return "GL_2D"; + case 0x601: + return "GL_3D"; + case 0x602: + return "GL_3D_COLOR"; + case 0x603: + return "GL_3D_COLOR_TEXTURE"; + case 0x604: + return "GL_4D_COLOR_TEXTURE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FenceConditionNV: + { + switch (value) + { + case 0x84F2: + return "GL_ALL_COMPLETED_NV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FenceParameterNameNV: + { + switch (value) + { + case 0x84F3: + return "GL_FENCE_STATUS_NV"; + case 0x84F4: + return "GL_FENCE_CONDITION_NV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogCoordSrc: + { + switch (value) + { + case 0x8451: + return "GL_FOG_COORD"; + case 0x8452: + return "GL_FRAGMENT_DEPTH"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogCoordinatePointerType: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogMode: + { + switch (value) + { + case 0x800: + return "GL_EXP"; + case 0x801: + return "GL_EXP2"; + case 0x2601: + return "GL_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogPName: + { + switch (value) + { + case 0xB61: + return "GL_FOG_INDEX"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0x8450: + return "GL_FOG_COORD_SRC"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogParameter: + { + switch (value) + { + case 0xB61: + return "GL_FOG_INDEX"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogPointerTypeEXT: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FogPointerTypeIBM: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentLightParameterSGIX: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentShaderDestMaskATI: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentShaderDestModMaskATI: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentShaderGenericSourceATI: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentShaderTextureSourceATI: + { + switch (value) + { + case 0x84C0: + return "GL_TEXTURE0"; + case 0x84C1: + return "GL_TEXTURE1"; + case 0x84C2: + return "GL_TEXTURE2"; + case 0x84C3: + return "GL_TEXTURE3"; + case 0x84C4: + return "GL_TEXTURE4"; + case 0x84C5: + return "GL_TEXTURE5"; + case 0x84C6: + return "GL_TEXTURE6"; + case 0x84C7: + return "GL_TEXTURE7"; + case 0x84C8: + return "GL_TEXTURE8"; + case 0x84C9: + return "GL_TEXTURE9"; + case 0x84CA: + return "GL_TEXTURE10"; + case 0x84CB: + return "GL_TEXTURE11"; + case 0x84CC: + return "GL_TEXTURE12"; + case 0x84CD: + return "GL_TEXTURE13"; + case 0x84CE: + return "GL_TEXTURE14"; + case 0x84CF: + return "GL_TEXTURE15"; + case 0x84D0: + return "GL_TEXTURE16"; + case 0x84D1: + return "GL_TEXTURE17"; + case 0x84D2: + return "GL_TEXTURE18"; + case 0x84D3: + return "GL_TEXTURE19"; + case 0x84D4: + return "GL_TEXTURE20"; + case 0x84D5: + return "GL_TEXTURE21"; + case 0x84D6: + return "GL_TEXTURE22"; + case 0x84D7: + return "GL_TEXTURE23"; + case 0x84D8: + return "GL_TEXTURE24"; + case 0x84D9: + return "GL_TEXTURE25"; + case 0x84DA: + return "GL_TEXTURE26"; + case 0x84DB: + return "GL_TEXTURE27"; + case 0x84DC: + return "GL_TEXTURE28"; + case 0x84DD: + return "GL_TEXTURE29"; + case 0x84DE: + return "GL_TEXTURE30"; + case 0x84DF: + return "GL_TEXTURE31"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FragmentShaderValueRepATI: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FramebufferAttachment: + { + switch (value) + { + case 0x821A: + return "GL_DEPTH_STENCIL_ATTACHMENT"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + case 0x8D00: + return "GL_DEPTH_ATTACHMENT"; + case 0x8D20: + return "GL_STENCIL_ATTACHMENT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FramebufferAttachmentParameterName: + { + switch (value) + { + case 0x8210: + return "GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING"; + case 0x8211: + return "GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE"; + case 0x8212: + return "GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE"; + case 0x8213: + return "GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE"; + case 0x8214: + return "GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE"; + case 0x8215: + return "GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE"; + case 0x8216: + return "GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE"; + case 0x8217: + return "GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE"; + case 0x8CD0: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE"; + case 0x8CD1: + return "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME"; + case 0x8CD2: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL"; + case 0x8CD3: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE"; + case 0x8CD4: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER"; + case 0x8DA7: + return "GL_FRAMEBUFFER_ATTACHMENT_LAYERED"; + case 0x9630: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_NUM_VIEWS_OVR"; + case 0x9632: + return "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_BASE_VIEW_INDEX_OVR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FramebufferParameterName: + { + switch (value) + { + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FramebufferStatus: + { + switch (value) + { + case 0x8219: + return "GL_FRAMEBUFFER_UNDEFINED"; + case 0x8CD5: + return "GL_FRAMEBUFFER_COMPLETE"; + case 0x8CD6: + return "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT"; + case 0x8CD7: + return "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT"; + case 0x8CDB: + return "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER"; + case 0x8CDC: + return "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER"; + case 0x8CDD: + return "GL_FRAMEBUFFER_UNSUPPORTED"; + case 0x8D56: + return "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"; + case 0x8DA8: + return "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FramebufferTarget: + { + switch (value) + { + case 0x8CA8: + return "GL_READ_FRAMEBUFFER"; + case 0x8CA9: + return "GL_DRAW_FRAMEBUFFER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::FrontFaceDirection: + { + switch (value) + { + case 0x900: + return "GL_CW"; + case 0x901: + return "GL_CCW"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetFramebufferParameter: + { + switch (value) + { + case 0xC32: + return "GL_DOUBLEBUFFER"; + case 0xC33: + return "GL_STEREO"; + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; + case 0x9310: + return "GL_FRAMEBUFFER_DEFAULT_WIDTH"; + case 0x9311: + return "GL_FRAMEBUFFER_DEFAULT_HEIGHT"; + case 0x9312: + return "GL_FRAMEBUFFER_DEFAULT_LAYERS"; + case 0x9313: + return "GL_FRAMEBUFFER_DEFAULT_SAMPLES"; + case 0x9314: + return "GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetMapQuery: + { + switch (value) + { + case 0xA00: + return "GL_COEFF"; + case 0xA01: + return "GL_ORDER"; + case 0xA02: + return "GL_DOMAIN"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetMultisamplePNameNV: + { + switch (value) + { + case 0x8E50: + return "GL_SAMPLE_POSITION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetPName: + { + switch (value) + { + case 0xB00: + return "GL_CURRENT_COLOR"; + case 0xB01: + return "GL_CURRENT_INDEX"; + case 0xB02: + return "GL_CURRENT_NORMAL"; + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xB04: + return "GL_CURRENT_RASTER_COLOR"; + case 0xB05: + return "GL_CURRENT_RASTER_INDEX"; + case 0xB06: + return "GL_CURRENT_RASTER_TEXTURE_COORDS"; + case 0xB07: + return "GL_CURRENT_RASTER_POSITION"; + case 0xB08: + return "GL_CURRENT_RASTER_POSITION_VALID"; + case 0xB09: + return "GL_CURRENT_RASTER_DISTANCE"; + case 0xB10: + return "GL_POINT_SMOOTH"; + case 0xB11: + return "GL_POINT_SIZE"; + case 0xB12: + return "GL_POINT_SIZE_RANGE"; + case 0xB13: + return "GL_POINT_SIZE_GRANULARITY"; + case 0xB20: + return "GL_LINE_SMOOTH"; + case 0xB21: + return "GL_LINE_WIDTH"; + case 0xB22: + return "GL_LINE_WIDTH_RANGE"; + case 0xB23: + return "GL_LINE_WIDTH_GRANULARITY"; + case 0xB24: + return "GL_LINE_STIPPLE"; + case 0xB25: + return "GL_LINE_STIPPLE_PATTERN"; + case 0xB26: + return "GL_LINE_STIPPLE_REPEAT"; + case 0xB30: + return "GL_LIST_MODE"; + case 0xB31: + return "GL_MAX_LIST_NESTING"; + case 0xB32: + return "GL_LIST_BASE"; + case 0xB33: + return "GL_LIST_INDEX"; + case 0xB40: + return "GL_POLYGON_MODE"; + case 0xB41: + return "GL_POLYGON_SMOOTH"; + case 0xB42: + return "GL_POLYGON_STIPPLE"; + case 0xB43: + return "GL_EDGE_FLAG"; + case 0xB44: + return "GL_CULL_FACE"; + case 0xB45: + return "GL_CULL_FACE_MODE"; + case 0xB46: + return "GL_FRONT_FACE"; + case 0xB50: + return "GL_LIGHTING"; + case 0xB51: + return "GL_LIGHT_MODEL_LOCAL_VIEWER"; + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + case 0xB54: + return "GL_SHADE_MODEL"; + case 0xB55: + return "GL_COLOR_MATERIAL_FACE"; + case 0xB56: + return "GL_COLOR_MATERIAL_PARAMETER"; + case 0xB57: + return "GL_COLOR_MATERIAL"; + case 0xB60: + return "GL_FOG"; + case 0xB61: + return "GL_FOG_INDEX"; + case 0xB62: + return "GL_FOG_DENSITY"; + case 0xB63: + return "GL_FOG_START"; + case 0xB64: + return "GL_FOG_END"; + case 0xB65: + return "GL_FOG_MODE"; + case 0xB66: + return "GL_FOG_COLOR"; + case 0xB70: + return "GL_DEPTH_RANGE"; + case 0xB71: + return "GL_DEPTH_TEST"; + case 0xB72: + return "GL_DEPTH_WRITEMASK"; + case 0xB73: + return "GL_DEPTH_CLEAR_VALUE"; + case 0xB74: + return "GL_DEPTH_FUNC"; + case 0xB80: + return "GL_ACCUM_CLEAR_VALUE"; + case 0xB90: + return "GL_STENCIL_TEST"; + case 0xB91: + return "GL_STENCIL_CLEAR_VALUE"; + case 0xB92: + return "GL_STENCIL_FUNC"; + case 0xB93: + return "GL_STENCIL_VALUE_MASK"; + case 0xB94: + return "GL_STENCIL_FAIL"; + case 0xB95: + return "GL_STENCIL_PASS_DEPTH_FAIL"; + case 0xB96: + return "GL_STENCIL_PASS_DEPTH_PASS"; + case 0xB97: + return "GL_STENCIL_REF"; + case 0xB98: + return "GL_STENCIL_WRITEMASK"; + case 0xBA0: + return "GL_MATRIX_MODE"; + case 0xBA1: + return "GL_NORMALIZE"; + case 0xBA2: + return "GL_VIEWPORT"; + case 0xBA3: + return "GL_MODELVIEW_STACK_DEPTH"; + case 0xBA4: + return "GL_PROJECTION_STACK_DEPTH"; + case 0xBA5: + return "GL_TEXTURE_STACK_DEPTH"; + case 0xBA6: + return "GL_MODELVIEW_MATRIX"; + case 0xBA7: + return "GL_PROJECTION_MATRIX"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + case 0xBB0: + return "GL_ATTRIB_STACK_DEPTH"; + case 0xBB1: + return "GL_CLIENT_ATTRIB_STACK_DEPTH"; + case 0xBC0: + return "GL_ALPHA_TEST"; + case 0xBC1: + return "GL_ALPHA_TEST_FUNC"; + case 0xBC2: + return "GL_ALPHA_TEST_REF"; + case 0xBD0: + return "GL_DITHER"; + case 0xBE0: + return "GL_BLEND_DST"; + case 0xBE1: + return "GL_BLEND_SRC"; + case 0xBE2: + return "GL_BLEND"; + case 0xBF0: + return "GL_LOGIC_OP_MODE"; + case 0xBF1: + return "GL_INDEX_LOGIC_OP"; + case 0xBF2: + return "GL_COLOR_LOGIC_OP"; + case 0xC00: + return "GL_AUX_BUFFERS"; + case 0xC01: + return "GL_DRAW_BUFFER"; + case 0xC02: + return "GL_READ_BUFFER"; + case 0xC10: + return "GL_SCISSOR_BOX"; + case 0xC11: + return "GL_SCISSOR_TEST"; + case 0xC20: + return "GL_INDEX_CLEAR_VALUE"; + case 0xC21: + return "GL_INDEX_WRITEMASK"; + case 0xC22: + return "GL_COLOR_CLEAR_VALUE"; + case 0xC23: + return "GL_COLOR_WRITEMASK"; + case 0xC30: + return "GL_INDEX_MODE"; + case 0xC31: + return "GL_RGBA_MODE"; + case 0xC32: + return "GL_DOUBLEBUFFER"; + case 0xC33: + return "GL_STEREO"; + case 0xC40: + return "GL_RENDER_MODE"; + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC53: + return "GL_POLYGON_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0xC60: + return "GL_TEXTURE_GEN_S"; + case 0xC61: + return "GL_TEXTURE_GEN_T"; + case 0xC62: + return "GL_TEXTURE_GEN_R"; + case 0xC63: + return "GL_TEXTURE_GEN_Q"; + case 0xCB0: + return "GL_PIXEL_MAP_I_TO_I_SIZE"; + case 0xCB1: + return "GL_PIXEL_MAP_S_TO_S_SIZE"; + case 0xCB2: + return "GL_PIXEL_MAP_I_TO_R_SIZE"; + case 0xCB3: + return "GL_PIXEL_MAP_I_TO_G_SIZE"; + case 0xCB4: + return "GL_PIXEL_MAP_I_TO_B_SIZE"; + case 0xCB5: + return "GL_PIXEL_MAP_I_TO_A_SIZE"; + case 0xCB6: + return "GL_PIXEL_MAP_R_TO_R_SIZE"; + case 0xCB7: + return "GL_PIXEL_MAP_G_TO_G_SIZE"; + case 0xCB8: + return "GL_PIXEL_MAP_B_TO_B_SIZE"; + case 0xCB9: + return "GL_PIXEL_MAP_A_TO_A_SIZE"; + case 0xCF0: + return "GL_UNPACK_SWAP_BYTES"; + case 0xCF1: + return "GL_UNPACK_LSB_FIRST"; + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD00: + return "GL_PACK_SWAP_BYTES"; + case 0xD01: + return "GL_PACK_LSB_FIRST"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0xD10: + return "GL_MAP_COLOR"; + case 0xD11: + return "GL_MAP_STENCIL"; + case 0xD12: + return "GL_INDEX_SHIFT"; + case 0xD13: + return "GL_INDEX_OFFSET"; + case 0xD14: + return "GL_RED_SCALE"; + case 0xD15: + return "GL_RED_BIAS"; + case 0xD16: + return "GL_ZOOM_X"; + case 0xD17: + return "GL_ZOOM_Y"; + case 0xD18: + return "GL_GREEN_SCALE"; + case 0xD19: + return "GL_GREEN_BIAS"; + case 0xD1A: + return "GL_BLUE_SCALE"; + case 0xD1B: + return "GL_BLUE_BIAS"; + case 0xD1C: + return "GL_ALPHA_SCALE"; + case 0xD1D: + return "GL_ALPHA_BIAS"; + case 0xD1E: + return "GL_DEPTH_SCALE"; + case 0xD1F: + return "GL_DEPTH_BIAS"; + case 0xD30: + return "GL_MAX_EVAL_ORDER"; + case 0xD31: + return "GL_MAX_LIGHTS"; + case 0xD32: + return "GL_MAX_CLIP_DISTANCES"; + case 0xD33: + return "GL_MAX_TEXTURE_SIZE"; + case 0xD34: + return "GL_MAX_PIXEL_MAP_TABLE"; + case 0xD35: + return "GL_MAX_ATTRIB_STACK_DEPTH"; + case 0xD36: + return "GL_MAX_MODELVIEW_STACK_DEPTH"; + case 0xD37: + return "GL_MAX_NAME_STACK_DEPTH"; + case 0xD38: + return "GL_MAX_PROJECTION_STACK_DEPTH"; + case 0xD39: + return "GL_MAX_TEXTURE_STACK_DEPTH"; + case 0xD3A: + return "GL_MAX_VIEWPORT_DIMS"; + case 0xD3B: + return "GL_MAX_CLIENT_ATTRIB_STACK_DEPTH"; + case 0xD50: + return "GL_SUBPIXEL_BITS"; + case 0xD51: + return "GL_INDEX_BITS"; + case 0xD52: + return "GL_RED_BITS"; + case 0xD53: + return "GL_GREEN_BITS"; + case 0xD54: + return "GL_BLUE_BITS"; + case 0xD55: + return "GL_ALPHA_BITS"; + case 0xD56: + return "GL_DEPTH_BITS"; + case 0xD57: + return "GL_STENCIL_BITS"; + case 0xD58: + return "GL_ACCUM_RED_BITS"; + case 0xD59: + return "GL_ACCUM_GREEN_BITS"; + case 0xD5A: + return "GL_ACCUM_BLUE_BITS"; + case 0xD5B: + return "GL_ACCUM_ALPHA_BITS"; + case 0xD70: + return "GL_NAME_STACK_DEPTH"; + case 0xD80: + return "GL_AUTO_NORMAL"; + case 0xD90: + return "GL_MAP1_COLOR_4"; + case 0xD91: + return "GL_MAP1_INDEX"; + case 0xD92: + return "GL_MAP1_NORMAL"; + case 0xD93: + return "GL_MAP1_TEXTURE_COORD_1"; + case 0xD94: + return "GL_MAP1_TEXTURE_COORD_2"; + case 0xD95: + return "GL_MAP1_TEXTURE_COORD_3"; + case 0xD96: + return "GL_MAP1_TEXTURE_COORD_4"; + case 0xD97: + return "GL_MAP1_VERTEX_3"; + case 0xD98: + return "GL_MAP1_VERTEX_4"; + case 0xDB0: + return "GL_MAP2_COLOR_4"; + case 0xDB1: + return "GL_MAP2_INDEX"; + case 0xDB2: + return "GL_MAP2_NORMAL"; + case 0xDB3: + return "GL_MAP2_TEXTURE_COORD_1"; + case 0xDB4: + return "GL_MAP2_TEXTURE_COORD_2"; + case 0xDB5: + return "GL_MAP2_TEXTURE_COORD_3"; + case 0xDB6: + return "GL_MAP2_TEXTURE_COORD_4"; + case 0xDB7: + return "GL_MAP2_VERTEX_3"; + case 0xDB8: + return "GL_MAP2_VERTEX_4"; + case 0xDD0: + return "GL_MAP1_GRID_DOMAIN"; + case 0xDD1: + return "GL_MAP1_GRID_SEGMENTS"; + case 0xDD2: + return "GL_MAP2_GRID_DOMAIN"; + case 0xDD3: + return "GL_MAP2_GRID_SEGMENTS"; + case 0xDE0: + return "GL_TEXTURE_1D"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0xDF1: + return "GL_FEEDBACK_BUFFER_SIZE"; + case 0xDF2: + return "GL_FEEDBACK_BUFFER_TYPE"; + case 0xDF4: + return "GL_SELECTION_BUFFER_SIZE"; + case 0x2A00: + return "GL_POLYGON_OFFSET_UNITS"; + case 0x2A01: + return "GL_POLYGON_OFFSET_POINT"; + case 0x2A02: + return "GL_POLYGON_OFFSET_LINE"; + case 0x3000: + return "GL_CLIP_PLANE0"; + case 0x3001: + return "GL_CLIP_PLANE1"; + case 0x3002: + return "GL_CLIP_PLANE2"; + case 0x3003: + return "GL_CLIP_PLANE3"; + case 0x3004: + return "GL_CLIP_PLANE4"; + case 0x3005: + return "GL_CLIP_PLANE5"; + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + case 0x8005: + return "GL_BLEND_COLOR"; + case 0x8009: + return "GL_BLEND_EQUATION"; + case 0x8037: + return "GL_POLYGON_OFFSET_FILL"; + case 0x8038: + return "GL_POLYGON_OFFSET_FACTOR"; + case 0x8068: + return "GL_TEXTURE_BINDING_1D"; + case 0x8069: + return "GL_TEXTURE_BINDING_2D"; + case 0x806A: + return "GL_TEXTURE_BINDING_3D"; + case 0x806B: + return "GL_PACK_SKIP_IMAGES"; + case 0x806C: + return "GL_PACK_IMAGE_HEIGHT"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + case 0x8073: + return "GL_MAX_3D_TEXTURE_SIZE"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x8075: + return "GL_NORMAL_ARRAY"; + case 0x8076: + return "GL_COLOR_ARRAY"; + case 0x8077: + return "GL_INDEX_ARRAY"; + case 0x8078: + return "GL_TEXTURE_COORD_ARRAY"; + case 0x8079: + return "GL_EDGE_FLAG_ARRAY"; + case 0x807A: + return "GL_VERTEX_ARRAY_SIZE"; + case 0x807B: + return "GL_VERTEX_ARRAY_TYPE"; + case 0x807C: + return "GL_VERTEX_ARRAY_STRIDE"; + case 0x807E: + return "GL_NORMAL_ARRAY_TYPE"; + case 0x807F: + return "GL_NORMAL_ARRAY_STRIDE"; + case 0x8081: + return "GL_COLOR_ARRAY_SIZE"; + case 0x8082: + return "GL_COLOR_ARRAY_TYPE"; + case 0x8083: + return "GL_COLOR_ARRAY_STRIDE"; + case 0x8085: + return "GL_INDEX_ARRAY_TYPE"; + case 0x8086: + return "GL_INDEX_ARRAY_STRIDE"; + case 0x8088: + return "GL_TEXTURE_COORD_ARRAY_SIZE"; + case 0x8089: + return "GL_TEXTURE_COORD_ARRAY_TYPE"; + case 0x808A: + return "GL_TEXTURE_COORD_ARRAY_STRIDE"; + case 0x808C: + return "GL_EDGE_FLAG_ARRAY_STRIDE"; + case 0x80A8: + return "GL_SAMPLE_BUFFERS"; + case 0x80A9: + return "GL_SAMPLES"; + case 0x80AA: + return "GL_SAMPLE_COVERAGE_VALUE"; + case 0x80AB: + return "GL_SAMPLE_COVERAGE_INVERT"; + case 0x80C8: + return "GL_BLEND_DST_RGB"; + case 0x80C9: + return "GL_BLEND_SRC_RGB"; + case 0x80CA: + return "GL_BLEND_DST_ALPHA"; + case 0x80CB: + return "GL_BLEND_SRC_ALPHA"; + case 0x80E8: + return "GL_MAX_ELEMENTS_VERTICES"; + case 0x80E9: + return "GL_MAX_ELEMENTS_INDICES"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x81F8: + return "GL_LIGHT_MODEL_COLOR_CONTROL"; + case 0x821B: + return "GL_MAJOR_VERSION"; + case 0x821C: + return "GL_MINOR_VERSION"; + case 0x821D: + return "GL_NUM_EXTENSIONS"; + case 0x821E: + return "GL_CONTEXT_FLAGS"; + case 0x825A: + return "GL_PROGRAM_PIPELINE_BINDING"; + case 0x825B: + return "GL_MAX_VIEWPORTS"; + case 0x825C: + return "GL_VIEWPORT_SUBPIXEL_BITS"; + case 0x825D: + return "GL_VIEWPORT_BOUNDS_RANGE"; + case 0x825E: + return "GL_LAYER_PROVOKING_VERTEX"; + case 0x825F: + return "GL_VIEWPORT_INDEX_PROVOKING_VERTEX"; + case 0x8263: + return "GL_MAX_COMPUTE_UNIFORM_COMPONENTS"; + case 0x8264: + return "GL_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS"; + case 0x8265: + return "GL_MAX_COMPUTE_ATOMIC_COUNTERS"; + case 0x8266: + return "GL_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS"; + case 0x826C: + return "GL_MAX_DEBUG_GROUP_STACK_DEPTH"; + case 0x826D: + return "GL_DEBUG_GROUP_STACK_DEPTH"; + case 0x826E: + return "GL_MAX_UNIFORM_LOCATIONS"; + case 0x82D6: + return "GL_VERTEX_BINDING_DIVISOR"; + case 0x82D7: + return "GL_VERTEX_BINDING_OFFSET"; + case 0x82D8: + return "GL_VERTEX_BINDING_STRIDE"; + case 0x82D9: + return "GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x82DA: + return "GL_MAX_VERTEX_ATTRIB_BINDINGS"; + case 0x82E8: + return "GL_MAX_LABEL_LENGTH"; + case 0x846D: + return "GL_ALIASED_POINT_SIZE_RANGE"; + case 0x846E: + return "GL_ALIASED_LINE_WIDTH_RANGE"; + case 0x84E0: + return "GL_ACTIVE_TEXTURE"; + case 0x84E8: + return "GL_MAX_RENDERBUFFER_SIZE"; + case 0x84EF: + return "GL_TEXTURE_COMPRESSION_HINT"; + case 0x84F6: + return "GL_TEXTURE_BINDING_RECTANGLE"; + case 0x84F8: + return "GL_MAX_RECTANGLE_TEXTURE_SIZE"; + case 0x84FD: + return "GL_MAX_TEXTURE_LOD_BIAS"; + case 0x8514: + return "GL_TEXTURE_BINDING_CUBE_MAP"; + case 0x851C: + return "GL_MAX_CUBE_MAP_TEXTURE_SIZE"; + case 0x85B5: + return "GL_VERTEX_ARRAY_BINDING"; + case 0x8642: + return "GL_PROGRAM_POINT_SIZE"; + case 0x86A2: + return "GL_NUM_COMPRESSED_TEXTURE_FORMATS"; + case 0x86A3: + return "GL_COMPRESSED_TEXTURE_FORMATS"; + case 0x87FE: + return "GL_NUM_PROGRAM_BINARY_FORMATS"; + case 0x87FF: + return "GL_PROGRAM_BINARY_FORMATS"; + case 0x8800: + return "GL_STENCIL_BACK_FUNC"; + case 0x8801: + return "GL_STENCIL_BACK_FAIL"; + case 0x8802: + return "GL_STENCIL_BACK_PASS_DEPTH_FAIL"; + case 0x8803: + return "GL_STENCIL_BACK_PASS_DEPTH_PASS"; + case 0x8824: + return "GL_MAX_DRAW_BUFFERS"; + case 0x883D: + return "GL_BLEND_EQUATION_ALPHA"; + case 0x8869: + return "GL_MAX_VERTEX_ATTRIBS"; + case 0x8872: + return "GL_MAX_TEXTURE_IMAGE_UNITS"; + case 0x8894: + return "GL_ARRAY_BUFFER_BINDING"; + case 0x8895: + return "GL_ELEMENT_ARRAY_BUFFER_BINDING"; + case 0x88ED: + return "GL_PIXEL_PACK_BUFFER_BINDING"; + case 0x88EF: + return "GL_PIXEL_UNPACK_BUFFER_BINDING"; + case 0x88FC: + return "GL_MAX_DUAL_SOURCE_DRAW_BUFFERS"; + case 0x88FF: + return "GL_MAX_ARRAY_TEXTURE_LAYERS"; + case 0x8904: + return "GL_MIN_PROGRAM_TEXEL_OFFSET"; + case 0x8905: + return "GL_MAX_PROGRAM_TEXEL_OFFSET"; + case 0x8919: + return "GL_SAMPLER_BINDING"; + case 0x8A28: + return "GL_UNIFORM_BUFFER_BINDING"; + case 0x8A29: + return "GL_UNIFORM_BUFFER_START"; + case 0x8A2A: + return "GL_UNIFORM_BUFFER_SIZE"; + case 0x8A2B: + return "GL_MAX_VERTEX_UNIFORM_BLOCKS"; + case 0x8A2C: + return "GL_MAX_GEOMETRY_UNIFORM_BLOCKS"; + case 0x8A2D: + return "GL_MAX_FRAGMENT_UNIFORM_BLOCKS"; + case 0x8A2E: + return "GL_MAX_COMBINED_UNIFORM_BLOCKS"; + case 0x8A2F: + return "GL_MAX_UNIFORM_BUFFER_BINDINGS"; + case 0x8A30: + return "GL_MAX_UNIFORM_BLOCK_SIZE"; + case 0x8A31: + return "GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS"; + case 0x8A32: + return "GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8A33: + return "GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8A34: + return "GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT"; + case 0x8B49: + return "GL_MAX_FRAGMENT_UNIFORM_COMPONENTS"; + case 0x8B4A: + return "GL_MAX_VERTEX_UNIFORM_COMPONENTS"; + case 0x8B4B: + return "GL_MAX_VARYING_COMPONENTS"; + case 0x8B4C: + return "GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS"; + case 0x8B4D: + return "GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + case 0x8B8D: + return "GL_CURRENT_PROGRAM"; + case 0x8B9A: + return "GL_IMPLEMENTATION_COLOR_READ_TYPE"; + case 0x8B9B: + return "GL_IMPLEMENTATION_COLOR_READ_FORMAT"; + case 0x8C1C: + return "GL_TEXTURE_BINDING_1D_ARRAY"; + case 0x8C1D: + return "GL_TEXTURE_BINDING_2D_ARRAY"; + case 0x8C29: + return "GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS"; + case 0x8C2B: + return "GL_MAX_TEXTURE_BUFFER_SIZE"; + case 0x8C2C: + return "GL_TEXTURE_BINDING_BUFFER"; + case 0x8C84: + return "GL_TRANSFORM_FEEDBACK_BUFFER_START"; + case 0x8C85: + return "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"; + case 0x8C8F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"; + case 0x8CA3: + return "GL_STENCIL_BACK_REF"; + case 0x8CA4: + return "GL_STENCIL_BACK_VALUE_MASK"; + case 0x8CA5: + return "GL_STENCIL_BACK_WRITEMASK"; + case 0x8CA6: + return "GL_DRAW_FRAMEBUFFER_BINDING"; + case 0x8CA7: + return "GL_RENDERBUFFER_BINDING"; + case 0x8CAA: + return "GL_READ_FRAMEBUFFER_BINDING"; + case 0x8CDF: + return "GL_MAX_COLOR_ATTACHMENTS"; + case 0x8D6B: + return "GL_MAX_ELEMENT_INDEX"; + case 0x8DDF: + return "GL_MAX_GEOMETRY_UNIFORM_COMPONENTS"; + case 0x8DF8: + return "GL_SHADER_BINARY_FORMATS"; + case 0x8DF9: + return "GL_NUM_SHADER_BINARY_FORMATS"; + case 0x8DFA: + return "GL_SHADER_COMPILER"; + case 0x8DFB: + return "GL_MAX_VERTEX_UNIFORM_VECTORS"; + case 0x8DFC: + return "GL_MAX_VARYING_VECTORS"; + case 0x8DFD: + return "GL_MAX_FRAGMENT_UNIFORM_VECTORS"; + case 0x8E28: + return "GL_TIMESTAMP"; + case 0x8E4F: + return "GL_PROVOKING_VERTEX"; + case 0x8E59: + return "GL_MAX_SAMPLE_MASK_WORDS"; + case 0x8E89: + return "GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS"; + case 0x8E8A: + return "GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS"; + case 0x8F9E: + return "GL_PRIMITIVE_RESTART_INDEX"; + case 0x90BC: + return "GL_MIN_MAP_BUFFER_ALIGNMENT"; + case 0x90D3: + return "GL_SHADER_STORAGE_BUFFER_BINDING"; + case 0x90D4: + return "GL_SHADER_STORAGE_BUFFER_START"; + case 0x90D5: + return "GL_SHADER_STORAGE_BUFFER_SIZE"; + case 0x90D6: + return "GL_MAX_VERTEX_SHADER_STORAGE_BLOCKS"; + case 0x90D7: + return "GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS"; + case 0x90D8: + return "GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS"; + case 0x90D9: + return "GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS"; + case 0x90DA: + return "GL_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS"; + case 0x90DB: + return "GL_MAX_COMPUTE_SHADER_STORAGE_BLOCKS"; + case 0x90DC: + return "GL_MAX_COMBINED_SHADER_STORAGE_BLOCKS"; + case 0x90DD: + return "GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS"; + case 0x90DF: + return "GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT"; + case 0x90EB: + return "GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS"; + case 0x90EF: + return "GL_DISPATCH_INDIRECT_BUFFER_BINDING"; + case 0x9104: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE"; + case 0x9105: + return "GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY"; + case 0x910E: + return "GL_MAX_COLOR_TEXTURE_SAMPLES"; + case 0x910F: + return "GL_MAX_DEPTH_TEXTURE_SAMPLES"; + case 0x9110: + return "GL_MAX_INTEGER_SAMPLES"; + case 0x9111: + return "GL_MAX_SERVER_WAIT_TIMEOUT"; + case 0x9122: + return "GL_MAX_VERTEX_OUTPUT_COMPONENTS"; + case 0x9123: + return "GL_MAX_GEOMETRY_INPUT_COMPONENTS"; + case 0x9124: + return "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"; + case 0x9125: + return "GL_MAX_FRAGMENT_INPUT_COMPONENTS"; + case 0x9126: + return "GL_CONTEXT_PROFILE_MASK"; + case 0x919F: + return "GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT"; + case 0x91BB: + return "GL_MAX_COMPUTE_UNIFORM_BLOCKS"; + case 0x91BC: + return "GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS"; + case 0x91BE: + return "GL_MAX_COMPUTE_WORK_GROUP_COUNT"; + case 0x91BF: + return "GL_MAX_COMPUTE_WORK_GROUP_SIZE"; + case 0x92D2: + return "GL_MAX_VERTEX_ATOMIC_COUNTERS"; + case 0x92D3: + return "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"; + case 0x92D4: + return "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"; + case 0x92D5: + return "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"; + case 0x92D6: + return "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"; + case 0x92D7: + return "GL_MAX_COMBINED_ATOMIC_COUNTERS"; + case 0x9315: + return "GL_MAX_FRAMEBUFFER_WIDTH"; + case 0x9316: + return "GL_MAX_FRAMEBUFFER_HEIGHT"; + case 0x9317: + return "GL_MAX_FRAMEBUFFER_LAYERS"; + case 0x9318: + return "GL_MAX_FRAMEBUFFER_SAMPLES"; + case 0x9596: + return "GL_NUM_DEVICE_UUIDS_EXT"; + case 0x9597: + return "GL_DEVICE_UUID_EXT"; + case 0x9598: + return "GL_DRIVER_UUID_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetPixelMap: + { + switch (value) + { + case 0xC70: + return "GL_PIXEL_MAP_I_TO_I"; + case 0xC71: + return "GL_PIXEL_MAP_S_TO_S"; + case 0xC72: + return "GL_PIXEL_MAP_I_TO_R"; + case 0xC73: + return "GL_PIXEL_MAP_I_TO_G"; + case 0xC74: + return "GL_PIXEL_MAP_I_TO_B"; + case 0xC75: + return "GL_PIXEL_MAP_I_TO_A"; + case 0xC76: + return "GL_PIXEL_MAP_R_TO_R"; + case 0xC77: + return "GL_PIXEL_MAP_G_TO_G"; + case 0xC78: + return "GL_PIXEL_MAP_B_TO_B"; + case 0xC79: + return "GL_PIXEL_MAP_A_TO_A"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetPointervPName: + { + switch (value) + { + case 0xDF0: + return "GL_FEEDBACK_BUFFER_POINTER"; + case 0xDF3: + return "GL_SELECTION_BUFFER_POINTER"; + case 0x808E: + return "GL_VERTEX_ARRAY_POINTER"; + case 0x808F: + return "GL_NORMAL_ARRAY_POINTER"; + case 0x8090: + return "GL_COLOR_ARRAY_POINTER"; + case 0x8091: + return "GL_INDEX_ARRAY_POINTER"; + case 0x8092: + return "GL_TEXTURE_COORD_ARRAY_POINTER"; + case 0x8093: + return "GL_EDGE_FLAG_ARRAY_POINTER"; + case 0x8244: + return "GL_DEBUG_CALLBACK_FUNCTION"; + case 0x8245: + return "GL_DEBUG_CALLBACK_USER_PARAM"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GetTextureParameter: + { + switch (value) + { + case 0x1000: + return "GL_TEXTURE_WIDTH"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_COMPONENTS"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x1005: + return "GL_TEXTURE_BORDER"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8060: + return "GL_TEXTURE_LUMINANCE_SIZE"; + case 0x8061: + return "GL_TEXTURE_INTENSITY_SIZE"; + case 0x8066: + return "GL_TEXTURE_PRIORITY"; + case 0x8067: + return "GL_TEXTURE_RESIDENT"; + case 0x8511: + return "GL_NORMAL_MAP"; + case 0x8512: + return "GL_REFLECTION_MAP"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GlslTypeToken: + { + switch (value) + { + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5D: + return "GL_SAMPLER_1D"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B61: + return "GL_SAMPLER_1D_SHADOW"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B63: + return "GL_SAMPLER_2D_RECT"; + case 0x8B64: + return "GL_SAMPLER_2D_RECT_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC0: + return "GL_SAMPLER_1D_ARRAY"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC3: + return "GL_SAMPLER_1D_ARRAY_SHADOW"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DC9: + return "GL_INT_SAMPLER_1D"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCD: + return "GL_INT_SAMPLER_2D_RECT"; + case 0x8DCE: + return "GL_INT_SAMPLER_1D_ARRAY"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD1: + return "GL_UNSIGNED_INT_SAMPLER_1D"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD5: + return "GL_UNSIGNED_INT_SAMPLER_2D_RECT"; + case 0x8DD6: + return "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x8F46: + return "GL_DOUBLE_MAT2"; + case 0x8F47: + return "GL_DOUBLE_MAT3"; + case 0x8F48: + return "GL_DOUBLE_MAT4"; + case 0x8FFC: + return "GL_DOUBLE_VEC2"; + case 0x8FFD: + return "GL_DOUBLE_VEC3"; + case 0x8FFE: + return "GL_DOUBLE_VEC4"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x904C: + return "GL_IMAGE_1D"; + case 0x904D: + return "GL_IMAGE_2D"; + case 0x904E: + return "GL_IMAGE_3D"; + case 0x904F: + return "GL_IMAGE_2D_RECT"; + case 0x9050: + return "GL_IMAGE_CUBE"; + case 0x9051: + return "GL_IMAGE_BUFFER"; + case 0x9052: + return "GL_IMAGE_1D_ARRAY"; + case 0x9053: + return "GL_IMAGE_2D_ARRAY"; + case 0x9054: + return "GL_IMAGE_CUBE_MAP_ARRAY"; + case 0x9055: + return "GL_IMAGE_2D_MULTISAMPLE"; + case 0x9056: + return "GL_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9057: + return "GL_INT_IMAGE_1D"; + case 0x9058: + return "GL_INT_IMAGE_2D"; + case 0x9059: + return "GL_INT_IMAGE_3D"; + case 0x905A: + return "GL_INT_IMAGE_2D_RECT"; + case 0x905B: + return "GL_INT_IMAGE_CUBE"; + case 0x905C: + return "GL_INT_IMAGE_BUFFER"; + case 0x905D: + return "GL_INT_IMAGE_1D_ARRAY"; + case 0x905E: + return "GL_INT_IMAGE_2D_ARRAY"; + case 0x905F: + return "GL_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x9060: + return "GL_INT_IMAGE_2D_MULTISAMPLE"; + case 0x9061: + return "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9062: + return "GL_UNSIGNED_INT_IMAGE_1D"; + case 0x9063: + return "GL_UNSIGNED_INT_IMAGE_2D"; + case 0x9064: + return "GL_UNSIGNED_INT_IMAGE_3D"; + case 0x9065: + return "GL_UNSIGNED_INT_IMAGE_2D_RECT"; + case 0x9066: + return "GL_UNSIGNED_INT_IMAGE_CUBE"; + case 0x9067: + return "GL_UNSIGNED_INT_IMAGE_BUFFER"; + case 0x9068: + return "GL_UNSIGNED_INT_IMAGE_1D_ARRAY"; + case 0x9069: + return "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"; + case 0x906A: + return "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"; + case 0x906B: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE"; + case 0x906C: + return "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x92DB: + return "GL_UNSIGNED_INT_ATOMIC_COUNTER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::GraphicsResetStatus: + { + switch (value) + { + case 0x0: + return "GL_NO_ERROR"; + case 0x8253: + return "GL_GUILTY_CONTEXT_RESET"; + case 0x8254: + return "GL_INNOCENT_CONTEXT_RESET"; + case 0x8255: + return "GL_UNKNOWN_CONTEXT_RESET"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::HintMode: + { + switch (value) + { + case 0x1100: + return "GL_DONT_CARE"; + case 0x1101: + return "GL_FASTEST"; + case 0x1102: + return "GL_NICEST"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::HintTarget: + { + switch (value) + { + case 0xC50: + return "GL_PERSPECTIVE_CORRECTION_HINT"; + case 0xC51: + return "GL_POINT_SMOOTH_HINT"; + case 0xC52: + return "GL_LINE_SMOOTH_HINT"; + case 0xC53: + return "GL_POLYGON_SMOOTH_HINT"; + case 0xC54: + return "GL_FOG_HINT"; + case 0x8192: + return "GL_GENERATE_MIPMAP_HINT"; + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; + case 0x84EF: + return "GL_TEXTURE_COMPRESSION_HINT"; + case 0x8B8B: + return "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::HistogramTarget: + { + switch (value) + { + case 0x8024: + return "GL_HISTOGRAM"; + case 0x8025: + return "GL_PROXY_HISTOGRAM"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::HistogramTargetEXT: + { + switch (value) + { + case 0x8024: + return "GL_HISTOGRAM"; + case 0x8025: + return "GL_PROXY_HISTOGRAM"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::IndexFunctionEXT: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::IndexMaterialParameterEXT: + { + switch (value) + { + case 0xD13: + return "GL_INDEX_OFFSET"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::IndexPointerType: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::InterleavedArrayFormat: + { + switch (value) + { + case 0x2A20: + return "GL_V2F"; + case 0x2A21: + return "GL_V3F"; + case 0x2A22: + return "GL_C4UB_V2F"; + case 0x2A23: + return "GL_C4UB_V3F"; + case 0x2A24: + return "GL_C3F_V3F"; + case 0x2A25: + return "GL_N3F_V3F"; + case 0x2A26: + return "GL_C4F_N3F_V3F"; + case 0x2A27: + return "GL_T2F_V3F"; + case 0x2A28: + return "GL_T4F_V4F"; + case 0x2A29: + return "GL_T2F_C4UB_V3F"; + case 0x2A2A: + return "GL_T2F_C3F_V3F"; + case 0x2A2B: + return "GL_T2F_N3F_V3F"; + case 0x2A2C: + return "GL_T2F_C4F_N3F_V3F"; + case 0x2A2D: + return "GL_T4F_C4F_N3F_V4F"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::InternalFormat: + { + switch (value) + { + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x2A10: + return "GL_R3_G3_B2"; + case 0x803B: + return "GL_ALPHA4"; + case 0x803C: + return "GL_ALPHA8"; + case 0x803D: + return "GL_ALPHA12"; + case 0x803E: + return "GL_ALPHA16"; + case 0x803F: + return "GL_LUMINANCE4"; + case 0x8040: + return "GL_LUMINANCE8"; + case 0x8041: + return "GL_LUMINANCE12"; + case 0x8042: + return "GL_LUMINANCE16"; + case 0x8043: + return "GL_LUMINANCE4_ALPHA4"; + case 0x8044: + return "GL_LUMINANCE6_ALPHA2"; + case 0x8045: + return "GL_LUMINANCE8_ALPHA8"; + case 0x8046: + return "GL_LUMINANCE12_ALPHA4"; + case 0x8047: + return "GL_LUMINANCE12_ALPHA12"; + case 0x8048: + return "GL_LUMINANCE16_ALPHA16"; + case 0x8049: + return "GL_INTENSITY"; + case 0x804A: + return "GL_INTENSITY4"; + case 0x804B: + return "GL_INTENSITY8"; + case 0x804C: + return "GL_INTENSITY12"; + case 0x804D: + return "GL_INTENSITY16"; + case 0x804F: + return "GL_RGB4"; + case 0x8050: + return "GL_RGB5"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10"; + case 0x8053: + return "GL_RGB12"; + case 0x8054: + return "GL_RGB16"; + case 0x8055: + return "GL_RGBA2"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805A: + return "GL_RGBA12"; + case 0x805B: + return "GL_RGBA16"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; + case 0x81A6: + return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32"; + case 0x8225: + return "GL_COMPRESSED_RED"; + case 0x8226: + return "GL_COMPRESSED_RG"; + case 0x8227: + return "GL_RG"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; + case 0x84ED: + return "GL_COMPRESSED_RGB"; + case 0x84EE: + return "GL_COMPRESSED_RGBA"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; + case 0x8814: + return "GL_RGBA32F"; + case 0x8815: + return "GL_RGB32F"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3D: + return "GL_RGB9_E5"; + case 0x8C40: + return "GL_SRGB"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C42: + return "GL_SRGB_ALPHA"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8C48: + return "GL_COMPRESSED_SRGB"; + case 0x8C49: + return "GL_COMPRESSED_SRGB_ALPHA"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; + case 0x8D46: + return "GL_STENCIL_INDEX1"; + case 0x8D47: + return "GL_STENCIL_INDEX4"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D49: + return "GL_STENCIL_INDEX16"; + case 0x8D62: + return "GL_RGB565"; + case 0x8D70: + return "GL_RGBA32UI"; + case 0x8D71: + return "GL_RGB32UI"; + case 0x8D76: + return "GL_RGBA16UI"; + case 0x8D77: + return "GL_RGB16UI"; + case 0x8D7C: + return "GL_RGBA8UI"; + case 0x8D7D: + return "GL_RGB8UI"; + case 0x8D82: + return "GL_RGBA32I"; + case 0x8D83: + return "GL_RGB32I"; + case 0x8D88: + return "GL_RGBA16I"; + case 0x8D89: + return "GL_RGB16I"; + case 0x8D8E: + return "GL_RGBA8I"; + case 0x8D8F: + return "GL_RGB8I"; + case 0x8DBB: + return "GL_COMPRESSED_RED_RGTC1"; + case 0x8DBC: + return "GL_COMPRESSED_SIGNED_RED_RGTC1"; + case 0x8DBD: + return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; + case 0x8DBE: + return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8E8C: + return "GL_COMPRESSED_RGBA_BPTC_UNORM"; + case 0x8E8D: + return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM"; + case 0x8E8E: + return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT"; + case 0x8E8F: + return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT"; + case 0x8F94: + return "GL_R8_SNORM"; + case 0x8F95: + return "GL_RG8_SNORM"; + case 0x8F96: + return "GL_RGB8_SNORM"; + case 0x8F97: + return "GL_RGBA8_SNORM"; + case 0x8F98: + return "GL_R16_SNORM"; + case 0x8F99: + return "GL_RG16_SNORM"; + case 0x8F9A: + return "GL_RGB16_SNORM"; + case 0x8F9B: + return "GL_RGBA16_SNORM"; + case 0x8FBD: + return "GL_SR8_EXT"; + case 0x8FBE: + return "GL_SRG8_EXT"; + case 0x906F: + return "GL_RGB10_A2UI"; + case 0x9270: + return "GL_COMPRESSED_R11_EAC"; + case 0x9271: + return "GL_COMPRESSED_SIGNED_R11_EAC"; + case 0x9272: + return "GL_COMPRESSED_RG11_EAC"; + case 0x9273: + return "GL_COMPRESSED_SIGNED_RG11_EAC"; + case 0x9274: + return "GL_COMPRESSED_RGB8_ETC2"; + case 0x9275: + return "GL_COMPRESSED_SRGB8_ETC2"; + case 0x9276: + return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9277: + return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9278: + return "GL_COMPRESSED_RGBA8_ETC2_EAC"; + case 0x9279: + return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x93B0: + return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; + case 0x93B1: + return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; + case 0x93B2: + return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; + case 0x93B3: + return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; + case 0x93B4: + return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; + case 0x93B5: + return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; + case 0x93B6: + return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; + case 0x93B7: + return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; + case 0x93B8: + return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; + case 0x93B9: + return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; + case 0x93BA: + return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; + case 0x93BB: + return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; + case 0x93BC: + return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; + case 0x93BD: + return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; + case 0x93D0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; + case 0x93D1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; + case 0x93D2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; + case 0x93D3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; + case 0x93D4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; + case 0x93D5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; + case 0x93D6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; + case 0x93D7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; + case 0x93D8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; + case 0x93D9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; + case 0x93DA: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; + case 0x93DB: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; + case 0x93DC: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; + case 0x93DD: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::InternalFormatPName: + { + switch (value) + { + case 0x80A9: + return "GL_SAMPLES"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x826F: + return "GL_INTERNALFORMAT_SUPPORTED"; + case 0x8270: + return "GL_INTERNALFORMAT_PREFERRED"; + case 0x8271: + return "GL_INTERNALFORMAT_RED_SIZE"; + case 0x8272: + return "GL_INTERNALFORMAT_GREEN_SIZE"; + case 0x8273: + return "GL_INTERNALFORMAT_BLUE_SIZE"; + case 0x8274: + return "GL_INTERNALFORMAT_ALPHA_SIZE"; + case 0x8275: + return "GL_INTERNALFORMAT_DEPTH_SIZE"; + case 0x8276: + return "GL_INTERNALFORMAT_STENCIL_SIZE"; + case 0x8277: + return "GL_INTERNALFORMAT_SHARED_SIZE"; + case 0x8278: + return "GL_INTERNALFORMAT_RED_TYPE"; + case 0x8279: + return "GL_INTERNALFORMAT_GREEN_TYPE"; + case 0x827A: + return "GL_INTERNALFORMAT_BLUE_TYPE"; + case 0x827B: + return "GL_INTERNALFORMAT_ALPHA_TYPE"; + case 0x827C: + return "GL_INTERNALFORMAT_DEPTH_TYPE"; + case 0x827D: + return "GL_INTERNALFORMAT_STENCIL_TYPE"; + case 0x827E: + return "GL_MAX_WIDTH"; + case 0x827F: + return "GL_MAX_HEIGHT"; + case 0x8280: + return "GL_MAX_DEPTH"; + case 0x8281: + return "GL_MAX_LAYERS"; + case 0x8283: + return "GL_COLOR_COMPONENTS"; + case 0x8286: + return "GL_COLOR_RENDERABLE"; + case 0x8287: + return "GL_DEPTH_RENDERABLE"; + case 0x8288: + return "GL_STENCIL_RENDERABLE"; + case 0x8289: + return "GL_FRAMEBUFFER_RENDERABLE"; + case 0x828A: + return "GL_FRAMEBUFFER_RENDERABLE_LAYERED"; + case 0x828B: + return "GL_FRAMEBUFFER_BLEND"; + case 0x828C: + return "GL_READ_PIXELS"; + case 0x828D: + return "GL_READ_PIXELS_FORMAT"; + case 0x828E: + return "GL_READ_PIXELS_TYPE"; + case 0x828F: + return "GL_TEXTURE_IMAGE_FORMAT"; + case 0x8290: + return "GL_TEXTURE_IMAGE_TYPE"; + case 0x8291: + return "GL_GET_TEXTURE_IMAGE_FORMAT"; + case 0x8292: + return "GL_GET_TEXTURE_IMAGE_TYPE"; + case 0x8293: + return "GL_MIPMAP"; + case 0x8295: + return "GL_AUTO_GENERATE_MIPMAP"; + case 0x8296: + return "GL_COLOR_ENCODING"; + case 0x8297: + return "GL_SRGB_READ"; + case 0x8298: + return "GL_SRGB_WRITE"; + case 0x829A: + return "GL_FILTER"; + case 0x829B: + return "GL_VERTEX_TEXTURE"; + case 0x829C: + return "GL_TESS_CONTROL_TEXTURE"; + case 0x829D: + return "GL_TESS_EVALUATION_TEXTURE"; + case 0x829E: + return "GL_GEOMETRY_TEXTURE"; + case 0x829F: + return "GL_FRAGMENT_TEXTURE"; + case 0x82A0: + return "GL_COMPUTE_TEXTURE"; + case 0x82A1: + return "GL_TEXTURE_SHADOW"; + case 0x82A2: + return "GL_TEXTURE_GATHER"; + case 0x82A3: + return "GL_TEXTURE_GATHER_SHADOW"; + case 0x82A4: + return "GL_SHADER_IMAGE_LOAD"; + case 0x82A5: + return "GL_SHADER_IMAGE_STORE"; + case 0x82A6: + return "GL_SHADER_IMAGE_ATOMIC"; + case 0x82A7: + return "GL_IMAGE_TEXEL_SIZE"; + case 0x82A8: + return "GL_IMAGE_COMPATIBILITY_CLASS"; + case 0x82A9: + return "GL_IMAGE_PIXEL_FORMAT"; + case 0x82AA: + return "GL_IMAGE_PIXEL_TYPE"; + case 0x82AC: + return "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST"; + case 0x82AD: + return "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST"; + case 0x82AE: + return "GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE"; + case 0x82AF: + return "GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE"; + case 0x82B1: + return "GL_TEXTURE_COMPRESSED_BLOCK_WIDTH"; + case 0x82B2: + return "GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT"; + case 0x82B3: + return "GL_TEXTURE_COMPRESSED_BLOCK_SIZE"; + case 0x82B4: + return "GL_CLEAR_BUFFER"; + case 0x82B5: + return "GL_TEXTURE_VIEW"; + case 0x82B6: + return "GL_VIEW_COMPATIBILITY_CLASS"; + case 0x86A1: + return "GL_TEXTURE_COMPRESSED"; + case 0x90C7: + return "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"; + case 0x9365: + return "GL_CLEAR_TEXTURE"; + case 0x9380: + return "GL_NUM_SAMPLE_COUNTS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::InvalidateFramebufferAttachment: + { + switch (value) + { + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + case 0x821A: + return "GL_DEPTH_STENCIL_ATTACHMENT"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + case 0x8CF0: + return "GL_COLOR_ATTACHMENT16"; + case 0x8CF1: + return "GL_COLOR_ATTACHMENT17"; + case 0x8CF2: + return "GL_COLOR_ATTACHMENT18"; + case 0x8CF3: + return "GL_COLOR_ATTACHMENT19"; + case 0x8CF4: + return "GL_COLOR_ATTACHMENT20"; + case 0x8CF5: + return "GL_COLOR_ATTACHMENT21"; + case 0x8CF6: + return "GL_COLOR_ATTACHMENT22"; + case 0x8CF7: + return "GL_COLOR_ATTACHMENT23"; + case 0x8CF8: + return "GL_COLOR_ATTACHMENT24"; + case 0x8CF9: + return "GL_COLOR_ATTACHMENT25"; + case 0x8CFA: + return "GL_COLOR_ATTACHMENT26"; + case 0x8CFB: + return "GL_COLOR_ATTACHMENT27"; + case 0x8CFC: + return "GL_COLOR_ATTACHMENT28"; + case 0x8CFD: + return "GL_COLOR_ATTACHMENT29"; + case 0x8CFE: + return "GL_COLOR_ATTACHMENT30"; + case 0x8CFF: + return "GL_COLOR_ATTACHMENT31"; + case 0x8D00: + return "GL_DEPTH_ATTACHMENT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightEnvModeSGIX: + { + switch (value) + { + case 0x104: + return "GL_ADD"; + case 0x1E01: + return "GL_REPLACE"; + case 0x2100: + return "GL_MODULATE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightModelColorControl: + { + switch (value) + { + case 0x81F9: + return "GL_SINGLE_COLOR"; + case 0x81FA: + return "GL_SEPARATE_SPECULAR_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightModelParameter: + { + switch (value) + { + case 0xB51: + return "GL_LIGHT_MODEL_LOCAL_VIEWER"; + case 0xB52: + return "GL_LIGHT_MODEL_TWO_SIDE"; + case 0xB53: + return "GL_LIGHT_MODEL_AMBIENT"; + case 0x81F8: + return "GL_LIGHT_MODEL_COLOR_CONTROL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightName: + { + switch (value) + { + case 0x4000: + return "GL_LIGHT0"; + case 0x4001: + return "GL_LIGHT1"; + case 0x4002: + return "GL_LIGHT2"; + case 0x4003: + return "GL_LIGHT3"; + case 0x4004: + return "GL_LIGHT4"; + case 0x4005: + return "GL_LIGHT5"; + case 0x4006: + return "GL_LIGHT6"; + case 0x4007: + return "GL_LIGHT7"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightParameter: + { + switch (value) + { + case 0x1203: + return "GL_POSITION"; + case 0x1204: + return "GL_SPOT_DIRECTION"; + case 0x1205: + return "GL_SPOT_EXPONENT"; + case 0x1206: + return "GL_SPOT_CUTOFF"; + case 0x1207: + return "GL_CONSTANT_ATTENUATION"; + case 0x1208: + return "GL_LINEAR_ATTENUATION"; + case 0x1209: + return "GL_QUADRATIC_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LightTextureModeEXT: + { + switch (value) + { + case 0x8452: + return "GL_FRAGMENT_DEPTH"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ListMode: + { + switch (value) + { + case 0x1300: + return "GL_COMPILE"; + case 0x1301: + return "GL_COMPILE_AND_EXECUTE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ListNameType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x1407: + return "GL_2_BYTES"; + case 0x1408: + return "GL_3_BYTES"; + case 0x1409: + return "GL_4_BYTES"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::LogicOp: + { + switch (value) + { + case 0x1500: + return "GL_CLEAR"; + case 0x1501: + return "GL_AND"; + case 0x1502: + return "GL_AND_REVERSE"; + case 0x1503: + return "GL_COPY"; + case 0x1504: + return "GL_AND_INVERTED"; + case 0x1505: + return "GL_NOOP"; + case 0x1506: + return "GL_XOR"; + case 0x1507: + return "GL_OR"; + case 0x1508: + return "GL_NOR"; + case 0x1509: + return "GL_EQUIV"; + case 0x150A: + return "GL_INVERT"; + case 0x150B: + return "GL_OR_REVERSE"; + case 0x150C: + return "GL_COPY_INVERTED"; + case 0x150D: + return "GL_OR_INVERTED"; + case 0x150E: + return "GL_NAND"; + case 0x150F: + return "GL_SET"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MapBufferAccessMask: + { + switch (value) + { + case 0x1: + return "GL_MAP_READ_BIT"; + case 0x2: + return "GL_MAP_WRITE_BIT"; + case 0x4: + return "GL_MAP_INVALIDATE_RANGE_BIT"; + case 0x8: + return "GL_MAP_INVALIDATE_BUFFER_BIT"; + case 0x10: + return "GL_MAP_FLUSH_EXPLICIT_BIT"; + case 0x20: + return "GL_MAP_UNSYNCHRONIZED_BIT"; + case 0x40: + return "GL_MAP_PERSISTENT_BIT"; + case 0x80: + return "GL_MAP_COHERENT_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MapQuery: + { + switch (value) + { + case 0xA00: + return "GL_COEFF"; + case 0xA01: + return "GL_ORDER"; + case 0xA02: + return "GL_DOMAIN"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MapTarget: + { + switch (value) + { + case 0xD90: + return "GL_MAP1_COLOR_4"; + case 0xD91: + return "GL_MAP1_INDEX"; + case 0xD92: + return "GL_MAP1_NORMAL"; + case 0xD93: + return "GL_MAP1_TEXTURE_COORD_1"; + case 0xD94: + return "GL_MAP1_TEXTURE_COORD_2"; + case 0xD95: + return "GL_MAP1_TEXTURE_COORD_3"; + case 0xD96: + return "GL_MAP1_TEXTURE_COORD_4"; + case 0xD97: + return "GL_MAP1_VERTEX_3"; + case 0xD98: + return "GL_MAP1_VERTEX_4"; + case 0xDB0: + return "GL_MAP2_COLOR_4"; + case 0xDB1: + return "GL_MAP2_INDEX"; + case 0xDB2: + return "GL_MAP2_NORMAL"; + case 0xDB3: + return "GL_MAP2_TEXTURE_COORD_1"; + case 0xDB4: + return "GL_MAP2_TEXTURE_COORD_2"; + case 0xDB5: + return "GL_MAP2_TEXTURE_COORD_3"; + case 0xDB6: + return "GL_MAP2_TEXTURE_COORD_4"; + case 0xDB7: + return "GL_MAP2_VERTEX_3"; + case 0xDB8: + return "GL_MAP2_VERTEX_4"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MapTypeNV: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MaterialFace: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MaterialParameter: + { + switch (value) + { + case 0x1200: + return "GL_AMBIENT"; + case 0x1201: + return "GL_DIFFUSE"; + case 0x1202: + return "GL_SPECULAR"; + case 0x1600: + return "GL_EMISSION"; + case 0x1601: + return "GL_SHININESS"; + case 0x1602: + return "GL_AMBIENT_AND_DIFFUSE"; + case 0x1603: + return "GL_COLOR_INDEXES"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MatrixIndexPointerTypeARB: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MatrixMode: + { + switch (value) + { + case 0x1700: + return "GL_MODELVIEW"; + case 0x1701: + return "GL_PROJECTION"; + case 0x1702: + return "GL_TEXTURE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MemoryBarrierMask: + { + switch (value) + { + case 0x1: + return "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT"; + case 0x2: + return "GL_ELEMENT_ARRAY_BARRIER_BIT"; + case 0x4: + return "GL_UNIFORM_BARRIER_BIT"; + case 0x8: + return "GL_TEXTURE_FETCH_BARRIER_BIT"; + case 0x20: + return "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT"; + case 0x40: + return "GL_COMMAND_BARRIER_BIT"; + case 0x80: + return "GL_PIXEL_BUFFER_BARRIER_BIT"; + case 0x100: + return "GL_TEXTURE_UPDATE_BARRIER_BIT"; + case 0x200: + return "GL_BUFFER_UPDATE_BARRIER_BIT"; + case 0x400: + return "GL_FRAMEBUFFER_BARRIER_BIT"; + case 0x800: + return "GL_TRANSFORM_FEEDBACK_BARRIER_BIT"; + case 0x1000: + return "GL_ATOMIC_COUNTER_BARRIER_BIT"; + case 0x2000: + return "GL_SHADER_STORAGE_BARRIER_BIT"; + case 0x4000: + return "GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT"; + case 0x8000: + return "GL_QUERY_BUFFER_BARRIER_BIT"; + case 0xFFFFFFFF: + return "GL_ALL_BARRIER_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MemoryObjectParameterName: + { + switch (value) + { + case 0x9581: + return "GL_DEDICATED_MEMORY_OBJECT_EXT"; + case 0x959B: + return "GL_PROTECTED_MEMORY_OBJECT_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MeshMode1: + { + switch (value) + { + case 0x1B00: + return "GL_POINT"; + case 0x1B01: + return "GL_LINE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MeshMode2: + { + switch (value) + { + case 0x1B00: + return "GL_POINT"; + case 0x1B01: + return "GL_LINE"; + case 0x1B02: + return "GL_FILL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MinmaxTarget: + { + switch (value) + { + case 0x802E: + return "GL_MINMAX"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::MinmaxTargetEXT: + { + switch (value) + { + case 0x802E: + return "GL_MINMAX"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::NormalPointerType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ObjectIdentifier: + { + switch (value) + { + case 0x1702: + return "GL_TEXTURE"; + case 0x8074: + return "GL_VERTEX_ARRAY"; + case 0x82E0: + return "GL_BUFFER"; + case 0x82E1: + return "GL_SHADER"; + case 0x82E2: + return "GL_PROGRAM"; + case 0x82E3: + return "GL_QUERY"; + case 0x82E4: + return "GL_PROGRAM_PIPELINE"; + case 0x82E6: + return "GL_SAMPLER"; + case 0x8D40: + return "GL_FRAMEBUFFER"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x8E22: + return "GL_TRANSFORM_FEEDBACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PatchParameterName: + { + switch (value) + { + case 0x8E72: + return "GL_PATCH_VERTICES"; + case 0x8E73: + return "GL_PATCH_DEFAULT_INNER_LEVEL"; + case 0x8E74: + return "GL_PATCH_DEFAULT_OUTER_LEVEL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathColor: + { + switch (value) + { + case 0x8577: + return "GL_PRIMARY_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathColorFormat: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + case 0x8049: + return "GL_INTENSITY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathFillMode: + { + switch (value) + { + case 0x150A: + return "GL_INVERT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathFontStyle: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathGenMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x2400: + return "GL_EYE_LINEAR"; + case 0x2401: + return "GL_OBJECT_LINEAR"; + case 0x8576: + return "GL_CONSTANT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PathTransformType: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PipelineParameterName: + { + switch (value) + { + case 0x8259: + return "GL_ACTIVE_PROGRAM"; + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelCopyType: + { + switch (value) + { + case 0x1800: + return "GL_COLOR"; + case 0x1801: + return "GL_DEPTH"; + case 0x1802: + return "GL_STENCIL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelFormat: + { + switch (value) + { + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1900: + return "GL_COLOR_INDEX"; + case 0x1901: + return "GL_STENCIL_INDEX"; + case 0x1902: + return "GL_DEPTH_COMPONENT"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + case 0x80E0: + return "GL_BGR"; + case 0x80E1: + return "GL_BGRA"; + case 0x8227: + return "GL_RG"; + case 0x8228: + return "GL_RG_INTEGER"; + case 0x84F9: + return "GL_DEPTH_STENCIL"; + case 0x8D94: + return "GL_RED_INTEGER"; + case 0x8D95: + return "GL_GREEN_INTEGER"; + case 0x8D96: + return "GL_BLUE_INTEGER"; + case 0x8D98: + return "GL_RGB_INTEGER"; + case 0x8D99: + return "GL_RGBA_INTEGER"; + case 0x8D9A: + return "GL_BGR_INTEGER"; + case 0x8D9B: + return "GL_BGRA_INTEGER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelMap: + { + switch (value) + { + case 0xC70: + return "GL_PIXEL_MAP_I_TO_I"; + case 0xC71: + return "GL_PIXEL_MAP_S_TO_S"; + case 0xC72: + return "GL_PIXEL_MAP_I_TO_R"; + case 0xC73: + return "GL_PIXEL_MAP_I_TO_G"; + case 0xC74: + return "GL_PIXEL_MAP_I_TO_B"; + case 0xC75: + return "GL_PIXEL_MAP_I_TO_A"; + case 0xC76: + return "GL_PIXEL_MAP_R_TO_R"; + case 0xC77: + return "GL_PIXEL_MAP_G_TO_G"; + case 0xC78: + return "GL_PIXEL_MAP_B_TO_B"; + case 0xC79: + return "GL_PIXEL_MAP_A_TO_A"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelStoreParameter: + { + switch (value) + { + case 0xCF0: + return "GL_UNPACK_SWAP_BYTES"; + case 0xCF1: + return "GL_UNPACK_LSB_FIRST"; + case 0xCF2: + return "GL_UNPACK_ROW_LENGTH"; + case 0xCF3: + return "GL_UNPACK_SKIP_ROWS"; + case 0xCF4: + return "GL_UNPACK_SKIP_PIXELS"; + case 0xCF5: + return "GL_UNPACK_ALIGNMENT"; + case 0xD00: + return "GL_PACK_SWAP_BYTES"; + case 0xD01: + return "GL_PACK_LSB_FIRST"; + case 0xD02: + return "GL_PACK_ROW_LENGTH"; + case 0xD03: + return "GL_PACK_SKIP_ROWS"; + case 0xD04: + return "GL_PACK_SKIP_PIXELS"; + case 0xD05: + return "GL_PACK_ALIGNMENT"; + case 0x806B: + return "GL_PACK_SKIP_IMAGES"; + case 0x806C: + return "GL_PACK_IMAGE_HEIGHT"; + case 0x806D: + return "GL_UNPACK_SKIP_IMAGES"; + case 0x806E: + return "GL_UNPACK_IMAGE_HEIGHT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelTexGenMode: + { + switch (value) + { + case 0x1907: + return "GL_RGB"; + case 0x1908: + return "GL_RGBA"; + case 0x1909: + return "GL_LUMINANCE"; + case 0x190A: + return "GL_LUMINANCE_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelTexGenModeSGIX: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelTransferParameter: + { + switch (value) + { + case 0xD10: + return "GL_MAP_COLOR"; + case 0xD11: + return "GL_MAP_STENCIL"; + case 0xD12: + return "GL_INDEX_SHIFT"; + case 0xD13: + return "GL_INDEX_OFFSET"; + case 0xD14: + return "GL_RED_SCALE"; + case 0xD15: + return "GL_RED_BIAS"; + case 0xD18: + return "GL_GREEN_SCALE"; + case 0xD19: + return "GL_GREEN_BIAS"; + case 0xD1A: + return "GL_BLUE_SCALE"; + case 0xD1B: + return "GL_BLUE_BIAS"; + case 0xD1C: + return "GL_ALPHA_SCALE"; + case 0xD1D: + return "GL_ALPHA_BIAS"; + case 0xD1E: + return "GL_DEPTH_SCALE"; + case 0xD1F: + return "GL_DEPTH_BIAS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PixelType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x1A00: + return "GL_BITMAP"; + case 0x8032: + return "GL_UNSIGNED_BYTE_3_3_2"; + case 0x8033: + return "GL_UNSIGNED_SHORT_4_4_4_4"; + case 0x8034: + return "GL_UNSIGNED_SHORT_5_5_5_1"; + case 0x8035: + return "GL_UNSIGNED_INT_8_8_8_8"; + case 0x8036: + return "GL_UNSIGNED_INT_10_10_10_2"; + case 0x8362: + return "GL_UNSIGNED_BYTE_2_3_3_REV"; + case 0x8363: + return "GL_UNSIGNED_SHORT_5_6_5"; + case 0x8364: + return "GL_UNSIGNED_SHORT_5_6_5_REV"; + case 0x8365: + return "GL_UNSIGNED_SHORT_4_4_4_4_REV"; + case 0x8366: + return "GL_UNSIGNED_SHORT_1_5_5_5_REV"; + case 0x8367: + return "GL_UNSIGNED_INT_8_8_8_8_REV"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PointParameterNameARB: + { + switch (value) + { + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PointParameterNameSGIS: + { + switch (value) + { + case 0x8126: + return "GL_POINT_SIZE_MIN"; + case 0x8127: + return "GL_POINT_SIZE_MAX"; + case 0x8128: + return "GL_POINT_FADE_THRESHOLD_SIZE"; + case 0x8129: + return "GL_POINT_DISTANCE_ATTENUATION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PolygonMode: + { + switch (value) + { + case 0x1B00: + return "GL_POINT"; + case 0x1B01: + return "GL_LINE"; + case 0x1B02: + return "GL_FILL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PrecisionType: + { + switch (value) + { + case 0x8DF0: + return "GL_LOW_FLOAT"; + case 0x8DF1: + return "GL_MEDIUM_FLOAT"; + case 0x8DF2: + return "GL_HIGH_FLOAT"; + case 0x8DF3: + return "GL_LOW_INT"; + case 0x8DF4: + return "GL_MEDIUM_INT"; + case 0x8DF5: + return "GL_HIGH_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::PrimitiveType: + { + switch (value) + { + case 0x0: + return "GL_POINTS"; + case 0x1: + return "GL_LINES"; + case 0x2: + return "GL_LINE_LOOP"; + case 0x3: + return "GL_LINE_STRIP"; + case 0x4: + return "GL_TRIANGLES"; + case 0x5: + return "GL_TRIANGLE_STRIP"; + case 0x6: + return "GL_TRIANGLE_FAN"; + case 0x7: + return "GL_QUADS"; + case 0x8: + return "GL_QUAD_STRIP"; + case 0x9: + return "GL_POLYGON"; + case 0xA: + return "GL_LINES_ADJACENCY"; + case 0xB: + return "GL_LINE_STRIP_ADJACENCY"; + case 0xC: + return "GL_TRIANGLES_ADJACENCY"; + case 0xD: + return "GL_TRIANGLE_STRIP_ADJACENCY"; + case 0xE: + return "GL_PATCHES"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramInterface: + { + switch (value) + { + case 0x8C8E: + return "GL_TRANSFORM_FEEDBACK_BUFFER"; + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E2: + return "GL_UNIFORM_BLOCK"; + case 0x92E3: + return "GL_PROGRAM_INPUT"; + case 0x92E4: + return "GL_PROGRAM_OUTPUT"; + case 0x92E5: + return "GL_BUFFER_VARIABLE"; + case 0x92E6: + return "GL_SHADER_STORAGE_BLOCK"; + case 0x92E8: + return "GL_VERTEX_SUBROUTINE"; + case 0x92E9: + return "GL_TESS_CONTROL_SUBROUTINE"; + case 0x92EA: + return "GL_TESS_EVALUATION_SUBROUTINE"; + case 0x92EB: + return "GL_GEOMETRY_SUBROUTINE"; + case 0x92EC: + return "GL_FRAGMENT_SUBROUTINE"; + case 0x92ED: + return "GL_COMPUTE_SUBROUTINE"; + case 0x92EE: + return "GL_VERTEX_SUBROUTINE_UNIFORM"; + case 0x92EF: + return "GL_TESS_CONTROL_SUBROUTINE_UNIFORM"; + case 0x92F0: + return "GL_TESS_EVALUATION_SUBROUTINE_UNIFORM"; + case 0x92F1: + return "GL_GEOMETRY_SUBROUTINE_UNIFORM"; + case 0x92F2: + return "GL_FRAGMENT_SUBROUTINE_UNIFORM"; + case 0x92F3: + return "GL_COMPUTE_SUBROUTINE_UNIFORM"; + case 0x92F4: + return "GL_TRANSFORM_FEEDBACK_VARYING"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramInterfacePName: + { + switch (value) + { + case 0x92F5: + return "GL_ACTIVE_RESOURCES"; + case 0x92F6: + return "GL_MAX_NAME_LENGTH"; + case 0x92F7: + return "GL_MAX_NUM_ACTIVE_VARIABLES"; + case 0x92F8: + return "GL_MAX_NUM_COMPATIBLE_SUBROUTINES"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramParameterPName: + { + switch (value) + { + case 0x8257: + return "GL_PROGRAM_BINARY_RETRIEVABLE_HINT"; + case 0x8258: + return "GL_PROGRAM_SEPARABLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramPropertyARB: + { + switch (value) + { + case 0x8267: + return "GL_COMPUTE_WORK_GROUP_SIZE"; + case 0x8741: + return "GL_PROGRAM_BINARY_LENGTH"; + case 0x8916: + return "GL_GEOMETRY_VERTICES_OUT"; + case 0x8917: + return "GL_GEOMETRY_INPUT_TYPE"; + case 0x8918: + return "GL_GEOMETRY_OUTPUT_TYPE"; + case 0x8A35: + return "GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH"; + case 0x8A36: + return "GL_ACTIVE_UNIFORM_BLOCKS"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B82: + return "GL_LINK_STATUS"; + case 0x8B83: + return "GL_VALIDATE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B85: + return "GL_ATTACHED_SHADERS"; + case 0x8B86: + return "GL_ACTIVE_UNIFORMS"; + case 0x8B87: + return "GL_ACTIVE_UNIFORM_MAX_LENGTH"; + case 0x8B89: + return "GL_ACTIVE_ATTRIBUTES"; + case 0x8B8A: + return "GL_ACTIVE_ATTRIBUTE_MAX_LENGTH"; + case 0x8C76: + return "GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH"; + case 0x8C7F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_MODE"; + case 0x8C83: + return "GL_TRANSFORM_FEEDBACK_VARYINGS"; + case 0x92D9: + return "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramResourceProperty: + { + switch (value) + { + case 0x8E4A: + return "GL_NUM_COMPATIBLE_SUBROUTINES"; + case 0x8E4B: + return "GL_COMPATIBLE_SUBROUTINES"; + case 0x92E1: + return "GL_UNIFORM"; + case 0x92E7: + return "GL_IS_PER_PATCH"; + case 0x92F9: + return "GL_NAME_LENGTH"; + case 0x92FA: + return "GL_TYPE"; + case 0x92FB: + return "GL_ARRAY_SIZE"; + case 0x92FC: + return "GL_OFFSET"; + case 0x92FD: + return "GL_BLOCK_INDEX"; + case 0x92FE: + return "GL_ARRAY_STRIDE"; + case 0x92FF: + return "GL_MATRIX_STRIDE"; + case 0x9300: + return "GL_IS_ROW_MAJOR"; + case 0x9301: + return "GL_ATOMIC_COUNTER_BUFFER_INDEX"; + case 0x9302: + return "GL_BUFFER_BINDING"; + case 0x9303: + return "GL_BUFFER_DATA_SIZE"; + case 0x9304: + return "GL_NUM_ACTIVE_VARIABLES"; + case 0x9305: + return "GL_ACTIVE_VARIABLES"; + case 0x9306: + return "GL_REFERENCED_BY_VERTEX_SHADER"; + case 0x9307: + return "GL_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x9308: + return "GL_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x9309: + return "GL_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x930A: + return "GL_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x930B: + return "GL_REFERENCED_BY_COMPUTE_SHADER"; + case 0x930C: + return "GL_TOP_LEVEL_ARRAY_SIZE"; + case 0x930D: + return "GL_TOP_LEVEL_ARRAY_STRIDE"; + case 0x930E: + return "GL_LOCATION"; + case 0x930F: + return "GL_LOCATION_INDEX"; + case 0x934A: + return "GL_LOCATION_COMPONENT"; + case 0x934B: + return "GL_TRANSFORM_FEEDBACK_BUFFER_INDEX"; + case 0x934C: + return "GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ProgramStagePName: + { + switch (value) + { + case 0x8DE5: + return "GL_ACTIVE_SUBROUTINES"; + case 0x8DE6: + return "GL_ACTIVE_SUBROUTINE_UNIFORMS"; + case 0x8E47: + return "GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS"; + case 0x8E48: + return "GL_ACTIVE_SUBROUTINE_MAX_LENGTH"; + case 0x8E49: + return "GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::QueryCounterTarget: + { + switch (value) + { + case 0x8E28: + return "GL_TIMESTAMP"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::QueryObjectParameterName: + { + switch (value) + { + case 0x82EA: + return "GL_QUERY_TARGET"; + case 0x8866: + return "GL_QUERY_RESULT"; + case 0x8867: + return "GL_QUERY_RESULT_AVAILABLE"; + case 0x9194: + return "GL_QUERY_RESULT_NO_WAIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::QueryParameterName: + { + switch (value) + { + case 0x8864: + return "GL_QUERY_COUNTER_BITS"; + case 0x8865: + return "GL_CURRENT_QUERY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::QueryTarget: + { + switch (value) + { + case 0x82EC: + return "GL_TRANSFORM_FEEDBACK_OVERFLOW"; + case 0x82EE: + return "GL_VERTICES_SUBMITTED"; + case 0x82EF: + return "GL_PRIMITIVES_SUBMITTED"; + case 0x82F0: + return "GL_VERTEX_SHADER_INVOCATIONS"; + case 0x88BF: + return "GL_TIME_ELAPSED"; + case 0x8914: + return "GL_SAMPLES_PASSED"; + case 0x8C2F: + return "GL_ANY_SAMPLES_PASSED"; + case 0x8C87: + return "GL_PRIMITIVES_GENERATED"; + case 0x8C88: + return "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN"; + case 0x8D6A: + return "GL_ANY_SAMPLES_PASSED_CONSERVATIVE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ReadBufferMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x400: + return "GL_FRONT_LEFT"; + case 0x401: + return "GL_FRONT_RIGHT"; + case 0x402: + return "GL_BACK_LEFT"; + case 0x403: + return "GL_BACK_RIGHT"; + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x406: + return "GL_LEFT"; + case 0x407: + return "GL_RIGHT"; + case 0x409: + return "GL_AUX0"; + case 0x40A: + return "GL_AUX1"; + case 0x40B: + return "GL_AUX2"; + case 0x40C: + return "GL_AUX3"; + case 0x8CE0: + return "GL_COLOR_ATTACHMENT0"; + case 0x8CE1: + return "GL_COLOR_ATTACHMENT1"; + case 0x8CE2: + return "GL_COLOR_ATTACHMENT2"; + case 0x8CE3: + return "GL_COLOR_ATTACHMENT3"; + case 0x8CE4: + return "GL_COLOR_ATTACHMENT4"; + case 0x8CE5: + return "GL_COLOR_ATTACHMENT5"; + case 0x8CE6: + return "GL_COLOR_ATTACHMENT6"; + case 0x8CE7: + return "GL_COLOR_ATTACHMENT7"; + case 0x8CE8: + return "GL_COLOR_ATTACHMENT8"; + case 0x8CE9: + return "GL_COLOR_ATTACHMENT9"; + case 0x8CEA: + return "GL_COLOR_ATTACHMENT10"; + case 0x8CEB: + return "GL_COLOR_ATTACHMENT11"; + case 0x8CEC: + return "GL_COLOR_ATTACHMENT12"; + case 0x8CED: + return "GL_COLOR_ATTACHMENT13"; + case 0x8CEE: + return "GL_COLOR_ATTACHMENT14"; + case 0x8CEF: + return "GL_COLOR_ATTACHMENT15"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::RegisterCombinerPname: + { + switch (value) + { + case 0x8570: + return "GL_COMBINE"; + case 0x8571: + return "GL_COMBINE_RGB"; + case 0x8572: + return "GL_COMBINE_ALPHA"; + case 0x8573: + return "GL_RGB_SCALE"; + case 0x8574: + return "GL_ADD_SIGNED"; + case 0x8575: + return "GL_INTERPOLATE"; + case 0x8576: + return "GL_CONSTANT"; + case 0x8577: + return "GL_PRIMARY_COLOR"; + case 0x8578: + return "GL_PREVIOUS"; + case 0x8580: + return "GL_SOURCE0_RGB"; + case 0x8581: + return "GL_SOURCE1_RGB"; + case 0x8582: + return "GL_SOURCE2_RGB"; + case 0x8588: + return "GL_SOURCE0_ALPHA"; + case 0x8589: + return "GL_SOURCE1_ALPHA"; + case 0x858A: + return "GL_SOURCE2_ALPHA"; + case 0x8590: + return "GL_OPERAND0_RGB"; + case 0x8591: + return "GL_OPERAND1_RGB"; + case 0x8592: + return "GL_OPERAND2_RGB"; + case 0x8598: + return "GL_OPERAND0_ALPHA"; + case 0x8599: + return "GL_OPERAND1_ALPHA"; + case 0x859A: + return "GL_OPERAND2_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::RenderbufferParameterName: + { + switch (value) + { + case 0x8CAB: + return "GL_RENDERBUFFER_SAMPLES"; + case 0x8D42: + return "GL_RENDERBUFFER_WIDTH"; + case 0x8D43: + return "GL_RENDERBUFFER_HEIGHT"; + case 0x8D44: + return "GL_RENDERBUFFER_INTERNAL_FORMAT"; + case 0x8D50: + return "GL_RENDERBUFFER_RED_SIZE"; + case 0x8D51: + return "GL_RENDERBUFFER_GREEN_SIZE"; + case 0x8D52: + return "GL_RENDERBUFFER_BLUE_SIZE"; + case 0x8D53: + return "GL_RENDERBUFFER_ALPHA_SIZE"; + case 0x8D54: + return "GL_RENDERBUFFER_DEPTH_SIZE"; + case 0x8D55: + return "GL_RENDERBUFFER_STENCIL_SIZE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::RenderbufferTarget: + { + switch (value) + { + case 0x8D41: + return "GL_RENDERBUFFER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::RenderingMode: + { + switch (value) + { + case 0x1C00: + return "GL_RENDER"; + case 0x1C01: + return "GL_FEEDBACK"; + case 0x1C02: + return "GL_SELECT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ReplacementCodeTypeSUN: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SamplerParameterF: + { + switch (value) + { + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + case 0x84FE: + return "GL_TEXTURE_MAX_ANISOTROPY"; + case 0x8501: + return "GL_TEXTURE_LOD_BIAS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SamplerParameterI: + { + switch (value) + { + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; + case 0x884C: + return "GL_TEXTURE_COMPARE_MODE"; + case 0x884D: + return "GL_TEXTURE_COMPARE_FUNC"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ScalarType: + { + switch (value) + { + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SecondaryColorPointerTypeIBM: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SeparableTarget: + { + switch (value) + { + case 0x8012: + return "GL_SEPARABLE_2D"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SeparableTargetEXT: + { + switch (value) + { + case 0x8012: + return "GL_SEPARABLE_2D"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ShaderBinaryFormat: + { + switch (value) + { + case 0x9551: + return "GL_SHADER_BINARY_FORMAT_SPIR_V"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ShaderParameterName: + { + switch (value) + { + case 0x8B4F: + return "GL_SHADER_TYPE"; + case 0x8B80: + return "GL_DELETE_STATUS"; + case 0x8B81: + return "GL_COMPILE_STATUS"; + case 0x8B84: + return "GL_INFO_LOG_LENGTH"; + case 0x8B88: + return "GL_SHADER_SOURCE_LENGTH"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ShaderType: + { + switch (value) + { + case 0x8B30: + return "GL_FRAGMENT_SHADER"; + case 0x8B31: + return "GL_VERTEX_SHADER"; + case 0x8DD9: + return "GL_GEOMETRY_SHADER"; + case 0x8E87: + return "GL_TESS_EVALUATION_SHADER"; + case 0x8E88: + return "GL_TESS_CONTROL_SHADER"; + case 0x91B9: + return "GL_COMPUTE_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::ShadingModel: + { + switch (value) + { + case 0x1D00: + return "GL_FLAT"; + case 0x1D01: + return "GL_SMOOTH"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SizedInternalFormat: + { + switch (value) + { + case 0x2A10: + return "GL_R3_G3_B2"; + case 0x803B: + return "GL_ALPHA4"; + case 0x803C: + return "GL_ALPHA8"; + case 0x803D: + return "GL_ALPHA12"; + case 0x803E: + return "GL_ALPHA16"; + case 0x803F: + return "GL_LUMINANCE4"; + case 0x8040: + return "GL_LUMINANCE8"; + case 0x8041: + return "GL_LUMINANCE12"; + case 0x8042: + return "GL_LUMINANCE16"; + case 0x8043: + return "GL_LUMINANCE4_ALPHA4"; + case 0x8044: + return "GL_LUMINANCE6_ALPHA2"; + case 0x8045: + return "GL_LUMINANCE8_ALPHA8"; + case 0x8046: + return "GL_LUMINANCE12_ALPHA4"; + case 0x8047: + return "GL_LUMINANCE12_ALPHA12"; + case 0x8048: + return "GL_LUMINANCE16_ALPHA16"; + case 0x804A: + return "GL_INTENSITY4"; + case 0x804B: + return "GL_INTENSITY8"; + case 0x804C: + return "GL_INTENSITY12"; + case 0x804D: + return "GL_INTENSITY16"; + case 0x804F: + return "GL_RGB4"; + case 0x8050: + return "GL_RGB5"; + case 0x8051: + return "GL_RGB8"; + case 0x8052: + return "GL_RGB10"; + case 0x8053: + return "GL_RGB12"; + case 0x8054: + return "GL_RGB16"; + case 0x8055: + return "GL_RGBA2"; + case 0x8056: + return "GL_RGBA4"; + case 0x8057: + return "GL_RGB5_A1"; + case 0x8058: + return "GL_RGBA8"; + case 0x8059: + return "GL_RGB10_A2"; + case 0x805A: + return "GL_RGBA12"; + case 0x805B: + return "GL_RGBA16"; + case 0x81A5: + return "GL_DEPTH_COMPONENT16"; + case 0x81A6: + return "GL_DEPTH_COMPONENT24"; + case 0x81A7: + return "GL_DEPTH_COMPONENT32"; + case 0x8229: + return "GL_R8"; + case 0x822A: + return "GL_R16"; + case 0x822B: + return "GL_RG8"; + case 0x822C: + return "GL_RG16"; + case 0x822D: + return "GL_R16F"; + case 0x822E: + return "GL_R32F"; + case 0x822F: + return "GL_RG16F"; + case 0x8230: + return "GL_RG32F"; + case 0x8231: + return "GL_R8I"; + case 0x8232: + return "GL_R8UI"; + case 0x8233: + return "GL_R16I"; + case 0x8234: + return "GL_R16UI"; + case 0x8235: + return "GL_R32I"; + case 0x8236: + return "GL_R32UI"; + case 0x8237: + return "GL_RG8I"; + case 0x8238: + return "GL_RG8UI"; + case 0x8239: + return "GL_RG16I"; + case 0x823A: + return "GL_RG16UI"; + case 0x823B: + return "GL_RG32I"; + case 0x823C: + return "GL_RG32UI"; + case 0x83F0: + return "GL_COMPRESSED_RGB_S3TC_DXT1_EXT"; + case 0x83F1: + return "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT"; + case 0x83F2: + return "GL_COMPRESSED_RGBA_S3TC_DXT3_EXT"; + case 0x83F3: + return "GL_COMPRESSED_RGBA_S3TC_DXT5_EXT"; + case 0x8814: + return "GL_RGBA32F"; + case 0x8815: + return "GL_RGB32F"; + case 0x881A: + return "GL_RGBA16F"; + case 0x881B: + return "GL_RGB16F"; + case 0x88F0: + return "GL_DEPTH24_STENCIL8"; + case 0x8C3A: + return "GL_R11F_G11F_B10F"; + case 0x8C3D: + return "GL_RGB9_E5"; + case 0x8C41: + return "GL_SRGB8"; + case 0x8C43: + return "GL_SRGB8_ALPHA8"; + case 0x8CAC: + return "GL_DEPTH_COMPONENT32F"; + case 0x8CAD: + return "GL_DEPTH32F_STENCIL8"; + case 0x8D46: + return "GL_STENCIL_INDEX1"; + case 0x8D47: + return "GL_STENCIL_INDEX4"; + case 0x8D48: + return "GL_STENCIL_INDEX8"; + case 0x8D49: + return "GL_STENCIL_INDEX16"; + case 0x8D62: + return "GL_RGB565"; + case 0x8D70: + return "GL_RGBA32UI"; + case 0x8D71: + return "GL_RGB32UI"; + case 0x8D76: + return "GL_RGBA16UI"; + case 0x8D77: + return "GL_RGB16UI"; + case 0x8D7C: + return "GL_RGBA8UI"; + case 0x8D7D: + return "GL_RGB8UI"; + case 0x8D82: + return "GL_RGBA32I"; + case 0x8D83: + return "GL_RGB32I"; + case 0x8D88: + return "GL_RGBA16I"; + case 0x8D89: + return "GL_RGB16I"; + case 0x8D8E: + return "GL_RGBA8I"; + case 0x8D8F: + return "GL_RGB8I"; + case 0x8DBB: + return "GL_COMPRESSED_RED_RGTC1"; + case 0x8DBC: + return "GL_COMPRESSED_SIGNED_RED_RGTC1"; + case 0x8DBD: + return "GL_COMPRESSED_RED_GREEN_RGTC2_EXT"; + case 0x8DBE: + return "GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT"; + case 0x8E8C: + return "GL_COMPRESSED_RGBA_BPTC_UNORM"; + case 0x8E8D: + return "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM"; + case 0x8E8E: + return "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT"; + case 0x8E8F: + return "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT"; + case 0x8F94: + return "GL_R8_SNORM"; + case 0x8F95: + return "GL_RG8_SNORM"; + case 0x8F96: + return "GL_RGB8_SNORM"; + case 0x8F97: + return "GL_RGBA8_SNORM"; + case 0x8F98: + return "GL_R16_SNORM"; + case 0x8F99: + return "GL_RG16_SNORM"; + case 0x8F9A: + return "GL_RGB16_SNORM"; + case 0x8F9B: + return "GL_RGBA16_SNORM"; + case 0x906F: + return "GL_RGB10_A2UI"; + case 0x9270: + return "GL_COMPRESSED_R11_EAC"; + case 0x9271: + return "GL_COMPRESSED_SIGNED_R11_EAC"; + case 0x9272: + return "GL_COMPRESSED_RG11_EAC"; + case 0x9273: + return "GL_COMPRESSED_SIGNED_RG11_EAC"; + case 0x9274: + return "GL_COMPRESSED_RGB8_ETC2"; + case 0x9275: + return "GL_COMPRESSED_SRGB8_ETC2"; + case 0x9276: + return "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9277: + return "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2"; + case 0x9278: + return "GL_COMPRESSED_RGBA8_ETC2_EAC"; + case 0x9279: + return "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC"; + case 0x93B0: + return "GL_COMPRESSED_RGBA_ASTC_4x4_KHR"; + case 0x93B1: + return "GL_COMPRESSED_RGBA_ASTC_5x4_KHR"; + case 0x93B2: + return "GL_COMPRESSED_RGBA_ASTC_5x5_KHR"; + case 0x93B3: + return "GL_COMPRESSED_RGBA_ASTC_6x5_KHR"; + case 0x93B4: + return "GL_COMPRESSED_RGBA_ASTC_6x6_KHR"; + case 0x93B5: + return "GL_COMPRESSED_RGBA_ASTC_8x5_KHR"; + case 0x93B6: + return "GL_COMPRESSED_RGBA_ASTC_8x6_KHR"; + case 0x93B7: + return "GL_COMPRESSED_RGBA_ASTC_8x8_KHR"; + case 0x93B8: + return "GL_COMPRESSED_RGBA_ASTC_10x5_KHR"; + case 0x93B9: + return "GL_COMPRESSED_RGBA_ASTC_10x6_KHR"; + case 0x93BA: + return "GL_COMPRESSED_RGBA_ASTC_10x8_KHR"; + case 0x93BB: + return "GL_COMPRESSED_RGBA_ASTC_10x10_KHR"; + case 0x93BC: + return "GL_COMPRESSED_RGBA_ASTC_12x10_KHR"; + case 0x93BD: + return "GL_COMPRESSED_RGBA_ASTC_12x12_KHR"; + case 0x93D0: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR"; + case 0x93D1: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR"; + case 0x93D2: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR"; + case 0x93D3: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR"; + case 0x93D4: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR"; + case 0x93D5: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR"; + case 0x93D6: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR"; + case 0x93D7: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR"; + case 0x93D8: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR"; + case 0x93D9: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR"; + case 0x93DA: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR"; + case 0x93DB: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR"; + case 0x93DC: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR"; + case 0x93DD: + return "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::StencilFaceDirection: + { + switch (value) + { + case 0x404: + return "GL_FRONT"; + case 0x405: + return "GL_BACK"; + case 0x408: + return "GL_FRONT_AND_BACK"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::StencilFunction: + { + switch (value) + { + case 0x200: + return "GL_NEVER"; + case 0x201: + return "GL_LESS"; + case 0x202: + return "GL_EQUAL"; + case 0x203: + return "GL_LEQUAL"; + case 0x204: + return "GL_GREATER"; + case 0x205: + return "GL_NOTEQUAL"; + case 0x206: + return "GL_GEQUAL"; + case 0x207: + return "GL_ALWAYS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::StencilOp: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x150A: + return "GL_INVERT"; + case 0x1E00: + return "GL_KEEP"; + case 0x1E01: + return "GL_REPLACE"; + case 0x1E02: + return "GL_INCR"; + case 0x1E03: + return "GL_DECR"; + case 0x8507: + return "GL_INCR_WRAP"; + case 0x8508: + return "GL_DECR_WRAP"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::StringName: + { + switch (value) + { + case 0x1F00: + return "GL_VENDOR"; + case 0x1F01: + return "GL_RENDERER"; + case 0x1F02: + return "GL_VERSION"; + case 0x1F03: + return "GL_EXTENSIONS"; + case 0x8B8C: + return "GL_SHADING_LANGUAGE_VERSION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SubroutineParameterName: + { + switch (value) + { + case 0x8A38: + return "GL_UNIFORM_SIZE"; + case 0x8A39: + return "GL_UNIFORM_NAME_LENGTH"; + case 0x8E4A: + return "GL_NUM_COMPATIBLE_SUBROUTINES"; + case 0x8E4B: + return "GL_COMPATIBLE_SUBROUTINES"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SyncBehaviorFlags: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SyncCondition: + { + switch (value) + { + case 0x9117: + return "GL_SYNC_GPU_COMMANDS_COMPLETE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SyncObjectMask: + { + switch (value) + { + case 0x1: + return "GL_SYNC_FLUSH_COMMANDS_BIT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SyncParameterName: + { + switch (value) + { + case 0x9112: + return "GL_OBJECT_TYPE"; + case 0x9113: + return "GL_SYNC_CONDITION"; + case 0x9114: + return "GL_SYNC_STATUS"; + case 0x9115: + return "GL_SYNC_FLAGS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::SyncStatus: + { + switch (value) + { + case 0x911A: + return "GL_ALREADY_SIGNALED"; + case 0x911B: + return "GL_TIMEOUT_EXPIRED"; + case 0x911C: + return "GL_CONDITION_SATISFIED"; + case 0x911D: + return "GL_WAIT_FAILED"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TangentPointerTypeEXT: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TexCoordPointerType: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureCompareMode: + { + switch (value) + { + case 0x0: + return "GL_NONE"; + case 0x884E: + return "GL_COMPARE_REF_TO_TEXTURE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureCoordName: + { + switch (value) + { + case 0x2000: + return "GL_S"; + case 0x2001: + return "GL_T"; + case 0x2002: + return "GL_R"; + case 0x2003: + return "GL_Q"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureEnvMode: + { + switch (value) + { + case 0x104: + return "GL_ADD"; + case 0xBE2: + return "GL_BLEND"; + case 0x2100: + return "GL_MODULATE"; + case 0x2101: + return "GL_DECAL"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureEnvParameter: + { + switch (value) + { + case 0x2200: + return "GL_TEXTURE_ENV_MODE"; + case 0x2201: + return "GL_TEXTURE_ENV_COLOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureEnvTarget: + { + switch (value) + { + case 0x2300: + return "GL_TEXTURE_ENV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureGenMode: + { + switch (value) + { + case 0x2400: + return "GL_EYE_LINEAR"; + case 0x2401: + return "GL_OBJECT_LINEAR"; + case 0x2402: + return "GL_SPHERE_MAP"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureGenParameter: + { + switch (value) + { + case 0x2500: + return "GL_TEXTURE_GEN_MODE"; + case 0x2501: + return "GL_OBJECT_PLANE"; + case 0x2502: + return "GL_EYE_PLANE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureLayout: + { + switch (value) + { + case 0x9530: + return "GL_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_EXT"; + case 0x9531: + return "GL_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_EXT"; + case 0x958D: + return "GL_LAYOUT_GENERAL_EXT"; + case 0x958E: + return "GL_LAYOUT_COLOR_ATTACHMENT_EXT"; + case 0x958F: + return "GL_LAYOUT_DEPTH_STENCIL_ATTACHMENT_EXT"; + case 0x9590: + return "GL_LAYOUT_DEPTH_STENCIL_READ_ONLY_EXT"; + case 0x9591: + return "GL_LAYOUT_SHADER_READ_ONLY_EXT"; + case 0x9592: + return "GL_LAYOUT_TRANSFER_SRC_EXT"; + case 0x9593: + return "GL_LAYOUT_TRANSFER_DST_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureMagFilter: + { + switch (value) + { + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureMinFilter: + { + switch (value) + { + case 0x2600: + return "GL_NEAREST"; + case 0x2601: + return "GL_LINEAR"; + case 0x2700: + return "GL_NEAREST_MIPMAP_NEAREST"; + case 0x2701: + return "GL_LINEAR_MIPMAP_NEAREST"; + case 0x2702: + return "GL_NEAREST_MIPMAP_LINEAR"; + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureParameterName: + { + switch (value) + { + case 0x1000: + return "GL_TEXTURE_WIDTH"; + case 0x1001: + return "GL_TEXTURE_HEIGHT"; + case 0x1003: + return "GL_TEXTURE_COMPONENTS"; + case 0x1004: + return "GL_TEXTURE_BORDER_COLOR"; + case 0x1005: + return "GL_TEXTURE_BORDER"; + case 0x2800: + return "GL_TEXTURE_MAG_FILTER"; + case 0x2801: + return "GL_TEXTURE_MIN_FILTER"; + case 0x2802: + return "GL_TEXTURE_WRAP_S"; + case 0x2803: + return "GL_TEXTURE_WRAP_T"; + case 0x805C: + return "GL_TEXTURE_RED_SIZE"; + case 0x805D: + return "GL_TEXTURE_GREEN_SIZE"; + case 0x805E: + return "GL_TEXTURE_BLUE_SIZE"; + case 0x805F: + return "GL_TEXTURE_ALPHA_SIZE"; + case 0x8060: + return "GL_TEXTURE_LUMINANCE_SIZE"; + case 0x8061: + return "GL_TEXTURE_INTENSITY_SIZE"; + case 0x8066: + return "GL_TEXTURE_PRIORITY"; + case 0x8067: + return "GL_TEXTURE_RESIDENT"; + case 0x8072: + return "GL_TEXTURE_WRAP_R"; + case 0x813A: + return "GL_TEXTURE_MIN_LOD"; + case 0x813B: + return "GL_TEXTURE_MAX_LOD"; + case 0x813C: + return "GL_TEXTURE_BASE_LEVEL"; + case 0x813D: + return "GL_TEXTURE_MAX_LEVEL"; + case 0x8191: + return "GL_GENERATE_MIPMAP"; + case 0x84FE: + return "GL_TEXTURE_MAX_ANISOTROPY"; + case 0x8501: + return "GL_TEXTURE_LOD_BIAS"; + case 0x884C: + return "GL_TEXTURE_COMPARE_MODE"; + case 0x884D: + return "GL_TEXTURE_COMPARE_FUNC"; + case 0x8E42: + return "GL_TEXTURE_SWIZZLE_R"; + case 0x8E43: + return "GL_TEXTURE_SWIZZLE_G"; + case 0x8E44: + return "GL_TEXTURE_SWIZZLE_B"; + case 0x8E45: + return "GL_TEXTURE_SWIZZLE_A"; + case 0x8E46: + return "GL_TEXTURE_SWIZZLE_RGBA"; + case 0x90EA: + return "GL_DEPTH_STENCIL_TEXTURE_MODE"; + case 0x9580: + return "GL_TEXTURE_TILING_EXT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureSwizzle: + { + switch (value) + { + case 0x0: + return "GL_ZERO"; + case 0x1: + return "GL_ONE"; + case 0x1903: + return "GL_RED"; + case 0x1904: + return "GL_GREEN"; + case 0x1905: + return "GL_BLUE"; + case 0x1906: + return "GL_ALPHA"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureTarget: + { + switch (value) + { + case 0xDE0: + return "GL_TEXTURE_1D"; + case 0xDE1: + return "GL_TEXTURE_2D"; + case 0x8063: + return "GL_PROXY_TEXTURE_1D"; + case 0x8064: + return "GL_PROXY_TEXTURE_2D"; + case 0x806F: + return "GL_TEXTURE_3D"; + case 0x8070: + return "GL_PROXY_TEXTURE_3D"; + case 0x84F5: + return "GL_TEXTURE_RECTANGLE"; + case 0x84F7: + return "GL_PROXY_TEXTURE_RECTANGLE"; + case 0x8513: + return "GL_TEXTURE_CUBE_MAP"; + case 0x8515: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_X"; + case 0x8516: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_X"; + case 0x8517: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Y"; + case 0x8518: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Y"; + case 0x8519: + return "GL_TEXTURE_CUBE_MAP_POSITIVE_Z"; + case 0x851A: + return "GL_TEXTURE_CUBE_MAP_NEGATIVE_Z"; + case 0x851B: + return "GL_PROXY_TEXTURE_CUBE_MAP"; + case 0x8C18: + return "GL_TEXTURE_1D_ARRAY"; + case 0x8C19: + return "GL_PROXY_TEXTURE_1D_ARRAY"; + case 0x8C1A: + return "GL_TEXTURE_2D_ARRAY"; + case 0x8C1B: + return "GL_PROXY_TEXTURE_2D_ARRAY"; + case 0x8C2A: + return "GL_TEXTURE_BUFFER"; + case 0x8D41: + return "GL_RENDERBUFFER"; + case 0x9009: + return "GL_TEXTURE_CUBE_MAP_ARRAY"; + case 0x900B: + return "GL_PROXY_TEXTURE_CUBE_MAP_ARRAY"; + case 0x9100: + return "GL_TEXTURE_2D_MULTISAMPLE"; + case 0x9101: + return "GL_PROXY_TEXTURE_2D_MULTISAMPLE"; + case 0x9102: + return "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"; + case 0x9103: + return "GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureUnit: + { + switch (value) + { + case 0x84C0: + return "GL_TEXTURE0"; + case 0x84C1: + return "GL_TEXTURE1"; + case 0x84C2: + return "GL_TEXTURE2"; + case 0x84C3: + return "GL_TEXTURE3"; + case 0x84C4: + return "GL_TEXTURE4"; + case 0x84C5: + return "GL_TEXTURE5"; + case 0x84C6: + return "GL_TEXTURE6"; + case 0x84C7: + return "GL_TEXTURE7"; + case 0x84C8: + return "GL_TEXTURE8"; + case 0x84C9: + return "GL_TEXTURE9"; + case 0x84CA: + return "GL_TEXTURE10"; + case 0x84CB: + return "GL_TEXTURE11"; + case 0x84CC: + return "GL_TEXTURE12"; + case 0x84CD: + return "GL_TEXTURE13"; + case 0x84CE: + return "GL_TEXTURE14"; + case 0x84CF: + return "GL_TEXTURE15"; + case 0x84D0: + return "GL_TEXTURE16"; + case 0x84D1: + return "GL_TEXTURE17"; + case 0x84D2: + return "GL_TEXTURE18"; + case 0x84D3: + return "GL_TEXTURE19"; + case 0x84D4: + return "GL_TEXTURE20"; + case 0x84D5: + return "GL_TEXTURE21"; + case 0x84D6: + return "GL_TEXTURE22"; + case 0x84D7: + return "GL_TEXTURE23"; + case 0x84D8: + return "GL_TEXTURE24"; + case 0x84D9: + return "GL_TEXTURE25"; + case 0x84DA: + return "GL_TEXTURE26"; + case 0x84DB: + return "GL_TEXTURE27"; + case 0x84DC: + return "GL_TEXTURE28"; + case 0x84DD: + return "GL_TEXTURE29"; + case 0x84DE: + return "GL_TEXTURE30"; + case 0x84DF: + return "GL_TEXTURE31"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TextureWrapMode: + { + switch (value) + { + case 0x2703: + return "GL_LINEAR_MIPMAP_LINEAR"; + case 0x2900: + return "GL_CLAMP"; + case 0x2901: + return "GL_REPEAT"; + case 0x812D: + return "GL_CLAMP_TO_BORDER"; + case 0x812F: + return "GL_CLAMP_TO_EDGE"; + case 0x8370: + return "GL_MIRRORED_REPEAT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TransformFeedbackBufferMode: + { + switch (value) + { + case 0x8C8C: + return "GL_INTERLEAVED_ATTRIBS"; + case 0x8C8D: + return "GL_SEPARATE_ATTRIBS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::TransformFeedbackPName: + { + switch (value) + { + case 0x8C84: + return "GL_TRANSFORM_FEEDBACK_BUFFER_START"; + case 0x8C85: + return "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE"; + case 0x8C8F: + return "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"; + case 0x8E23: + return "GL_TRANSFORM_FEEDBACK_PAUSED"; + case 0x8E24: + return "GL_TRANSFORM_FEEDBACK_ACTIVE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::UniformBlockPName: + { + switch (value) + { + case 0x84F0: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER"; + case 0x84F1: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER"; + case 0x8A3F: + return "GL_UNIFORM_BLOCK_BINDING"; + case 0x8A40: + return "GL_UNIFORM_BLOCK_DATA_SIZE"; + case 0x8A41: + return "GL_UNIFORM_BLOCK_NAME_LENGTH"; + case 0x8A42: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS"; + case 0x8A43: + return "GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES"; + case 0x8A44: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"; + case 0x8A45: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER"; + case 0x8A46: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"; + case 0x90EC: + return "GL_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::UniformPName: + { + switch (value) + { + case 0x8A37: + return "GL_UNIFORM_TYPE"; + case 0x8A38: + return "GL_UNIFORM_SIZE"; + case 0x8A39: + return "GL_UNIFORM_NAME_LENGTH"; + case 0x8A3A: + return "GL_UNIFORM_BLOCK_INDEX"; + case 0x8A3B: + return "GL_UNIFORM_OFFSET"; + case 0x8A3C: + return "GL_UNIFORM_ARRAY_STRIDE"; + case 0x8A3D: + return "GL_UNIFORM_MATRIX_STRIDE"; + case 0x8A3E: + return "GL_UNIFORM_IS_ROW_MAJOR"; + case 0x92DA: + return "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::UniformType: + { + switch (value) + { + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + case 0x8B50: + return "GL_FLOAT_VEC2"; + case 0x8B51: + return "GL_FLOAT_VEC3"; + case 0x8B52: + return "GL_FLOAT_VEC4"; + case 0x8B53: + return "GL_INT_VEC2"; + case 0x8B54: + return "GL_INT_VEC3"; + case 0x8B55: + return "GL_INT_VEC4"; + case 0x8B56: + return "GL_BOOL"; + case 0x8B57: + return "GL_BOOL_VEC2"; + case 0x8B58: + return "GL_BOOL_VEC3"; + case 0x8B59: + return "GL_BOOL_VEC4"; + case 0x8B5A: + return "GL_FLOAT_MAT2"; + case 0x8B5B: + return "GL_FLOAT_MAT3"; + case 0x8B5C: + return "GL_FLOAT_MAT4"; + case 0x8B5D: + return "GL_SAMPLER_1D"; + case 0x8B5E: + return "GL_SAMPLER_2D"; + case 0x8B5F: + return "GL_SAMPLER_3D"; + case 0x8B60: + return "GL_SAMPLER_CUBE"; + case 0x8B61: + return "GL_SAMPLER_1D_SHADOW"; + case 0x8B62: + return "GL_SAMPLER_2D_SHADOW"; + case 0x8B63: + return "GL_SAMPLER_2D_RECT"; + case 0x8B64: + return "GL_SAMPLER_2D_RECT_SHADOW"; + case 0x8B65: + return "GL_FLOAT_MAT2x3"; + case 0x8B66: + return "GL_FLOAT_MAT2x4"; + case 0x8B67: + return "GL_FLOAT_MAT3x2"; + case 0x8B68: + return "GL_FLOAT_MAT3x4"; + case 0x8B69: + return "GL_FLOAT_MAT4x2"; + case 0x8B6A: + return "GL_FLOAT_MAT4x3"; + case 0x8DC0: + return "GL_SAMPLER_1D_ARRAY"; + case 0x8DC1: + return "GL_SAMPLER_2D_ARRAY"; + case 0x8DC2: + return "GL_SAMPLER_BUFFER"; + case 0x8DC3: + return "GL_SAMPLER_1D_ARRAY_SHADOW"; + case 0x8DC4: + return "GL_SAMPLER_2D_ARRAY_SHADOW"; + case 0x8DC5: + return "GL_SAMPLER_CUBE_SHADOW"; + case 0x8DC6: + return "GL_UNSIGNED_INT_VEC2"; + case 0x8DC7: + return "GL_UNSIGNED_INT_VEC3"; + case 0x8DC8: + return "GL_UNSIGNED_INT_VEC4"; + case 0x8DC9: + return "GL_INT_SAMPLER_1D"; + case 0x8DCA: + return "GL_INT_SAMPLER_2D"; + case 0x8DCB: + return "GL_INT_SAMPLER_3D"; + case 0x8DCC: + return "GL_INT_SAMPLER_CUBE"; + case 0x8DCD: + return "GL_INT_SAMPLER_2D_RECT"; + case 0x8DCE: + return "GL_INT_SAMPLER_1D_ARRAY"; + case 0x8DCF: + return "GL_INT_SAMPLER_2D_ARRAY"; + case 0x8DD0: + return "GL_INT_SAMPLER_BUFFER"; + case 0x8DD1: + return "GL_UNSIGNED_INT_SAMPLER_1D"; + case 0x8DD2: + return "GL_UNSIGNED_INT_SAMPLER_2D"; + case 0x8DD3: + return "GL_UNSIGNED_INT_SAMPLER_3D"; + case 0x8DD4: + return "GL_UNSIGNED_INT_SAMPLER_CUBE"; + case 0x8DD5: + return "GL_UNSIGNED_INT_SAMPLER_2D_RECT"; + case 0x8DD6: + return "GL_UNSIGNED_INT_SAMPLER_1D_ARRAY"; + case 0x8DD7: + return "GL_UNSIGNED_INT_SAMPLER_2D_ARRAY"; + case 0x8DD8: + return "GL_UNSIGNED_INT_SAMPLER_BUFFER"; + case 0x8F46: + return "GL_DOUBLE_MAT2"; + case 0x8F47: + return "GL_DOUBLE_MAT3"; + case 0x8F48: + return "GL_DOUBLE_MAT4"; + case 0x8F49: + return "GL_DOUBLE_MAT2x3"; + case 0x8F4A: + return "GL_DOUBLE_MAT2x4"; + case 0x8F4B: + return "GL_DOUBLE_MAT3x2"; + case 0x8F4C: + return "GL_DOUBLE_MAT3x4"; + case 0x8F4D: + return "GL_DOUBLE_MAT4x2"; + case 0x8F4E: + return "GL_DOUBLE_MAT4x3"; + case 0x8FFC: + return "GL_DOUBLE_VEC2"; + case 0x8FFD: + return "GL_DOUBLE_VEC3"; + case 0x8FFE: + return "GL_DOUBLE_VEC4"; + case 0x900C: + return "GL_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900D: + return "GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW"; + case 0x900E: + return "GL_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x900F: + return "GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY"; + case 0x9108: + return "GL_SAMPLER_2D_MULTISAMPLE"; + case 0x9109: + return "GL_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910A: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE"; + case 0x910B: + return "GL_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910C: + return "GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + case 0x910D: + return "GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::UseProgramStageMask: + { + switch (value) + { + case 0x1: + return "GL_VERTEX_SHADER_BIT"; + case 0x2: + return "GL_FRAGMENT_SHADER_BIT"; + case 0x4: + return "GL_GEOMETRY_SHADER_BIT"; + case 0x8: + return "GL_TESS_CONTROL_SHADER_BIT"; + case 0x10: + return "GL_TESS_EVALUATION_SHADER_BIT"; + case 0x20: + return "GL_COMPUTE_SHADER_BIT"; + case 0xFFFFFFFF: + return "GL_ALL_SHADER_BITS"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexArrayPName: + { + switch (value) + { + case 0x82D5: + return "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x874E: + return "GL_VERTEX_ATTRIB_ARRAY_LONG"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; + case 0x88FE: + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribEnum: + { + switch (value) + { + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x8626: + return "GL_CURRENT_VERTEX_ATTRIB"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; + case 0x889F: + return "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; + case 0x88FE: + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribIType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribLType: + { + switch (value) + { + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribPointerPropertyARB: + { + switch (value) + { + case 0x8645: + return "GL_VERTEX_ATTRIB_ARRAY_POINTER"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribPointerType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + case 0x140B: + return "GL_HALF_FLOAT"; + case 0x140C: + return "GL_FIXED"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; + case 0x8C3B: + return "GL_UNSIGNED_INT_10F_11F_11F_REV"; + case 0x8D9F: + return "GL_INT_2_10_10_10_REV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribPropertyARB: + { + switch (value) + { + case 0x82D4: + return "GL_VERTEX_ATTRIB_BINDING"; + case 0x82D5: + return "GL_VERTEX_ATTRIB_RELATIVE_OFFSET"; + case 0x8622: + return "GL_VERTEX_ATTRIB_ARRAY_ENABLED"; + case 0x8623: + return "GL_VERTEX_ATTRIB_ARRAY_SIZE"; + case 0x8624: + return "GL_VERTEX_ATTRIB_ARRAY_STRIDE"; + case 0x8625: + return "GL_VERTEX_ATTRIB_ARRAY_TYPE"; + case 0x8626: + return "GL_CURRENT_VERTEX_ATTRIB"; + case 0x874E: + return "GL_VERTEX_ATTRIB_ARRAY_LONG"; + case 0x886A: + return "GL_VERTEX_ATTRIB_ARRAY_NORMALIZED"; + case 0x889F: + return "GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING"; + case 0x88FD: + return "GL_VERTEX_ATTRIB_ARRAY_INTEGER"; + case 0x88FE: + return "GL_VERTEX_ATTRIB_ARRAY_DIVISOR"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexAttribType: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + case 0x140B: + return "GL_HALF_FLOAT"; + case 0x140C: + return "GL_FIXED"; + case 0x8368: + return "GL_UNSIGNED_INT_2_10_10_10_REV"; + case 0x8C3B: + return "GL_UNSIGNED_INT_10F_11F_11F_REV"; + case 0x8D9F: + return "GL_INT_2_10_10_10_REV"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexBufferObjectParameter: + { + switch (value) + { + case 0x821F: + return "GL_BUFFER_IMMUTABLE_STORAGE"; + case 0x8220: + return "GL_BUFFER_STORAGE_FLAGS"; + case 0x8764: + return "GL_BUFFER_SIZE"; + case 0x8765: + return "GL_BUFFER_USAGE"; + case 0x88BB: + return "GL_BUFFER_ACCESS"; + case 0x88BC: + return "GL_BUFFER_MAPPED"; + case 0x911F: + return "GL_BUFFER_ACCESS_FLAGS"; + case 0x9120: + return "GL_BUFFER_MAP_LENGTH"; + case 0x9121: + return "GL_BUFFER_MAP_OFFSET"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexBufferObjectUsage: + { + switch (value) + { + case 0x88E0: + return "GL_STREAM_DRAW"; + case 0x88E1: + return "GL_STREAM_READ"; + case 0x88E2: + return "GL_STREAM_COPY"; + case 0x88E4: + return "GL_STATIC_DRAW"; + case 0x88E5: + return "GL_STATIC_READ"; + case 0x88E6: + return "GL_STATIC_COPY"; + case 0x88E8: + return "GL_DYNAMIC_DRAW"; + case 0x88E9: + return "GL_DYNAMIC_READ"; + case 0x88EA: + return "GL_DYNAMIC_COPY"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexPointerType: + { + switch (value) + { + case 0x1402: + return "GL_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexProvokingMode: + { + switch (value) + { + case 0x8E4D: + return "GL_FIRST_VERTEX_CONVENTION"; + case 0x8E4E: + return "GL_LAST_VERTEX_CONVENTION"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexShaderTextureUnitParameter: + { + switch (value) + { + case 0xB03: + return "GL_CURRENT_TEXTURE_COORDS"; + case 0xBA8: + return "GL_TEXTURE_MATRIX"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexShaderWriteMaskEXT: + { + switch (value) + { + case 0x0: + return "GL_FALSE"; + case 0x1: + return "GL_TRUE"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::VertexWeightPointerTypeEXT: + { + switch (value) + { + case 0x1406: + return "GL_FLOAT"; + default: + return UnknownEnumToString(value); + } + } + + case BigGLEnum::WeightPointerTypeARB: + { + switch (value) + { + case 0x1400: + return "GL_BYTE"; + case 0x1401: + return "GL_UNSIGNED_BYTE"; + case 0x1402: + return "GL_SHORT"; + case 0x1403: + return "GL_UNSIGNED_SHORT"; + case 0x1404: + return "GL_INT"; + case 0x1405: + return "GL_UNSIGNED_INT"; + case 0x1406: + return "GL_FLOAT"; + case 0x140A: + return "GL_DOUBLE"; + default: + return UnknownEnumToString(value); + } + } + + default: + return UnknownEnumToString(value); } } } // namespace gl diff --git a/src/libANGLE/capture/gl_enum_utils_autogen.h b/src/libANGLE/capture/gl_enum_utils_autogen.h index 3e70dcde3..292b4eb5f 100644 --- a/src/libANGLE/capture/gl_enum_utils_autogen.h +++ b/src/libANGLE/capture/gl_enum_utils_autogen.h @@ -13,26 +13,224 @@ namespace gl { -enum class GLenumGroup +enum class GLESEnum { AccumOp, + AllEnums, AlphaFunction, AtomicCounterBufferPName, AttribMask, AttributeType, BindTransformFeedbackTarget, + BinormalPointerTypeEXT, BlendEquationModeEXT, BlendingFactor, BlitFramebufferFilter, Boolean, Buffer, BufferAccessARB, - BufferAccessMask, - BufferBitQCOM, + BufferPNameARB, + BufferPointerNameARB, + BufferStorageMask, BufferStorageTarget, BufferTargetARB, BufferUsageARB, CheckFramebufferStatusTarget, + ClampColorModeARB, + ClearBufferMask, + ClipPlaneName, + ColorBuffer, + ColorMaterialFace, + ColorMaterialParameter, + ColorPointerType, + CombinerBiasNV, + CombinerComponentUsageNV, + CombinerPortionNV, + CombinerScaleNV, + ContainerType, + ContextFlagMask, + CopyBufferSubDataTarget, + CopyImageSubDataTarget, + CullFaceMode, + DebugSeverity, + DebugSource, + DebugType, + DepthFunction, + DepthStencilTextureMode, + DrawBufferMode, + DrawElementsType, + ElementPointerTypeATI, + EnableCap, + ErrorCode, + ExternalHandleType, + FenceConditionNV, + FenceParameterNameNV, + FogCoordinatePointerType, + FogMode, + FogPName, + FogParameter, + FogPointerTypeEXT, + FogPointerTypeIBM, + FragmentLightParameterSGIX, + FragmentShaderDestMaskATI, + FragmentShaderDestModMaskATI, + FragmentShaderGenericSourceATI, + FragmentShaderTextureSourceATI, + FragmentShaderValueRepATI, + FramebufferAttachment, + FramebufferAttachmentParameterName, + FramebufferParameterName, + FramebufferStatus, + FramebufferTarget, + FrontFaceDirection, + GetFramebufferParameter, + GetMultisamplePNameNV, + GetPName, + GetPointervPName, + GetTextureParameter, + GlslTypeToken, + GraphicsResetStatus, + HintMode, + HintTarget, + IndexFunctionEXT, + IndexPointerType, + InternalFormat, + InternalFormatPName, + InvalidateFramebufferAttachment, + LightEnvModeSGIX, + LightModelParameter, + LightName, + LightParameter, + ListNameType, + LogicOp, + MapBufferAccessMask, + MapTypeNV, + MaterialFace, + MaterialParameter, + MatrixIndexPointerTypeARB, + MatrixMode, + MemoryBarrierMask, + MemoryObjectParameterName, + NormalPointerType, + ObjectIdentifier, + PatchParameterName, + PathColor, + PathColorFormat, + PathFillMode, + PathFontStyle, + PathGenMode, + PathTransformType, + PipelineParameterName, + PixelCopyType, + PixelFormat, + PixelStoreParameter, + PixelTexGenMode, + PixelTexGenModeSGIX, + PixelTransferParameter, + PixelType, + PointParameterNameARB, + PointParameterNameSGIS, + PrecisionType, + PrimitiveType, + ProgramInterface, + ProgramInterfacePName, + ProgramParameterPName, + ProgramPropertyARB, + ProgramResourceProperty, + QueryCounterTarget, + QueryObjectParameterName, + QueryParameterName, + QueryTarget, + ReadBufferMode, + RegisterCombinerPname, + RenderbufferParameterName, + RenderbufferTarget, + ReplacementCodeTypeSUN, + SamplerParameterF, + SamplerParameterI, + ScalarType, + SecondaryColorPointerTypeIBM, + SemaphoreParameterName, + ShaderBinaryFormat, + ShaderParameterName, + ShaderType, + ShadingModel, + ShadingRateQCOM, + SizedInternalFormat, + StencilFaceDirection, + StencilFunction, + StencilOp, + StringName, + SubroutineParameterName, + SyncBehaviorFlags, + SyncCondition, + SyncObjectMask, + SyncParameterName, + SyncStatus, + TangentPointerTypeEXT, + TexCoordPointerType, + TextureCompareMode, + TextureCoordName, + TextureEnvMode, + TextureEnvParameter, + TextureEnvTarget, + TextureGenParameter, + TextureLayout, + TextureMagFilter, + TextureMinFilter, + TextureParameterName, + TextureSwizzle, + TextureTarget, + TextureUnit, + TextureWrapMode, + TransformFeedbackBufferMode, + TransformFeedbackPName, + UniformBlockPName, + UniformPName, + UniformType, + UseProgramStageMask, + VertexArrayPName, + VertexAttribEnum, + VertexAttribIType, + VertexAttribPointerPropertyARB, + VertexAttribPointerType, + VertexAttribPropertyARB, + VertexAttribType, + VertexBufferObjectParameter, + VertexBufferObjectUsage, + VertexPointerType, + VertexProvokingMode, + VertexShaderTextureUnitParameter, + VertexShaderWriteMaskEXT, + VertexWeightPointerTypeEXT, + WeightPointerTypeARB +}; + +enum class BigGLEnum +{ + AccumOp, + AllEnums, + AlphaFunction, + AtomicCounterBufferPName, + AttribMask, + AttributeType, + BindTransformFeedbackTarget, + BinormalPointerTypeEXT, + BlendEquationModeEXT, + BlendingFactor, + BlitFramebufferFilter, + Boolean, + Buffer, + BufferAccessARB, + BufferPNameARB, + BufferPointerNameARB, + BufferStorageMask, + BufferStorageTarget, + BufferTargetARB, + BufferUsageARB, + CheckFramebufferStatusTarget, + ClampColorModeARB, + ClampColorTargetARB, ClearBufferMask, ClientAttribMask, ClipControlDepth, @@ -42,115 +240,117 @@ enum class GLenumGroup ColorMaterialFace, ColorMaterialParameter, ColorPointerType, - ColorTableParameterPNameSGI, ColorTableTarget, ColorTableTargetSGI, + CombinerBiasNV, + CombinerComponentUsageNV, + CombinerPortionNV, + CombinerScaleNV, + ConditionalRenderMode, + ContainerType, ContextFlagMask, ContextProfileMask, - ConvolutionBorderModeEXT, - ConvolutionParameterEXT, ConvolutionTarget, ConvolutionTargetEXT, CopyBufferSubDataTarget, + CopyImageSubDataTarget, CullFaceMode, - DataType, DebugSeverity, DebugSource, DebugType, - DefaultGroup, DepthFunction, + DepthStencilTextureMode, DrawBufferMode, DrawElementsType, + ElementPointerTypeATI, EnableCap, ErrorCode, ExternalHandleType, FeedBackToken, FeedbackType, - FfdMaskSGIX, - FfdTargetSGIX, + FenceConditionNV, + FenceParameterNameNV, + FogCoordSrc, FogCoordinatePointerType, FogMode, FogPName, FogParameter, FogPointerTypeEXT, FogPointerTypeIBM, - FragmentLightModelParameterSGIX, - FragmentOpATI, + FragmentLightParameterSGIX, + FragmentShaderDestMaskATI, + FragmentShaderDestModMaskATI, + FragmentShaderGenericSourceATI, + FragmentShaderTextureSourceATI, + FragmentShaderValueRepATI, FramebufferAttachment, FramebufferAttachmentParameterName, - FramebufferFetchNoncoherent, FramebufferParameterName, FramebufferStatus, FramebufferTarget, FrontFaceDirection, - GetColorTableParameterPNameSGI, - GetConvolutionParameter, GetFramebufferParameter, - GetHistogramParameterPNameEXT, GetMapQuery, - GetMinmaxParameterPNameEXT, + GetMultisamplePNameNV, GetPName, GetPixelMap, GetPointervPName, GetTextureParameter, + GlslTypeToken, GraphicsResetStatus, HintMode, HintTarget, + HistogramTarget, HistogramTargetEXT, + IndexFunctionEXT, + IndexMaterialParameterEXT, IndexPointerType, InterleavedArrayFormat, InternalFormat, InternalFormatPName, + InvalidateFramebufferAttachment, LightEnvModeSGIX, - LightEnvParameterSGIX, LightModelColorControl, LightModelParameter, LightName, LightParameter, + LightTextureModeEXT, ListMode, ListNameType, - ListParameterName, LogicOp, - MapBufferUsageMask, + MapBufferAccessMask, MapQuery, MapTarget, - MapTextureFormatINTEL, + MapTypeNV, MaterialFace, MaterialParameter, + MatrixIndexPointerTypeARB, MatrixMode, MemoryBarrierMask, MemoryObjectParameterName, MeshMode1, MeshMode2, + MinmaxTarget, MinmaxTargetEXT, NormalPointerType, ObjectIdentifier, - OcclusionQueryEventMaskAMD, PatchParameterName, PathColor, - PathCoverMode, - PathElementType, + PathColorFormat, PathFillMode, PathFontStyle, - PathFontTarget, PathGenMode, - PathHandleMissingGlyphs, - PathListMode, - PathMetricMask, - PathParameter, - PathStringFormat, PathTransformType, PipelineParameterName, PixelCopyType, PixelFormat, PixelMap, PixelStoreParameter, - PixelStoreResampleMode, - PixelStoreSubsampleRate, PixelTexGenMode, - PixelTexGenParameterNameSGIS, + PixelTexGenModeSGIX, PixelTransferParameter, PixelType, + PointParameterNameARB, PointParameterNameSGIS, PolygonMode, PrecisionType, @@ -159,60 +359,79 @@ enum class GLenumGroup ProgramInterfacePName, ProgramParameterPName, ProgramPropertyARB, + ProgramResourceProperty, ProgramStagePName, + QueryCounterTarget, QueryObjectParameterName, QueryParameterName, QueryTarget, ReadBufferMode, + RegisterCombinerPname, RenderbufferParameterName, RenderbufferTarget, RenderingMode, - SamplePatternSGIS, - SamplerParameterName, + ReplacementCodeTypeSUN, + SamplerParameterF, + SamplerParameterI, + ScalarType, + SecondaryColorPointerTypeIBM, SemaphoreParameterName, + SeparableTarget, SeparableTargetEXT, + ShaderBinaryFormat, ShaderParameterName, ShaderType, ShadingModel, - ShadingRate, + SizedInternalFormat, StencilFaceDirection, StencilFunction, StencilOp, StringName, SubroutineParameterName, + SyncBehaviorFlags, SyncCondition, SyncObjectMask, SyncParameterName, SyncStatus, + TangentPointerTypeEXT, TexCoordPointerType, + TextureCompareMode, TextureCoordName, TextureEnvMode, TextureEnvParameter, TextureEnvTarget, - TextureFilterFuncSGIS, TextureGenMode, TextureGenParameter, TextureLayout, TextureMagFilter, TextureMinFilter, TextureParameterName, - TextureStorageMaskAMD, + TextureSwizzle, TextureTarget, TextureUnit, TextureWrapMode, + TransformFeedbackBufferMode, TransformFeedbackPName, - TypeEnum, UniformBlockPName, UniformPName, + UniformType, UseProgramStageMask, VertexArrayPName, VertexAttribEnum, + VertexAttribIType, + VertexAttribLType, + VertexAttribPointerPropertyARB, VertexAttribPointerType, + VertexAttribPropertyARB, VertexAttribType, VertexBufferObjectParameter, VertexBufferObjectUsage, VertexPointerType, - VertexProvokingMode + VertexProvokingMode, + VertexShaderTextureUnitParameter, + VertexShaderWriteMaskEXT, + VertexWeightPointerTypeEXT, + WeightPointerTypeARB }; } // namespace gl diff --git a/src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp b/src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp index 65f0dec21..acfc840cc 100644 --- a/src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp +++ b/src/libANGLE/renderer/gl/DispatchTableGL_autogen.cpp @@ -969,10 +969,7 @@ void DispatchTableGL::initProcsDesktopGL(const gl::Version &version, ASSIGN("glTextureParameterfvEXT", textureParameterfv); ASSIGN("glTextureParameteriEXT", textureParameteri); ASSIGN("glTextureParameterivEXT", textureParameteriv); - ASSIGN("glTextureStorage1DEXT", textureStorage1D); - ASSIGN("glTextureStorage2DEXT", textureStorage2D); ASSIGN("glTextureStorage2DMultisampleEXT", textureStorage2DMultisample); - ASSIGN("glTextureStorage3DEXT", textureStorage3D); ASSIGN("glTextureStorage3DMultisampleEXT", textureStorage3DMultisample); ASSIGN("glTextureSubImage1DEXT", textureSubImage1D); ASSIGN("glTextureSubImage2DEXT", textureSubImage2D); @@ -1023,6 +1020,8 @@ void DispatchTableGL::initProcsDesktopGL(const gl::Version &version, ASSIGN("glBindFragDataLocationEXT", bindFragDataLocation); ASSIGN("glGetFragDataLocationEXT", getFragDataLocation); ASSIGN("glGetUniformuivEXT", getUniformuiv); + ASSIGN("glGetVertexAttribIivEXT", getVertexAttribIiv); + ASSIGN("glGetVertexAttribIuivEXT", getVertexAttribIuiv); ASSIGN("glUniform1uiEXT", uniform1ui); ASSIGN("glUniform1uivEXT", uniform1uiv); ASSIGN("glUniform2uiEXT", uniform2ui); @@ -1031,6 +1030,27 @@ void DispatchTableGL::initProcsDesktopGL(const gl::Version &version, ASSIGN("glUniform3uivEXT", uniform3uiv); ASSIGN("glUniform4uiEXT", uniform4ui); ASSIGN("glUniform4uivEXT", uniform4uiv); + ASSIGN("glVertexAttribI1iEXT", vertexAttribI1i); + ASSIGN("glVertexAttribI1ivEXT", vertexAttribI1iv); + ASSIGN("glVertexAttribI1uiEXT", vertexAttribI1ui); + ASSIGN("glVertexAttribI1uivEXT", vertexAttribI1uiv); + ASSIGN("glVertexAttribI2iEXT", vertexAttribI2i); + ASSIGN("glVertexAttribI2ivEXT", vertexAttribI2iv); + ASSIGN("glVertexAttribI2uiEXT", vertexAttribI2ui); + ASSIGN("glVertexAttribI2uivEXT", vertexAttribI2uiv); + ASSIGN("glVertexAttribI3iEXT", vertexAttribI3i); + ASSIGN("glVertexAttribI3ivEXT", vertexAttribI3iv); + ASSIGN("glVertexAttribI3uiEXT", vertexAttribI3ui); + ASSIGN("glVertexAttribI3uivEXT", vertexAttribI3uiv); + ASSIGN("glVertexAttribI4bvEXT", vertexAttribI4bv); + ASSIGN("glVertexAttribI4iEXT", vertexAttribI4i); + ASSIGN("glVertexAttribI4ivEXT", vertexAttribI4iv); + ASSIGN("glVertexAttribI4svEXT", vertexAttribI4sv); + ASSIGN("glVertexAttribI4ubvEXT", vertexAttribI4ubv); + ASSIGN("glVertexAttribI4uiEXT", vertexAttribI4ui); + ASSIGN("glVertexAttribI4uivEXT", vertexAttribI4uiv); + ASSIGN("glVertexAttribI4usvEXT", vertexAttribI4usv); + ASSIGN("glVertexAttribIPointerEXT", vertexAttribIPointer); } if (extensions.count("GL_EXT_point_parameters") != 0) @@ -2097,16 +2117,6 @@ void DispatchTableGL::initProcsGLES(const gl::Version &version, ASSIGN("glTexBufferRangeEXT", texBufferRangeEXT); } - if (extensions.count("GL_EXT_texture_storage") != 0) - { - ASSIGN("glTexStorage1DEXT", texStorage1D); - ASSIGN("glTexStorage2DEXT", texStorage2D); - ASSIGN("glTexStorage3DEXT", texStorage3D); - ASSIGN("glTextureStorage1DEXT", textureStorage1D); - ASSIGN("glTextureStorage2DEXT", textureStorage2D); - ASSIGN("glTextureStorage3DEXT", textureStorage3D); - } - if (extensions.count("GL_EXT_texture_view") != 0) { ASSIGN("glTextureViewEXT", textureView); @@ -2783,6 +2793,16 @@ void DispatchTableGL::initProcsSharedExtensions(const std::set &ext ASSIGN("glValidateProgramPipelineEXT", validateProgramPipeline); } + if (extensions.count("GL_EXT_texture_storage") != 0) + { + ASSIGN("glTexStorage1DEXT", texStorage1D); + ASSIGN("glTexStorage2DEXT", texStorage2D); + ASSIGN("glTexStorage3DEXT", texStorage3D); + ASSIGN("glTextureStorage1DEXT", textureStorage1D); + ASSIGN("glTextureStorage2DEXT", textureStorage2D); + ASSIGN("glTextureStorage3DEXT", textureStorage3D); + } + if (extensions.count("GL_KHR_parallel_shader_compile") != 0) { ASSIGN("glMaxShaderCompilerThreadsKHR", maxShaderCompilerThreadsKHR); @@ -3756,10 +3776,7 @@ void DispatchTableGL::initProcsDesktopGLNULL(const gl::Version &version, textureParameterfv = &glTextureParameterfvNULL; textureParameteri = &glTextureParameteriNULL; textureParameteriv = &glTextureParameterivNULL; - textureStorage1D = &glTextureStorage1DNULL; - textureStorage2D = &glTextureStorage2DNULL; textureStorage2DMultisample = &glTextureStorage2DMultisampleNULL; - textureStorage3D = &glTextureStorage3DNULL; textureStorage3DMultisample = &glTextureStorage3DMultisampleNULL; textureSubImage1D = &glTextureSubImage1DNULL; textureSubImage2D = &glTextureSubImage2DNULL; @@ -3810,6 +3827,8 @@ void DispatchTableGL::initProcsDesktopGLNULL(const gl::Version &version, bindFragDataLocation = &glBindFragDataLocationNULL; getFragDataLocation = &glGetFragDataLocationNULL; getUniformuiv = &glGetUniformuivNULL; + getVertexAttribIiv = &glGetVertexAttribIivNULL; + getVertexAttribIuiv = &glGetVertexAttribIuivNULL; uniform1ui = &glUniform1uiNULL; uniform1uiv = &glUniform1uivNULL; uniform2ui = &glUniform2uiNULL; @@ -3818,6 +3837,27 @@ void DispatchTableGL::initProcsDesktopGLNULL(const gl::Version &version, uniform3uiv = &glUniform3uivNULL; uniform4ui = &glUniform4uiNULL; uniform4uiv = &glUniform4uivNULL; + vertexAttribI1i = &glVertexAttribI1iNULL; + vertexAttribI1iv = &glVertexAttribI1ivNULL; + vertexAttribI1ui = &glVertexAttribI1uiNULL; + vertexAttribI1uiv = &glVertexAttribI1uivNULL; + vertexAttribI2i = &glVertexAttribI2iNULL; + vertexAttribI2iv = &glVertexAttribI2ivNULL; + vertexAttribI2ui = &glVertexAttribI2uiNULL; + vertexAttribI2uiv = &glVertexAttribI2uivNULL; + vertexAttribI3i = &glVertexAttribI3iNULL; + vertexAttribI3iv = &glVertexAttribI3ivNULL; + vertexAttribI3ui = &glVertexAttribI3uiNULL; + vertexAttribI3uiv = &glVertexAttribI3uivNULL; + vertexAttribI4bv = &glVertexAttribI4bvNULL; + vertexAttribI4i = &glVertexAttribI4iNULL; + vertexAttribI4iv = &glVertexAttribI4ivNULL; + vertexAttribI4sv = &glVertexAttribI4svNULL; + vertexAttribI4ubv = &glVertexAttribI4ubvNULL; + vertexAttribI4ui = &glVertexAttribI4uiNULL; + vertexAttribI4uiv = &glVertexAttribI4uivNULL; + vertexAttribI4usv = &glVertexAttribI4usvNULL; + vertexAttribIPointer = &glVertexAttribIPointerNULL; } if (extensions.count("GL_EXT_point_parameters") != 0) @@ -4883,16 +4923,6 @@ void DispatchTableGL::initProcsGLESNULL(const gl::Version &version, texBufferRangeEXT = &glTexBufferRangeEXTNULL; } - if (extensions.count("GL_EXT_texture_storage") != 0) - { - texStorage1D = &glTexStorage1DNULL; - texStorage2D = &glTexStorage2DNULL; - texStorage3D = &glTexStorage3DNULL; - textureStorage1D = &glTextureStorage1DNULL; - textureStorage2D = &glTextureStorage2DNULL; - textureStorage3D = &glTextureStorage3DNULL; - } - if (extensions.count("GL_EXT_texture_view") != 0) { textureView = &glTextureViewNULL; @@ -5569,6 +5599,16 @@ void DispatchTableGL::initProcsSharedExtensionsNULL(const std::set validateProgramPipeline = &glValidateProgramPipelineNULL; } + if (extensions.count("GL_EXT_texture_storage") != 0) + { + texStorage1D = &glTexStorage1DNULL; + texStorage2D = &glTexStorage2DNULL; + texStorage3D = &glTexStorage3DNULL; + textureStorage1D = &glTextureStorage1DNULL; + textureStorage2D = &glTextureStorage2DNULL; + textureStorage3D = &glTextureStorage3DNULL; + } + if (extensions.count("GL_KHR_parallel_shader_compile") != 0) { maxShaderCompilerThreadsKHR = &glMaxShaderCompilerThreadsKHRNULL; diff --git a/src/libANGLE/renderer/gl/generate_gl_dispatch_table.py b/src/libANGLE/renderer/gl/generate_gl_dispatch_table.py index 513301ffc..f0d4fa5f4 100644 --- a/src/libANGLE/renderer/gl/generate_gl_dispatch_table.py +++ b/src/libANGLE/renderer/gl/generate_gl_dispatch_table.py @@ -249,7 +249,7 @@ def main(): # auto_script parameters. if len(sys.argv) > 1: inputs = [ - '../../../../scripts/gl.xml', + '../../../../third_party/OpenGL-Registry/src/xml/gl.xml', '../angle_format.py', 'gl_bindings_data.json', ] @@ -269,7 +269,8 @@ def main(): return 1 return 0 - gl_xml_path = os.path.join('..', '..', '..', '..', 'scripts', 'gl.xml') + gl_xml_path = os.path.join('..', '..', '..', '..', 'third_party', 'OpenGL-Registry', 'src', + 'xml', 'gl.xml') dispatch_header_path = 'DispatchTableGL_autogen.h' dispatch_source_path = 'DispatchTableGL_autogen.cpp' null_functions_header_path = 'null_functions.h' diff --git a/src/libANGLE/renderer/gl/null_functions.cpp b/src/libANGLE/renderer/gl/null_functions.cpp index 5282b05ea..793fc5c70 100644 --- a/src/libANGLE/renderer/gl/null_functions.cpp +++ b/src/libANGLE/renderer/gl/null_functions.cpp @@ -923,7 +923,7 @@ void INTERNAL_GL_APIENTRY glGetActiveAttribNULL(GLuint program, void INTERNAL_GL_APIENTRY glGetActiveSubroutineNameNULL(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) {} @@ -931,7 +931,7 @@ void INTERNAL_GL_APIENTRY glGetActiveSubroutineNameNULL(GLuint program, void INTERNAL_GL_APIENTRY glGetActiveSubroutineUniformNameNULL(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) {} @@ -1092,21 +1092,21 @@ void INTERNAL_GL_APIENTRY glGetInternalformatSampleivNVNULL(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params) {} void INTERNAL_GL_APIENTRY glGetInternalformati64vNULL(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params) {} void INTERNAL_GL_APIENTRY glGetInternalformativNULL(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params) {} @@ -1229,7 +1229,7 @@ void INTERNAL_GL_APIENTRY glGetProgramResourceivNULL(GLuint program, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params) {} @@ -1351,7 +1351,7 @@ GLint INTERNAL_GL_APIENTRY glGetSubroutineUniformLocationNULL(GLuint program, } void INTERNAL_GL_APIENTRY -glGetSyncivNULL(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) +glGetSyncivNULL(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) {} void INTERNAL_GL_APIENTRY @@ -2325,7 +2325,7 @@ void INTERNAL_GL_APIENTRY glSetFenceNVNULL(GLuint fence, GLenum condition) {} void INTERNAL_GL_APIENTRY glShaderBinaryNULL(GLsizei count, const GLuint *shaders, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length) {} diff --git a/src/libANGLE/renderer/gl/null_functions.h b/src/libANGLE/renderer/gl/null_functions.h index 4bd392b26..d5e56ea70 100644 --- a/src/libANGLE/renderer/gl/null_functions.h +++ b/src/libANGLE/renderer/gl/null_functions.h @@ -625,13 +625,13 @@ void INTERNAL_GL_APIENTRY glGetActiveAttribNULL(GLuint program, void INTERNAL_GL_APIENTRY glGetActiveSubroutineNameNULL(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); void INTERNAL_GL_APIENTRY glGetActiveSubroutineUniformNameNULL(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); void INTERNAL_GL_APIENTRY glGetActiveSubroutineUniformivNULL(GLuint program, @@ -728,17 +728,17 @@ void INTERNAL_GL_APIENTRY glGetInternalformatSampleivNVNULL(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params); void INTERNAL_GL_APIENTRY glGetInternalformati64vNULL(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params); void INTERNAL_GL_APIENTRY glGetInternalformativNULL(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params); void INTERNAL_GL_APIENTRY glGetMemoryObjectParameterivEXTNULL(GLuint memoryObject, GLenum pname, @@ -813,7 +813,7 @@ void INTERNAL_GL_APIENTRY glGetProgramResourceivNULL(GLuint program, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params); void INTERNAL_GL_APIENTRY glGetProgramStageivNULL(GLuint program, @@ -882,7 +882,7 @@ GLint INTERNAL_GL_APIENTRY glGetSubroutineUniformLocationNULL(GLuint program, GLenum shadertype, const GLchar *name); void INTERNAL_GL_APIENTRY -glGetSyncivNULL(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); +glGetSyncivNULL(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); void INTERNAL_GL_APIENTRY glGetTexImageNULL(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); void INTERNAL_GL_APIENTRY glGetTexLevelParameterfvNULL(GLenum target, @@ -1471,7 +1471,7 @@ void INTERNAL_GL_APIENTRY glSemaphoreParameterui64vEXTNULL(GLuint semaphore, void INTERNAL_GL_APIENTRY glSetFenceNVNULL(GLuint fence, GLenum condition); void INTERNAL_GL_APIENTRY glShaderBinaryNULL(GLsizei count, const GLuint *shaders, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length); void INTERNAL_GL_APIENTRY glShaderSourceNULL(GLuint shader, diff --git a/src/libANGLE/validationES2_autogen.h b/src/libANGLE/validationES2_autogen.h index 82a29f823..335139fe7 100644 --- a/src/libANGLE/validationES2_autogen.h +++ b/src/libANGLE/validationES2_autogen.h @@ -423,7 +423,7 @@ bool ValidateShaderBinary(const Context *context, angle::EntryPoint entryPoint, GLsizei count, const ShaderProgramID *shadersPacked, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length); bool ValidateShaderSource(const Context *context, diff --git a/src/libANGLE/validationES31_autogen.h b/src/libANGLE/validationES31_autogen.h index c9f1ddf06..3e2adb50d 100644 --- a/src/libANGLE/validationES31_autogen.h +++ b/src/libANGLE/validationES31_autogen.h @@ -132,7 +132,7 @@ bool ValidateGetProgramResourceiv(const Context *context, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, const GLsizei *length, const GLint *params); bool ValidateGetTexLevelParameterfv(const Context *context, diff --git a/src/libANGLE/validationES3_autogen.h b/src/libANGLE/validationES3_autogen.h index 8667c4cb8..10465c63f 100644 --- a/src/libANGLE/validationES3_autogen.h +++ b/src/libANGLE/validationES3_autogen.h @@ -257,7 +257,7 @@ bool ValidateGetInternalformativ(const Context *context, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, const GLint *params); bool ValidateGetProgramBinary(const Context *context, angle::EntryPoint entryPoint, @@ -294,7 +294,7 @@ bool ValidateGetSynciv(const Context *context, angle::EntryPoint entryPoint, GLsync sync, GLenum pname, - GLsizei bufSize, + GLsizei count, const GLsizei *length, const GLint *values); bool ValidateGetTransformFeedbackVarying(const Context *context, diff --git a/src/libANGLE/validationESEXT_autogen.h b/src/libANGLE/validationESEXT_autogen.h index 64ff65d00..594ec404f 100644 --- a/src/libANGLE/validationESEXT_autogen.h +++ b/src/libANGLE/validationESEXT_autogen.h @@ -889,7 +889,7 @@ bool ValidateSampleMaskiANGLE(const Context *context, bool ValidateGetTranslatedShaderSourceANGLE(const Context *context, angle::EntryPoint entryPoint, ShaderProgramID shaderPacked, - GLsizei bufsize, + GLsizei bufSize, const GLsizei *length, const GLchar *source); @@ -1231,7 +1231,7 @@ bool ValidateMultiDrawElementsBaseVertexEXT(const Context *context, const GLsizei *count, DrawElementsType typePacked, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex); // GL_EXT_external_buffer @@ -1412,6 +1412,8 @@ bool ValidateRenderbufferStorageMultisampleEXT(const Context *context, GLsizei width, GLsizei height); +// GL_EXT_multisampled_render_to_texture2 + // GL_EXT_occlusion_query_boolean // GL_EXT_primitive_bounding_box diff --git a/src/libANGLE/validationGL4_autogen.h b/src/libANGLE/validationGL4_autogen.h index a5cb3736b..a69a1f209 100644 --- a/src/libANGLE/validationGL4_autogen.h +++ b/src/libANGLE/validationGL4_autogen.h @@ -42,7 +42,7 @@ bool ValidateGetActiveSubroutineName(const Context *context, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, const GLsizei *length, const GLchar *name); bool ValidateGetActiveSubroutineUniformName(const Context *context, @@ -50,7 +50,7 @@ bool ValidateGetActiveSubroutineUniformName(const Context *context, ShaderProgramID programPacked, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, const GLsizei *length, const GLchar *name); bool ValidateGetActiveSubroutineUniformiv(const Context *context, @@ -486,7 +486,7 @@ bool ValidateGetInternalformati64v(const Context *context, GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, const GLint64 *params); bool ValidateGetProgramResourceLocationIndex(const Context *context, angle::EntryPoint entryPoint, diff --git a/src/libGLESv2/entry_points_gl_1_autogen.cpp b/src/libGLESv2/entry_points_gl_1_autogen.cpp index 3d951f1b7..4bd0071e9 100644 --- a/src/libGLESv2/entry_points_gl_1_autogen.cpp +++ b/src/libGLESv2/entry_points_gl_1_autogen.cpp @@ -35,7 +35,7 @@ void GL_APIENTRY GL_Accum(GLenum op, GLfloat value) { Context *context = GetValidGlobalContext(); EVENT(context, GLAccum, "context = %d, op = %s, value = %f", CID(context), - GLenumToString(GLenumGroup::AccumOp, op), value); + GLenumToString(BigGLEnum::AccumOp, op), value); if (context) { @@ -58,7 +58,7 @@ void GL_APIENTRY GL_Begin(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBegin, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode)); + GLenumToString(BigGLEnum::PrimitiveType, mode)); if (context) { @@ -136,7 +136,7 @@ void GL_APIENTRY GL_CallLists(GLsizei n, GLenum type, const void *lists) { Context *context = GetValidGlobalContext(); EVENT(context, GLCallLists, "context = %d, n = %d, type = %s, lists = 0x%016" PRIxPTR "", - CID(context), n, GLenumToString(GLenumGroup::ListNameType, type), (uintptr_t)lists); + CID(context), n, GLenumToString(BigGLEnum::ListNameType, type), (uintptr_t)lists); if (context) { @@ -228,7 +228,7 @@ void GL_APIENTRY GL_ClipPlane(GLenum plane, const GLdouble *equation) { Context *context = GetValidGlobalContext(); EVENT(context, GLClipPlane, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation); + CID(context), GLenumToString(BigGLEnum::ClipPlaneName, plane), (uintptr_t)equation); if (context) { @@ -940,8 +940,8 @@ void GL_APIENTRY GL_ColorMaterial(GLenum face, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLColorMaterial, "context = %d, face = %s, mode = %s", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::ColorMaterialParameter, mode)); + GLenumToString(BigGLEnum::MaterialFace, face), + GLenumToString(BigGLEnum::ColorMaterialParameter, mode)); if (context) { @@ -965,7 +965,7 @@ void GL_APIENTRY GL_CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, { Context *context = GetValidGlobalContext(); EVENT(context, GLCopyPixels, "context = %d, x = %d, y = %d, width = %d, height = %d, type = %s", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelCopyType, type)); + CID(context), x, y, width, height, GLenumToString(BigGLEnum::PixelCopyType, type)); if (context) { @@ -1034,7 +1034,7 @@ void GL_APIENTRY GL_DrawBuffer(GLenum buf) { Context *context = GetValidGlobalContext(); EVENT(context, GLDrawBuffer, "context = %d, buf = %s", CID(context), - GLenumToString(GLenumGroup::DrawBufferMode, buf)); + GLenumToString(BigGLEnum::DrawBufferMode, buf)); if (context) { @@ -1060,8 +1060,8 @@ GL_DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const v EVENT(context, GLDrawPixels, "context = %d, width = %d, height = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), width, height, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), width, height, GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -1354,7 +1354,7 @@ void GL_APIENTRY GL_EvalMesh1(GLenum mode, GLint i1, GLint i2) { Context *context = GetValidGlobalContext(); EVENT(context, GLEvalMesh1, "context = %d, mode = %s, i1 = %d, i2 = %d", CID(context), - GLenumToString(GLenumGroup::MeshMode1, mode), i1, i2); + GLenumToString(BigGLEnum::MeshMode1, mode), i1, i2); if (context) { @@ -1378,7 +1378,7 @@ void GL_APIENTRY GL_EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j { Context *context = GetValidGlobalContext(); EVENT(context, GLEvalMesh2, "context = %d, mode = %s, i1 = %d, i2 = %d, j1 = %d, j2 = %d", - CID(context), GLenumToString(GLenumGroup::MeshMode2, mode), i1, i2, j1, j2); + CID(context), GLenumToString(BigGLEnum::MeshMode2, mode), i1, i2, j1, j2); if (context) { @@ -1447,7 +1447,7 @@ void GL_APIENTRY GL_FeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) Context *context = GetValidGlobalContext(); EVENT(context, GLFeedbackBuffer, "context = %d, size = %d, type = %s, buffer = 0x%016" PRIxPTR "", CID(context), size, - GLenumToString(GLenumGroup::FeedbackType, type), (uintptr_t)buffer); + GLenumToString(BigGLEnum::FeedbackType, type), (uintptr_t)buffer); if (context) { @@ -1471,7 +1471,7 @@ void GL_APIENTRY GL_Fogi(GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogi, "context = %d, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::FogParameter, pname), param); + GLenumToString(BigGLEnum::FogParameter, pname), param); if (context) { @@ -1494,7 +1494,7 @@ void GL_APIENTRY GL_Fogiv(GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogiv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::FogParameter, pname), (uintptr_t)params); if (context) { @@ -1576,7 +1576,7 @@ void GL_APIENTRY GL_GetClipPlane(GLenum plane, GLdouble *equation) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetClipPlane, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation); + CID(context), GLenumToString(BigGLEnum::ClipPlaneName, plane), (uintptr_t)equation); if (context) { @@ -1600,7 +1600,7 @@ void GL_APIENTRY GL_GetDoublev(GLenum pname, GLdouble *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetDoublev, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + GLenumToString(BigGLEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -1624,8 +1624,8 @@ void GL_APIENTRY GL_GetLightiv(GLenum light, GLenum pname, GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetLightiv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::LightName, light), + GLenumToString(BigGLEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -1649,8 +1649,8 @@ void GL_APIENTRY GL_GetMapdv(GLenum target, GLenum query, GLdouble *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetMapdv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v); if (context) { @@ -1674,8 +1674,8 @@ void GL_APIENTRY GL_GetMapfv(GLenum target, GLenum query, GLfloat *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetMapfv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v); if (context) { @@ -1699,8 +1699,8 @@ void GL_APIENTRY GL_GetMapiv(GLenum target, GLenum query, GLint *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetMapiv, "context = %d, target = %s, query = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::GetMapQuery, query), (uintptr_t)v); if (context) { @@ -1725,8 +1725,8 @@ void GL_APIENTRY GL_GetMaterialiv(GLenum face, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetMaterialiv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::MaterialFace, face), + GLenumToString(BigGLEnum::MaterialParameter, pname), (uintptr_t)params); if (context) { @@ -1750,7 +1750,7 @@ void GL_APIENTRY GL_GetPixelMapfv(GLenum map, GLfloat *values) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetPixelMapfv, "context = %d, map = %s, values = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values); if (context) { @@ -1774,7 +1774,7 @@ void GL_APIENTRY GL_GetPixelMapuiv(GLenum map, GLuint *values) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetPixelMapuiv, "context = %d, map = %s, values = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values); if (context) { @@ -1798,7 +1798,7 @@ void GL_APIENTRY GL_GetPixelMapusv(GLenum map, GLushort *values) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetPixelMapusv, "context = %d, map = %s, values = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::PixelMap, map), (uintptr_t)values); if (context) { @@ -1847,8 +1847,8 @@ void GL_APIENTRY GL_GetTexGendv(GLenum coord, GLenum pname, GLdouble *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGendv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -1873,8 +1873,8 @@ void GL_APIENTRY GL_GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGenfv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -1899,8 +1899,8 @@ void GL_APIENTRY GL_GetTexGeniv(GLenum coord, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGeniv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -1927,9 +1927,9 @@ GL_GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pix EVENT(context, GLGetTexImage, "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -2204,7 +2204,7 @@ void GL_APIENTRY GL_LightModeli(GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModeli, "context = %d, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::LightModelParameter, pname), param); + GLenumToString(BigGLEnum::LightModelParameter, pname), param); if (context) { @@ -2228,7 +2228,7 @@ void GL_APIENTRY GL_LightModeliv(GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModeliv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::LightModelParameter, pname), (uintptr_t)params); if (context) { @@ -2252,8 +2252,8 @@ void GL_APIENTRY GL_Lighti(GLenum light, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLighti, "context = %d, light = %s, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), param); + GLenumToString(BigGLEnum::LightName, light), + GLenumToString(BigGLEnum::LightParameter, pname), param); if (context) { @@ -2277,8 +2277,8 @@ void GL_APIENTRY GL_Lightiv(GLenum light, GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightiv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::LightName, light), + GLenumToString(BigGLEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -2396,7 +2396,7 @@ GL_Map1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, con EVENT(context, GLMap1d, "context = %d, target = %s, u1 = %f, u2 = %f, stride = %d, order = %d, points = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), u1, u2, stride, order, + CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, stride, order, (uintptr_t)points); if (context) @@ -2424,7 +2424,7 @@ GL_Map1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const EVENT(context, GLMap1f, "context = %d, target = %s, u1 = %f, u2 = %f, stride = %d, order = %d, points = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), u1, u2, stride, order, + CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, stride, order, (uintptr_t)points); if (context) @@ -2460,7 +2460,7 @@ void GL_APIENTRY GL_Map2d(GLenum target, EVENT(context, GLMap2d, "context = %d, target = %s, u1 = %f, u2 = %f, ustride = %d, uorder = %d, v1 = %f, v2 = " "%f, vstride = %d, vorder = %d, points = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), u1, u2, ustride, uorder, v1, + CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, (uintptr_t)points); if (context) @@ -2497,7 +2497,7 @@ void GL_APIENTRY GL_Map2f(GLenum target, EVENT(context, GLMap2f, "context = %d, target = %s, u1 = %f, u2 = %f, ustride = %d, uorder = %d, v1 = %f, v2 = " "%f, vstride = %d, vorder = %d, points = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), u1, u2, ustride, uorder, v1, + CID(context), GLenumToString(BigGLEnum::MapTarget, target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, (uintptr_t)points); if (context) @@ -2620,8 +2620,8 @@ void GL_APIENTRY GL_Materiali(GLenum face, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLMateriali, "context = %d, face = %s, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), param); + GLenumToString(BigGLEnum::MaterialFace, face), + GLenumToString(BigGLEnum::MaterialParameter, pname), param); if (context) { @@ -2645,8 +2645,8 @@ void GL_APIENTRY GL_Materialiv(GLenum face, GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLMaterialiv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::MaterialFace, face), + GLenumToString(BigGLEnum::MaterialParameter, pname), (uintptr_t)params); if (context) { @@ -2693,7 +2693,7 @@ void GL_APIENTRY GL_NewList(GLuint list, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLNewList, "context = %d, list = %u, mode = %s", CID(context), list, - GLenumToString(GLenumGroup::ListMode, mode)); + GLenumToString(BigGLEnum::ListMode, mode)); if (context) { @@ -2966,7 +2966,7 @@ void GL_APIENTRY GL_PixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *value { Context *context = GetValidGlobalContext(); EVENT(context, GLPixelMapfv, "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values); if (context) { @@ -2991,7 +2991,7 @@ void GL_APIENTRY GL_PixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *value Context *context = GetValidGlobalContext(); EVENT(context, GLPixelMapuiv, "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values); + GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values); if (context) { @@ -3016,7 +3016,7 @@ void GL_APIENTRY GL_PixelMapusv(GLenum map, GLsizei mapsize, const GLushort *val Context *context = GetValidGlobalContext(); EVENT(context, GLPixelMapusv, "context = %d, map = %s, mapsize = %d, values = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PixelMap, map), mapsize, (uintptr_t)values); + GLenumToString(BigGLEnum::PixelMap, map), mapsize, (uintptr_t)values); if (context) { @@ -3040,7 +3040,7 @@ void GL_APIENTRY GL_PixelStoref(GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPixelStoref, "context = %d, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::PixelStoreParameter, pname), param); + GLenumToString(BigGLEnum::PixelStoreParameter, pname), param); if (context) { @@ -3064,7 +3064,7 @@ void GL_APIENTRY GL_PixelTransferf(GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPixelTransferf, "context = %d, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::PixelTransferParameter, pname), param); + GLenumToString(BigGLEnum::PixelTransferParameter, pname), param); if (context) { @@ -3088,7 +3088,7 @@ void GL_APIENTRY GL_PixelTransferi(GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPixelTransferi, "context = %d, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::PixelTransferParameter, pname), param); + GLenumToString(BigGLEnum::PixelTransferParameter, pname), param); if (context) { @@ -3136,8 +3136,8 @@ void GL_APIENTRY GL_PolygonMode(GLenum face, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLPolygonMode, "context = %d, face = %s, mode = %s", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::PolygonMode, mode)); + GLenumToString(BigGLEnum::MaterialFace, face), + GLenumToString(BigGLEnum::PolygonMode, mode)); if (context) { @@ -3229,7 +3229,7 @@ void GL_APIENTRY GL_PushAttrib(GLbitfield mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLPushAttrib, "context = %d, mask = %s", CID(context), - GLbitfieldToString(GLenumGroup::AttribMask, mask).c_str()); + GLbitfieldToString(BigGLEnum::AttribMask, mask).c_str()); if (context) { @@ -4010,7 +4010,7 @@ GLint GL_APIENTRY GL_RenderMode(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLRenderMode, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::RenderingMode, mode)); + GLenumToString(BigGLEnum::RenderingMode, mode)); GLint returnValue; if (context) @@ -4837,8 +4837,8 @@ void GL_APIENTRY GL_TexGend(GLenum coord, GLenum pname, GLdouble param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGend, "context = %d, coord = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), param); if (context) { @@ -4862,8 +4862,8 @@ void GL_APIENTRY GL_TexGendv(GLenum coord, GLenum pname, const GLdouble *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGendv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -4887,8 +4887,8 @@ void GL_APIENTRY GL_TexGenf(GLenum coord, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenf, "context = %d, coord = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), param); if (context) { @@ -4912,8 +4912,8 @@ void GL_APIENTRY GL_TexGenfv(GLenum coord, GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenfv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -4937,8 +4937,8 @@ void GL_APIENTRY GL_TexGeni(GLenum coord, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGeni, "context = %d, coord = %s, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), param); if (context) { @@ -4962,8 +4962,8 @@ void GL_APIENTRY GL_TexGeniv(GLenum coord, GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGeniv, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::TextureCoordName, coord), + GLenumToString(BigGLEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -4996,9 +4996,9 @@ void GL_APIENTRY GL_TexImage1D(GLenum target, EVENT(context, GLTexImage1D, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, border = %d, " "format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, - width, border, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, internalformat, + width, border, GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -5646,8 +5646,8 @@ void GL_APIENTRY GL_CopyTexImage1D(GLenum target, EVENT(context, GLCopyTexImage1D, "context = %d, target = %s, level = %d, internalformat = %s, x = %d, y = %d, width = %d, " "border = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), x, y, width, border); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, + GLenumToString(BigGLEnum::InternalFormat, internalformat), x, y, width, border); if (context) { @@ -5675,7 +5675,7 @@ GL_CopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y Context *context = GetValidGlobalContext(); EVENT(context, GLCopyTexSubImage1D, "context = %d, target = %s, level = %d, xoffset = %d, x = %d, y = %d, width = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, x, y, + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, x, y, width); if (context) @@ -5727,7 +5727,7 @@ void GL_APIENTRY GL_IndexPointer(GLenum type, GLsizei stride, const void *pointe Context *context = GetValidGlobalContext(); EVENT(context, GLIndexPointer, "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::IndexPointerType, type), stride, (uintptr_t)pointer); + GLenumToString(BigGLEnum::IndexPointerType, type), stride, (uintptr_t)pointer); if (context) { @@ -5796,7 +5796,7 @@ void GL_APIENTRY GL_InterleavedArrays(GLenum format, GLsizei stride, const void Context *context = GetValidGlobalContext(); EVENT(context, GLInterleavedArrays, "context = %d, format = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::InterleavedArrayFormat, format), stride, (uintptr_t)pointer); + GLenumToString(BigGLEnum::InterleavedArrayFormat, format), stride, (uintptr_t)pointer); if (context) { @@ -5869,7 +5869,7 @@ void GL_APIENTRY GL_PushClientAttrib(GLbitfield mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLPushClientAttrib, "context = %d, mask = %s", CID(context), - GLbitfieldToString(GLenumGroup::ClientAttribMask, mask).c_str()); + GLbitfieldToString(BigGLEnum::ClientAttribMask, mask).c_str()); if (context) { @@ -5901,9 +5901,9 @@ void GL_APIENTRY GL_TexSubImage1D(GLenum target, EVENT(context, GLTexSubImage1D, "context = %d, target = %s, level = %d, xoffset = %d, width = %d, format = %s, type = " "%s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, width, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, width, + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -5940,8 +5940,8 @@ void GL_APIENTRY GL_CompressedTexImage1D(GLenum target, EVENT(context, GLCompressedTexImage1D, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, border = %d, " "imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, border, imageSize, + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, + GLenumToString(BigGLEnum::InternalFormat, internalformat), width, border, imageSize, (uintptr_t)data); if (context) @@ -5977,8 +5977,8 @@ void GL_APIENTRY GL_CompressedTexSubImage1D(GLenum target, EVENT(context, GLCompressedTexSubImage1D, "context = %d, target = %s, level = %d, xoffset = %d, width = %d, format = %s, imageSize " "= %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, width, - GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, xoffset, width, + GLenumToString(BigGLEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) { @@ -6006,7 +6006,7 @@ void GL_APIENTRY GL_GetCompressedTexImage(GLenum target, GLint level, void *img) Context *context = GetValidGlobalContext(); EVENT(context, GLGetCompressedTexImage, "context = %d, target = %s, level = %d, img = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), level, (uintptr_t)img); + GLenumToString(BigGLEnum::TextureTarget, target), level, (uintptr_t)img); if (context) { @@ -6128,7 +6128,7 @@ void GL_APIENTRY GL_MultiTexCoord1d(GLenum target, GLdouble s) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1d, "context = %d, target = %s, s = %f", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s); + GLenumToString(BigGLEnum::TextureUnit, target), s); if (context) { @@ -6152,7 +6152,7 @@ void GL_APIENTRY GL_MultiTexCoord1dv(GLenum target, const GLdouble *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6176,7 +6176,7 @@ void GL_APIENTRY GL_MultiTexCoord1f(GLenum target, GLfloat s) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1f, "context = %d, target = %s, s = %f", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s); + GLenumToString(BigGLEnum::TextureUnit, target), s); if (context) { @@ -6200,7 +6200,7 @@ void GL_APIENTRY GL_MultiTexCoord1fv(GLenum target, const GLfloat *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6224,7 +6224,7 @@ void GL_APIENTRY GL_MultiTexCoord1i(GLenum target, GLint s) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1i, "context = %d, target = %s, s = %d", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s); + GLenumToString(BigGLEnum::TextureUnit, target), s); if (context) { @@ -6248,7 +6248,7 @@ void GL_APIENTRY GL_MultiTexCoord1iv(GLenum target, const GLint *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6272,7 +6272,7 @@ void GL_APIENTRY GL_MultiTexCoord1s(GLenum target, GLshort s) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1s, "context = %d, target = %s, s = %d", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s); + GLenumToString(BigGLEnum::TextureUnit, target), s); if (context) { @@ -6296,7 +6296,7 @@ void GL_APIENTRY GL_MultiTexCoord1sv(GLenum target, const GLshort *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord1sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6320,7 +6320,7 @@ void GL_APIENTRY GL_MultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2d, "context = %d, target = %s, s = %f, t = %f", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s, t); + GLenumToString(BigGLEnum::TextureUnit, target), s, t); if (context) { @@ -6344,7 +6344,7 @@ void GL_APIENTRY GL_MultiTexCoord2dv(GLenum target, const GLdouble *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6368,7 +6368,7 @@ void GL_APIENTRY GL_MultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2f, "context = %d, target = %s, s = %f, t = %f", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s, t); + GLenumToString(BigGLEnum::TextureUnit, target), s, t); if (context) { @@ -6392,7 +6392,7 @@ void GL_APIENTRY GL_MultiTexCoord2fv(GLenum target, const GLfloat *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6416,7 +6416,7 @@ void GL_APIENTRY GL_MultiTexCoord2i(GLenum target, GLint s, GLint t) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2i, "context = %d, target = %s, s = %d, t = %d", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s, t); + GLenumToString(BigGLEnum::TextureUnit, target), s, t); if (context) { @@ -6440,7 +6440,7 @@ void GL_APIENTRY GL_MultiTexCoord2iv(GLenum target, const GLint *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6464,7 +6464,7 @@ void GL_APIENTRY GL_MultiTexCoord2s(GLenum target, GLshort s, GLshort t) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2s, "context = %d, target = %s, s = %d, t = %d", CID(context), - GLenumToString(GLenumGroup::TextureUnit, target), s, t); + GLenumToString(BigGLEnum::TextureUnit, target), s, t); if (context) { @@ -6488,7 +6488,7 @@ void GL_APIENTRY GL_MultiTexCoord2sv(GLenum target, const GLshort *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord2sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6512,7 +6512,7 @@ void GL_APIENTRY GL_MultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdou { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3d, "context = %d, target = %s, s = %f, t = %f, r = %f", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r); if (context) { @@ -6536,7 +6536,7 @@ void GL_APIENTRY GL_MultiTexCoord3dv(GLenum target, const GLdouble *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6560,7 +6560,7 @@ void GL_APIENTRY GL_MultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3f, "context = %d, target = %s, s = %f, t = %f, r = %f", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r); if (context) { @@ -6584,7 +6584,7 @@ void GL_APIENTRY GL_MultiTexCoord3fv(GLenum target, const GLfloat *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6608,7 +6608,7 @@ void GL_APIENTRY GL_MultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3i, "context = %d, target = %s, s = %d, t = %d, r = %d", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r); if (context) { @@ -6632,7 +6632,7 @@ void GL_APIENTRY GL_MultiTexCoord3iv(GLenum target, const GLint *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6656,7 +6656,7 @@ void GL_APIENTRY GL_MultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3s, "context = %d, target = %s, s = %d, t = %d, r = %d", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r); if (context) { @@ -6680,7 +6680,7 @@ void GL_APIENTRY GL_MultiTexCoord3sv(GLenum target, const GLshort *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord3sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6704,7 +6704,7 @@ void GL_APIENTRY GL_MultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdou { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4d, "context = %d, target = %s, s = %f, t = %f, r = %f, q = %f", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q); if (context) { @@ -6728,7 +6728,7 @@ void GL_APIENTRY GL_MultiTexCoord4dv(GLenum target, const GLdouble *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4dv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6752,7 +6752,7 @@ void GL_APIENTRY GL_MultiTexCoord4fv(GLenum target, const GLfloat *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4fv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6776,7 +6776,7 @@ void GL_APIENTRY GL_MultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GL { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4i, "context = %d, target = %s, s = %d, t = %d, r = %d, q = %d", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q); if (context) { @@ -6800,7 +6800,7 @@ void GL_APIENTRY GL_MultiTexCoord4iv(GLenum target, const GLint *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4iv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6824,7 +6824,7 @@ void GL_APIENTRY GL_MultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4s, "context = %d, target = %s, s = %d, t = %d, r = %d, q = %d", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), s, t, r, q); if (context) { @@ -6848,7 +6848,7 @@ void GL_APIENTRY GL_MultiTexCoord4sv(GLenum target, const GLshort *v) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4sv, "context = %d, target = %s, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::TextureUnit, target), (uintptr_t)v); if (context) { @@ -6874,7 +6874,7 @@ void GL_APIENTRY GL_FogCoordPointer(GLenum type, GLsizei stride, const void *poi Context *context = GetValidGlobalContext(); EVENT(context, GLFogCoordPointer, "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FogPointerTypeEXT, type), stride, (uintptr_t)pointer); + GLenumToString(BigGLEnum::FogPointerTypeEXT, type), stride, (uintptr_t)pointer); if (context) { @@ -6993,7 +6993,7 @@ void GL_APIENTRY GL_MultiDrawArrays(GLenum mode, EVENT(context, GLMultiDrawArrays, "context = %d, mode = %s, first = 0x%016" PRIxPTR ", count = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)first, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)first, (uintptr_t)count, drawcount); if (context) @@ -7026,8 +7026,8 @@ void GL_APIENTRY GL_MultiDrawElements(GLenum mode, EVENT(context, GLMultiDrawElements, "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount); + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)count, + GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, drawcount); if (context) { @@ -7055,7 +7055,7 @@ void GL_APIENTRY GL_PointParameteri(GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameteri, "context = %d, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, pname), param); + GLenumToString(BigGLEnum::AllEnums, pname), param); if (context) { @@ -7079,7 +7079,7 @@ void GL_APIENTRY GL_PointParameteriv(GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameteriv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -7491,7 +7491,7 @@ void GL_APIENTRY GL_SecondaryColorPointer(GLint size, Context *context = GetValidGlobalContext(); EVENT(context, GLSecondaryColorPointer, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::ColorPointerType, type), stride, + CID(context), size, GLenumToString(BigGLEnum::ColorPointerType, type), stride, (uintptr_t)pointer); if (context) @@ -7883,7 +7883,7 @@ void GL_APIENTRY GL_GetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr Context *context = GetValidGlobalContext(); EVENT(context, GLGetBufferSubData, "context = %d, target = %s, offset = %llu, size = %llu, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), + CID(context), GLenumToString(BigGLEnum::BufferTargetARB, target), static_cast(offset), static_cast(size), (uintptr_t)data); @@ -7910,7 +7910,7 @@ void GL_APIENTRY GL_GetQueryObjectiv(GLuint id, GLenum pname, GLint *params) Context *context = GetGlobalContext(); EVENT(context, GLGetQueryObjectiv, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -7933,8 +7933,8 @@ void *GL_APIENTRY GL_MapBuffer(GLenum target, GLenum access) { Context *context = GetValidGlobalContext(); EVENT(context, GLMapBuffer, "context = %d, target = %s, access = %s", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::BufferAccessARB, access)); + GLenumToString(BigGLEnum::BufferTargetARB, target), + GLenumToString(BigGLEnum::BufferAccessARB, access)); void *returnValue; if (context) diff --git a/src/libGLESv2/entry_points_gl_2_autogen.cpp b/src/libGLESv2/entry_points_gl_2_autogen.cpp index 11c879b69..4493fa44f 100644 --- a/src/libGLESv2/entry_points_gl_2_autogen.cpp +++ b/src/libGLESv2/entry_points_gl_2_autogen.cpp @@ -36,7 +36,7 @@ void GL_APIENTRY GL_GetVertexAttribdv(GLuint index, GLenum pname, GLdouble *para Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribdv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params); if (context) { diff --git a/src/libGLESv2/entry_points_gl_3_autogen.cpp b/src/libGLESv2/entry_points_gl_3_autogen.cpp index d0f60f156..923b469cd 100644 --- a/src/libGLESv2/entry_points_gl_3_autogen.cpp +++ b/src/libGLESv2/entry_points_gl_3_autogen.cpp @@ -35,7 +35,7 @@ void GL_APIENTRY GL_BeginConditionalRender(GLuint id, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBeginConditionalRender, "context = %d, id = %u, mode = %s", CID(context), id, - GLenumToString(GLenumGroup::TypeEnum, mode)); + GLenumToString(BigGLEnum::ConditionalRenderMode, mode)); if (context) { @@ -86,8 +86,7 @@ void GL_APIENTRY GL_ClampColor(GLenum target, GLenum clamp) { Context *context = GetValidGlobalContext(); EVENT(context, GLClampColor, "context = %d, target = %s, clamp = %s", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, clamp)); + GLenumToString(BigGLEnum::AllEnums, target), GLenumToString(BigGLEnum::AllEnums, clamp)); if (context) { @@ -139,9 +138,9 @@ void GL_APIENTRY GL_FramebufferTexture1D(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTexture1D, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level); + CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target), + GLenumToString(BigGLEnum::FramebufferAttachment, attachment), + GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level); if (context) { @@ -177,9 +176,9 @@ void GL_APIENTRY GL_FramebufferTexture3D(GLenum target, EVENT(context, GLFramebufferTexture3D, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, " "zoffset = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset); + CID(context), GLenumToString(BigGLEnum::FramebufferTarget, target), + GLenumToString(BigGLEnum::FramebufferAttachment, attachment), + GLenumToString(BigGLEnum::TextureTarget, textarget), texture, level, zoffset); if (context) { @@ -656,8 +655,8 @@ void GL_APIENTRY GL_MultiDrawElementsBaseVertex(GLenum mode, EVENT(context, GLMultiDrawElementsBaseVertex, "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR ", drawcount = %d, basevertex = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)count, + GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, drawcount, (uintptr_t)basevertex); if (context) @@ -687,7 +686,7 @@ void GL_APIENTRY GL_ProvokingVertex(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLProvokingVertex, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::VertexProvokingMode, mode)); + GLenumToString(BigGLEnum::VertexProvokingMode, mode)); if (context) { @@ -719,8 +718,8 @@ void GL_APIENTRY GL_TexImage2DMultisample(GLenum target, EVENT(context, GLTexImage2DMultisample, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples, + GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height, GLbooleanToString(fixedsamplelocations)); if (context) @@ -756,8 +755,8 @@ void GL_APIENTRY GL_TexImage3DMultisample(GLenum target, EVENT(context, GLTexImage3DMultisample, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), samples, + GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height, depth, GLbooleanToString(fixedsamplelocations)); if (context) @@ -818,7 +817,7 @@ void GL_APIENTRY GL_ColorP3ui(GLenum type, GLuint color) { Context *context = GetValidGlobalContext(); EVENT(context, GLColorP3ui, "context = %d, type = %s, color = %u", CID(context), - GLenumToString(GLenumGroup::ColorPointerType, type), color); + GLenumToString(BigGLEnum::ColorPointerType, type), color); if (context) { @@ -842,7 +841,7 @@ void GL_APIENTRY GL_ColorP3uiv(GLenum type, const GLuint *color) { Context *context = GetValidGlobalContext(); EVENT(context, GLColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color); + GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color); if (context) { @@ -866,7 +865,7 @@ void GL_APIENTRY GL_ColorP4ui(GLenum type, GLuint color) { Context *context = GetValidGlobalContext(); EVENT(context, GLColorP4ui, "context = %d, type = %s, color = %u", CID(context), - GLenumToString(GLenumGroup::ColorPointerType, type), color); + GLenumToString(BigGLEnum::ColorPointerType, type), color); if (context) { @@ -890,7 +889,7 @@ void GL_APIENTRY GL_ColorP4uiv(GLenum type, const GLuint *color) { Context *context = GetValidGlobalContext(); EVENT(context, GLColorP4uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color); + GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color); if (context) { @@ -947,7 +946,7 @@ void GL_APIENTRY GL_GetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params) Context *context = GetGlobalContext(); EVENT(context, GLGetQueryObjecti64v, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -972,7 +971,7 @@ void GL_APIENTRY GL_GetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *param Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryObjectui64v, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -998,8 +997,8 @@ void GL_APIENTRY GL_MultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP1ui, "context = %d, texture = %s, type = %s, coords = %u", - CID(context), GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + CID(context), GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1025,8 +1024,8 @@ void GL_APIENTRY GL_MultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP1uiv, "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1051,8 +1050,8 @@ void GL_APIENTRY GL_MultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP2ui, "context = %d, texture = %s, type = %s, coords = %u", - CID(context), GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + CID(context), GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1078,8 +1077,8 @@ void GL_APIENTRY GL_MultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP2uiv, "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1104,8 +1103,8 @@ void GL_APIENTRY GL_MultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP3ui, "context = %d, texture = %s, type = %s, coords = %u", - CID(context), GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + CID(context), GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1131,8 +1130,8 @@ void GL_APIENTRY GL_MultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP3uiv, "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1157,8 +1156,8 @@ void GL_APIENTRY GL_MultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP4ui, "context = %d, texture = %s, type = %s, coords = %u", - CID(context), GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + CID(context), GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1184,8 +1183,8 @@ void GL_APIENTRY GL_MultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoordP4uiv, "context = %d, texture = %s, type = %s, coords = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture), - GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + GLenumToString(BigGLEnum::TextureUnit, texture), + GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1210,7 +1209,7 @@ void GL_APIENTRY GL_NormalP3ui(GLenum type, GLuint coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLNormalP3ui, "context = %d, type = %s, coords = %u", CID(context), - GLenumToString(GLenumGroup::NormalPointerType, type), coords); + GLenumToString(BigGLEnum::NormalPointerType, type), coords); if (context) { @@ -1234,7 +1233,7 @@ void GL_APIENTRY GL_NormalP3uiv(GLenum type, const GLuint *coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLNormalP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::NormalPointerType, type), (uintptr_t)coords); + CID(context), GLenumToString(BigGLEnum::NormalPointerType, type), (uintptr_t)coords); if (context) { @@ -1258,7 +1257,7 @@ void GL_APIENTRY GL_QueryCounter(GLuint id, GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLQueryCounter, "context = %d, id = %u, target = %s", CID(context), id, - GLenumToString(GLenumGroup::QueryTarget, target)); + GLenumToString(BigGLEnum::QueryCounterTarget, target)); if (context) { @@ -1284,7 +1283,7 @@ void GL_APIENTRY GL_SecondaryColorP3ui(GLenum type, GLuint color) { Context *context = GetValidGlobalContext(); EVENT(context, GLSecondaryColorP3ui, "context = %d, type = %s, color = %u", CID(context), - GLenumToString(GLenumGroup::ColorPointerType, type), color); + GLenumToString(BigGLEnum::ColorPointerType, type), color); if (context) { @@ -1308,7 +1307,7 @@ void GL_APIENTRY GL_SecondaryColorP3uiv(GLenum type, const GLuint *color) { Context *context = GetValidGlobalContext(); EVENT(context, GLSecondaryColorP3uiv, "context = %d, type = %s, color = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ColorPointerType, type), (uintptr_t)color); + CID(context), GLenumToString(BigGLEnum::ColorPointerType, type), (uintptr_t)color); if (context) { @@ -1332,7 +1331,7 @@ void GL_APIENTRY GL_TexCoordP1ui(GLenum type, GLuint coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP1ui, "context = %d, type = %s, coords = %u", CID(context), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1356,7 +1355,7 @@ void GL_APIENTRY GL_TexCoordP1uiv(GLenum type, const GLuint *coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP1uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1380,7 +1379,7 @@ void GL_APIENTRY GL_TexCoordP2ui(GLenum type, GLuint coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP2ui, "context = %d, type = %s, coords = %u", CID(context), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1404,7 +1403,7 @@ void GL_APIENTRY GL_TexCoordP2uiv(GLenum type, const GLuint *coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP2uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1428,7 +1427,7 @@ void GL_APIENTRY GL_TexCoordP3ui(GLenum type, GLuint coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP3ui, "context = %d, type = %s, coords = %u", CID(context), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1452,7 +1451,7 @@ void GL_APIENTRY GL_TexCoordP3uiv(GLenum type, const GLuint *coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP3uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1476,7 +1475,7 @@ void GL_APIENTRY GL_TexCoordP4ui(GLenum type, GLuint coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP4ui, "context = %d, type = %s, coords = %u", CID(context), - GLenumToString(GLenumGroup::TexCoordPointerType, type), coords); + GLenumToString(BigGLEnum::TexCoordPointerType, type), coords); if (context) { @@ -1500,7 +1499,7 @@ void GL_APIENTRY GL_TexCoordP4uiv(GLenum type, const GLuint *coords) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordP4uiv, "context = %d, type = %s, coords = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TexCoordPointerType, type), (uintptr_t)coords); + CID(context), GLenumToString(BigGLEnum::TexCoordPointerType, type), (uintptr_t)coords); if (context) { @@ -1525,7 +1524,7 @@ void GL_APIENTRY GL_VertexAttribP1ui(GLuint index, GLenum type, GLboolean normal Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP1ui, "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribPointerType, type), GLbooleanToString(normalized), + GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), value); if (context) @@ -1554,7 +1553,7 @@ void GL_APIENTRY GL_VertexAttribP1uiv(GLuint index, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP1uiv, "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type), + CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), (uintptr_t)value); if (context) @@ -1581,7 +1580,7 @@ void GL_APIENTRY GL_VertexAttribP2ui(GLuint index, GLenum type, GLboolean normal Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP2ui, "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribPointerType, type), GLbooleanToString(normalized), + GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), value); if (context) @@ -1610,7 +1609,7 @@ void GL_APIENTRY GL_VertexAttribP2uiv(GLuint index, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP2uiv, "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type), + CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), (uintptr_t)value); if (context) @@ -1637,7 +1636,7 @@ void GL_APIENTRY GL_VertexAttribP3ui(GLuint index, GLenum type, GLboolean normal Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP3ui, "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribPointerType, type), GLbooleanToString(normalized), + GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), value); if (context) @@ -1666,7 +1665,7 @@ void GL_APIENTRY GL_VertexAttribP3uiv(GLuint index, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP3uiv, "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type), + CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), (uintptr_t)value); if (context) @@ -1693,7 +1692,7 @@ void GL_APIENTRY GL_VertexAttribP4ui(GLuint index, GLenum type, GLboolean normal Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP4ui, "context = %d, index = %u, type = %s, normalized = %s, value = %u", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribPointerType, type), GLbooleanToString(normalized), + GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), value); if (context) @@ -1722,7 +1721,7 @@ void GL_APIENTRY GL_VertexAttribP4uiv(GLuint index, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribP4uiv, "context = %d, index = %u, type = %s, normalized = %s, value = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::VertexAttribPointerType, type), + CID(context), index, GLenumToString(BigGLEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), (uintptr_t)value); if (context) @@ -1748,7 +1747,7 @@ void GL_APIENTRY GL_VertexP2ui(GLenum type, GLuint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP2ui, "context = %d, type = %s, value = %u", CID(context), - GLenumToString(GLenumGroup::VertexPointerType, type), value); + GLenumToString(BigGLEnum::VertexPointerType, type), value); if (context) { @@ -1772,7 +1771,7 @@ void GL_APIENTRY GL_VertexP2uiv(GLenum type, const GLuint *value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP2uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value); + CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value); if (context) { @@ -1796,7 +1795,7 @@ void GL_APIENTRY GL_VertexP3ui(GLenum type, GLuint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP3ui, "context = %d, type = %s, value = %u", CID(context), - GLenumToString(GLenumGroup::VertexPointerType, type), value); + GLenumToString(BigGLEnum::VertexPointerType, type), value); if (context) { @@ -1820,7 +1819,7 @@ void GL_APIENTRY GL_VertexP3uiv(GLenum type, const GLuint *value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP3uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value); + CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value); if (context) { @@ -1844,7 +1843,7 @@ void GL_APIENTRY GL_VertexP4ui(GLenum type, GLuint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP4ui, "context = %d, type = %s, value = %u", CID(context), - GLenumToString(GLenumGroup::VertexPointerType, type), value); + GLenumToString(BigGLEnum::VertexPointerType, type), value); if (context) { @@ -1868,7 +1867,7 @@ void GL_APIENTRY GL_VertexP4uiv(GLenum type, const GLuint *value) { Context *context = GetValidGlobalContext(); EVENT(context, GLVertexP4uiv, "context = %d, type = %s, value = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::VertexPointerType, type), (uintptr_t)value); + CID(context), GLenumToString(BigGLEnum::VertexPointerType, type), (uintptr_t)value); if (context) { diff --git a/src/libGLESv2/entry_points_gl_4_autogen.cpp b/src/libGLESv2/entry_points_gl_4_autogen.cpp index 05130b7d0..f338575e5 100644 --- a/src/libGLESv2/entry_points_gl_4_autogen.cpp +++ b/src/libGLESv2/entry_points_gl_4_autogen.cpp @@ -35,7 +35,7 @@ void GL_APIENTRY GL_BeginQueryIndexed(GLenum target, GLuint index, GLuint id) { Context *context = GetValidGlobalContext(); EVENT(context, GLBeginQueryIndexed, "context = %d, target = %s, index = %u, id = %u", - CID(context), GLenumToString(GLenumGroup::QueryTarget, target), index, id); + CID(context), GLenumToString(BigGLEnum::QueryTarget, target), index, id); if (context) { @@ -61,7 +61,7 @@ void GL_APIENTRY GL_DrawTransformFeedback(GLenum mode, GLuint id) { Context *context = GetValidGlobalContext(); EVENT(context, GLDrawTransformFeedback, "context = %d, mode = %s, id = %u", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), id); + GLenumToString(BigGLEnum::PrimitiveType, mode), id); if (context) { @@ -87,7 +87,7 @@ void GL_APIENTRY GL_DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint s { Context *context = GetValidGlobalContext(); EVENT(context, GLDrawTransformFeedbackStream, "context = %d, mode = %s, id = %u, stream = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), id, stream); + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), id, stream); if (context) { @@ -113,7 +113,7 @@ void GL_APIENTRY GL_EndQueryIndexed(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLEndQueryIndexed, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target), index); + GLenumToString(BigGLEnum::QueryTarget, target), index); if (context) { @@ -136,16 +136,16 @@ void GL_APIENTRY GL_EndQueryIndexed(GLenum target, GLuint index) void GL_APIENTRY GL_GetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetActiveSubroutineName, - "context = %d, program = %u, shadertype = %s, index = %u, bufsize = %d, length = " + "context = %d, program = %u, shadertype = %s, index = %u, bufSize = %d, length = " "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index, - bufsize, (uintptr_t)length, (uintptr_t)name); + CID(context), program, GLenumToString(BigGLEnum::ShaderType, shadertype), index, bufSize, + (uintptr_t)length, (uintptr_t)name); if (context) { @@ -154,14 +154,14 @@ void GL_APIENTRY GL_GetActiveSubroutineName(GLuint program, bool isCallValid = (context->skipValidation() || ValidateGetActiveSubroutineName( context, angle::EntryPoint::GLGetActiveSubroutineName, - programPacked, shadertype, index, bufsize, length, name)); + programPacked, shadertype, index, bufSize, length, name)); if (isCallValid) { - context->getActiveSubroutineName(programPacked, shadertype, index, bufsize, length, + context->getActiveSubroutineName(programPacked, shadertype, index, bufSize, length, name); } ANGLE_CAPTURE_GL(GetActiveSubroutineName, isCallValid, context, programPacked, shadertype, - index, bufsize, length, name); + index, bufSize, length, name); } else { @@ -172,16 +172,16 @@ void GL_APIENTRY GL_GetActiveSubroutineName(GLuint program, void GL_APIENTRY GL_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetActiveSubroutineUniformName, - "context = %d, program = %u, shadertype = %s, index = %u, bufsize = %d, length = " + "context = %d, program = %u, shadertype = %s, index = %u, bufSize = %d, length = " "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index, - bufsize, (uintptr_t)length, (uintptr_t)name); + CID(context), program, GLenumToString(BigGLEnum::ShaderType, shadertype), index, bufSize, + (uintptr_t)length, (uintptr_t)name); if (context) { @@ -190,14 +190,14 @@ void GL_APIENTRY GL_GetActiveSubroutineUniformName(GLuint program, bool isCallValid = (context->skipValidation() || ValidateGetActiveSubroutineUniformName( context, angle::EntryPoint::GLGetActiveSubroutineUniformName, - programPacked, shadertype, index, bufsize, length, name)); + programPacked, shadertype, index, bufSize, length, name)); if (isCallValid) { - context->getActiveSubroutineUniformName(programPacked, shadertype, index, bufsize, + context->getActiveSubroutineUniformName(programPacked, shadertype, index, bufSize, length, name); } ANGLE_CAPTURE_GL(GetActiveSubroutineUniformName, isCallValid, context, programPacked, - shadertype, index, bufsize, length, name); + shadertype, index, bufSize, length, name); } else { @@ -215,8 +215,8 @@ void GL_APIENTRY GL_GetActiveSubroutineUniformiv(GLuint program, EVENT(context, GLGetActiveSubroutineUniformiv, "context = %d, program = %u, shadertype = %s, index = %u, pname = %s, values = " "0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index, - GLenumToString(GLenumGroup::SubroutineParameterName, pname), (uintptr_t)values); + CID(context), program, GLenumToString(BigGLEnum::ShaderType, shadertype), index, + GLenumToString(BigGLEnum::SubroutineParameterName, pname), (uintptr_t)values); if (context) { @@ -247,8 +247,8 @@ void GL_APIENTRY GL_GetProgramStageiv(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramStageiv, "context = %d, program = %u, shadertype = %s, pname = %s, values = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), - GLenumToString(GLenumGroup::ProgramStagePName, pname), (uintptr_t)values); + CID(context), program, GLenumToString(BigGLEnum::ShaderType, shadertype), + GLenumToString(BigGLEnum::ProgramStagePName, pname), (uintptr_t)values); if (context) { @@ -276,8 +276,8 @@ void GL_APIENTRY GL_GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryIndexediv, "context = %d, target = %s, index = %u, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, - GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::QueryTarget, target), index, + GLenumToString(BigGLEnum::QueryParameterName, pname), (uintptr_t)params); if (context) { @@ -303,7 +303,7 @@ GLuint GL_APIENTRY GL_GetSubroutineIndex(GLuint program, GLenum shadertype, cons Context *context = GetValidGlobalContext(); EVENT(context, GLGetSubroutineIndex, "context = %d, program = %u, shadertype = %s, name = 0x%016" PRIxPTR "", CID(context), - program, GLenumToString(GLenumGroup::ShaderType, shadertype), (uintptr_t)name); + program, GLenumToString(BigGLEnum::ShaderType, shadertype), (uintptr_t)name); GLuint returnValue; if (context) @@ -340,7 +340,7 @@ GLint GL_APIENTRY GL_GetSubroutineUniformLocation(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetSubroutineUniformLocation, "context = %d, program = %u, shadertype = %s, name = 0x%016" PRIxPTR "", CID(context), - program, GLenumToString(GLenumGroup::ShaderType, shadertype), (uintptr_t)name); + program, GLenumToString(BigGLEnum::ShaderType, shadertype), (uintptr_t)name); GLint returnValue; if (context) @@ -377,7 +377,7 @@ void GL_APIENTRY GL_GetUniformSubroutineuiv(GLenum shadertype, GLint location, G Context *context = GetValidGlobalContext(); EVENT(context, GLGetUniformSubroutineuiv, "context = %d, shadertype = %s, location = %d, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ShaderType, shadertype), location, (uintptr_t)params); + GLenumToString(BigGLEnum::ShaderType, shadertype), location, (uintptr_t)params); if (context) { @@ -430,7 +430,7 @@ void GL_APIENTRY GL_PatchParameterfv(GLenum pname, const GLfloat *values) { Context *context = GetValidGlobalContext(); EVENT(context, GLPatchParameterfv, "context = %d, pname = %s, values = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PatchParameterName, pname), (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::PatchParameterName, pname), (uintptr_t)values); if (context) { @@ -934,7 +934,7 @@ void GL_APIENTRY GL_UniformSubroutinesuiv(GLenum shadertype, GLsizei count, cons Context *context = GetValidGlobalContext(); EVENT(context, GLUniformSubroutinesuiv, "context = %d, shadertype = %s, count = %d, indices = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ShaderType, shadertype), count, (uintptr_t)indices); + GLenumToString(BigGLEnum::ShaderType, shadertype), count, (uintptr_t)indices); if (context) { @@ -1010,7 +1010,7 @@ void GL_APIENTRY GL_GetDoublei_v(GLenum target, GLuint index, GLdouble *data) Context *context = GetValidGlobalContext(); EVENT(context, GLGetDoublei_v, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); + GLenumToString(BigGLEnum::GetPName, target), index, (uintptr_t)data); if (context) { @@ -1034,7 +1034,7 @@ void GL_APIENTRY GL_GetFloati_v(GLenum target, GLuint index, GLfloat *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetFloati_v, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); + CID(context), GLenumToString(BigGLEnum::GetPName, target), index, (uintptr_t)data); if (context) { @@ -1059,7 +1059,7 @@ void GL_APIENTRY GL_GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *par Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribLdv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::VertexAttribEnum, pname), (uintptr_t)params); if (context) { @@ -1912,8 +1912,8 @@ GL_VertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, c EVENT(context, GLVertexAttribLPointer, "context = %d, index = %u, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type), - stride, (uintptr_t)pointer); + CID(context), index, size, GLenumToString(BigGLEnum::VertexAttribLType, type), stride, + (uintptr_t)pointer); if (context) { @@ -2017,8 +2017,8 @@ void GL_APIENTRY GL_DrawArraysInstancedBaseInstance(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstancedBaseInstance, "context = %d, mode = %s, first = %d, count = %d, instancecount = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, - instancecount, baseinstance); + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), first, count, instancecount, + baseinstance); if (context) { @@ -2053,8 +2053,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseInstance(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseInstance, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), count, + GLenumToString(BigGLEnum::PrimitiveType, type), (uintptr_t)indices, instancecount, baseinstance); if (context) @@ -2093,8 +2093,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstance(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstance, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, basevertex = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), count, + GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, basevertex, baseinstance); if (context) @@ -2127,7 +2127,7 @@ void GL_APIENTRY GL_DrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsiz Context *context = GetValidGlobalContext(); EVENT(context, GLDrawTransformFeedbackInstanced, "context = %d, mode = %s, id = %u, instancecount = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), id, instancecount); + GLenumToString(BigGLEnum::PrimitiveType, mode), id, instancecount); if (context) { @@ -2158,7 +2158,7 @@ void GL_APIENTRY GL_DrawTransformFeedbackStreamInstanced(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawTransformFeedbackStreamInstanced, "context = %d, mode = %s, id = %u, stream = %u, instancecount = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), id, stream, instancecount); + GLenumToString(BigGLEnum::PrimitiveType, mode), id, stream, instancecount); if (context) { @@ -2190,7 +2190,7 @@ void GL_APIENTRY GL_GetActiveAtomicCounterBufferiv(GLuint program, EVENT(context, GLGetActiveAtomicCounterBufferiv, "context = %d, program = %u, bufferIndex = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), program, bufferIndex, - GLenumToString(GLenumGroup::AtomicCounterBufferPName, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::AtomicCounterBufferPName, pname), (uintptr_t)params); if (context) { @@ -2221,8 +2221,8 @@ void GL_APIENTRY GL_TexStorage1D(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexStorage1D, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width); + GLenumToString(BigGLEnum::TextureTarget, target), levels, + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width); if (context) { @@ -2253,10 +2253,10 @@ void GL_APIENTRY GL_ClearBufferData(GLenum target, EVENT(context, GLClearBufferData, "context = %d, target = %s, internalformat = %s, format = %s, type = %s, data = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + CID(context), GLenumToString(BigGLEnum::BufferStorageTarget, target), + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -2289,11 +2289,11 @@ void GL_APIENTRY GL_ClearBufferSubData(GLenum target, EVENT(context, GLClearBufferSubData, "context = %d, target = %s, internalformat = %s, offset = %llu, size = %llu, format = " "%s, type = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), + CID(context), GLenumToString(BigGLEnum::BufferTargetARB, target), + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), static_cast(offset), static_cast(size), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -2318,16 +2318,16 @@ void GL_APIENTRY GL_ClearBufferSubData(GLenum target, void GL_APIENTRY GL_GetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetInternalformati64v, - "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, params = " + "context = %d, target = %s, internalformat = %s, pname = %s, count = %d, params = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), - GLenumToString(GLenumGroup::InternalFormatPName, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), + GLenumToString(BigGLEnum::InternalFormat, internalformat), + GLenumToString(BigGLEnum::InternalFormatPName, pname), count, (uintptr_t)params); if (context) { @@ -2335,13 +2335,13 @@ void GL_APIENTRY GL_GetInternalformati64v(GLenum target, bool isCallValid = (context->skipValidation() || ValidateGetInternalformati64v(context, angle::EntryPoint::GLGetInternalformati64v, - target, internalformat, pname, bufSize, params)); + target, internalformat, pname, count, params)); if (isCallValid) { - context->getInternalformati64v(target, internalformat, pname, bufSize, params); + context->getInternalformati64v(target, internalformat, pname, count, params); } ANGLE_CAPTURE_GL(GetInternalformati64v, isCallValid, context, target, internalformat, pname, - bufSize, params); + count, params); } else { @@ -2356,7 +2356,7 @@ GLint GL_APIENTRY GL_GetProgramResourceLocationIndex(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramResourceLocationIndex, "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), + CID(context), program, GLenumToString(BigGLEnum::ProgramInterface, programInterface), (uintptr_t)name); GLint returnValue; @@ -2514,7 +2514,7 @@ void GL_APIENTRY GL_MultiDrawArraysIndirect(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLMultiDrawArraysIndirect, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)indirect, drawcount, stride); if (context) @@ -2548,8 +2548,8 @@ void GL_APIENTRY GL_MultiDrawElementsIndirect(GLenum mode, EVENT(context, GLMultiDrawElementsIndirect, "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect, drawcount, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), + GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indirect, drawcount, stride); if (context) @@ -2618,8 +2618,8 @@ void GL_APIENTRY GL_TextureView(GLuint texture, EVENT(context, GLTextureView, "context = %d, texture = %u, target = %s, origtexture = %u, internalformat = %s, " "minlevel = %u, numlevels = %u, minlayer = %u, numlayers = %u", - CID(context), texture, GLenumToString(GLenumGroup::TextureTarget, target), origtexture, - GLenumToString(GLenumGroup::InternalFormat, internalformat), minlevel, numlevels, + CID(context), texture, GLenumToString(BigGLEnum::TextureTarget, target), origtexture, + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), minlevel, numlevels, minlayer, numlayers); if (context) @@ -2652,7 +2652,7 @@ void GL_APIENTRY GL_VertexAttribLFormat(GLuint attribindex, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribLFormat, "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), - attribindex, size, GLenumToString(GLenumGroup::VertexAttribType, type), relativeoffset); + attribindex, size, GLenumToString(BigGLEnum::VertexAttribLType, type), relativeoffset); if (context) { @@ -2683,7 +2683,7 @@ void GL_APIENTRY GL_BindBuffersBase(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLBindBuffersBase, "context = %d, target = %s, first = %u, count = %d, buffers = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), first, count, + CID(context), GLenumToString(BigGLEnum::BufferTargetARB, target), first, count, (uintptr_t)buffers); if (context) @@ -2717,7 +2717,7 @@ void GL_APIENTRY GL_BindBuffersRange(GLenum target, EVENT(context, GLBindBuffersRange, "context = %d, target = %s, first = %u, count = %d, buffers = 0x%016" PRIxPTR ", offsets = 0x%016" PRIxPTR ", sizes = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), first, count, + CID(context), GLenumToString(BigGLEnum::BufferTargetARB, target), first, count, (uintptr_t)buffers, (uintptr_t)offsets, (uintptr_t)sizes); if (context) @@ -2858,9 +2858,9 @@ void GL_APIENTRY GL_BufferStorage(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLBufferStorage, "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s", - CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target), + CID(context), GLenumToString(BigGLEnum::BufferStorageTarget, target), static_cast(size), (uintptr_t)data, - GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str()); + GLbitfieldToString(BigGLEnum::BufferStorageMask, flags).c_str()); if (context) { @@ -2888,8 +2888,8 @@ GL_ClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const EVENT(context, GLClearTexImage, "context = %d, texture = %u, level = %d, format = %s, type = %s, data = 0x%016" PRIxPTR "", - CID(context), texture, level, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + CID(context), texture, level, GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -2928,8 +2928,8 @@ void GL_APIENTRY GL_ClearTexSubImage(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, type = %s, data = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, zoffset, width, height, depth, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -2999,8 +2999,8 @@ void GL_APIENTRY GL_BlitNamedFramebuffer(GLuint readFramebuffer, "context = %d, readFramebuffer = %u, drawFramebuffer = %u, srcX0 = %d, srcY0 = %d, srcX1 = " "%d, srcY1 = %d, dstX0 = %d, dstY0 = %d, dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", CID(context), readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, - dstX1, dstY1, GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(), - GLenumToString(GLenumGroup::BlitFramebufferFilter, filter)); + dstX1, dstY1, GLbitfieldToString(BigGLEnum::ClearBufferMask, mask).c_str(), + GLenumToString(BigGLEnum::BlitFramebufferFilter, filter)); if (context) { @@ -3029,7 +3029,7 @@ GLenum GL_APIENTRY GL_CheckNamedFramebufferStatus(GLuint framebuffer, GLenum tar { Context *context = GetValidGlobalContext(); EVENT(context, GLCheckNamedFramebufferStatus, "context = %d, framebuffer = %u, target = %s", - CID(context), framebuffer, GLenumToString(GLenumGroup::FramebufferTarget, target)); + CID(context), framebuffer, GLenumToString(BigGLEnum::FramebufferTarget, target)); GLenum returnValue; if (context) @@ -3071,9 +3071,9 @@ void GL_APIENTRY GL_ClearNamedBufferData(GLuint buffer, EVENT(context, GLClearNamedBufferData, "context = %d, buffer = %u, internalformat = %s, format = %s, type = %s, data = " "0x%016" PRIxPTR "", - CID(context), buffer, GLenumToString(GLenumGroup::InternalFormat, internalformat), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + CID(context), buffer, GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -3108,10 +3108,10 @@ void GL_APIENTRY GL_ClearNamedBufferSubData(GLuint buffer, EVENT(context, GLClearNamedBufferSubData, "context = %d, buffer = %u, internalformat = %s, offset = %llu, size = %llu, format = " "%s, type = %s, data = 0x%016" PRIxPTR "", - CID(context), buffer, GLenumToString(GLenumGroup::InternalFormat, internalformat), + CID(context), buffer, GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), static_cast(offset), static_cast(size), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)data); if (context) { @@ -3144,7 +3144,7 @@ void GL_APIENTRY GL_ClearNamedFramebufferfi(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLClearNamedFramebufferfi, "context = %d, framebuffer = %u, buffer = %s, drawbuffer = %d, depth = %f, stencil = %d", - CID(context), framebuffer, GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, depth, + CID(context), framebuffer, GLenumToString(BigGLEnum::Buffer, buffer), drawbuffer, depth, stencil); if (context) @@ -3176,7 +3176,7 @@ void GL_APIENTRY GL_ClearNamedFramebufferfv(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLClearNamedFramebufferfv, "context = %d, framebuffer = %u, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", - CID(context), framebuffer, GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, + CID(context), framebuffer, GLenumToString(BigGLEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) @@ -3208,7 +3208,7 @@ void GL_APIENTRY GL_ClearNamedFramebufferiv(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLClearNamedFramebufferiv, "context = %d, framebuffer = %u, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", - CID(context), framebuffer, GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, + CID(context), framebuffer, GLenumToString(BigGLEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) @@ -3240,7 +3240,7 @@ void GL_APIENTRY GL_ClearNamedFramebufferuiv(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLClearNamedFramebufferuiv, "context = %d, framebuffer = %u, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", - CID(context), framebuffer, GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, + CID(context), framebuffer, GLenumToString(BigGLEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) @@ -3268,8 +3268,8 @@ void GL_APIENTRY GL_ClipControl(GLenum origin, GLenum depth) { Context *context = GetValidGlobalContext(); EVENT(context, GLClipControl, "context = %d, origin = %s, depth = %s", CID(context), - GLenumToString(GLenumGroup::ClipControlOrigin, origin), - GLenumToString(GLenumGroup::ClipControlDepth, depth)); + GLenumToString(BigGLEnum::ClipControlOrigin, origin), + GLenumToString(BigGLEnum::ClipControlDepth, depth)); if (context) { @@ -3302,7 +3302,7 @@ void GL_APIENTRY GL_CompressedTextureSubImage1D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, width = %d, format = %s, " "imageSize = %d, data = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, width, - GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data); + GLenumToString(BigGLEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) { @@ -3341,7 +3341,7 @@ void GL_APIENTRY GL_CompressedTextureSubImage2D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, width = %d, height " "= %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, width, height, - GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data); + GLenumToString(BigGLEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) { @@ -3383,7 +3383,7 @@ void GL_APIENTRY GL_CompressedTextureSubImage3D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, zoffset, width, height, depth, - GLenumToString(GLenumGroup::PixelFormat, format), imageSize, (uintptr_t)data); + GLenumToString(BigGLEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) { @@ -3627,7 +3627,7 @@ void GL_APIENTRY GL_CreateQueries(GLenum target, GLsizei n, GLuint *ids) { Context *context = GetValidGlobalContext(); EVENT(context, GLCreateQueries, "context = %d, target = %s, n = %d, ids = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::QueryTarget, target), n, (uintptr_t)ids); + CID(context), GLenumToString(BigGLEnum::QueryTarget, target), n, (uintptr_t)ids); if (context) { @@ -3702,7 +3702,7 @@ void GL_APIENTRY GL_CreateTextures(GLenum target, GLsizei n, GLuint *textures) Context *context = GetValidGlobalContext(); EVENT(context, GLCreateTextures, "context = %d, target = %s, n = %d, textures = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), n, (uintptr_t)textures); + GLenumToString(BigGLEnum::TextureTarget, target), n, (uintptr_t)textures); if (context) { @@ -3953,7 +3953,7 @@ void GL_APIENTRY GL_GetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLi Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedBufferParameteri64v, "context = %d, buffer = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), buffer, - GLenumToString(GLenumGroup::VertexBufferObjectParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -3981,7 +3981,7 @@ void GL_APIENTRY GL_GetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedBufferParameteriv, "context = %d, buffer = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), buffer, - GLenumToString(GLenumGroup::VertexBufferObjectParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -4009,7 +4009,7 @@ void GL_APIENTRY GL_GetNamedBufferPointerv(GLuint buffer, GLenum pname, void **p Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedBufferPointerv, "context = %d, buffer = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), buffer, - GLenumToString(GLenumGroup::VertexBufferObjectParameter, pname), (uintptr_t)params); + GLenumToString(BigGLEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -4071,9 +4071,8 @@ void GL_APIENTRY GL_GetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedFramebufferAttachmentParameteriv, "context = %d, framebuffer = %u, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), framebuffer, GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), - (uintptr_t)params); + CID(context), framebuffer, GLenumToString(BigGLEnum::FramebufferAttachment, attachment), + GLenumToString(BigGLEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); if (context) { @@ -4103,8 +4102,7 @@ void GL_APIENTRY GL_GetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pn Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedFramebufferParameteriv, "context = %d, framebuffer = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - framebuffer, GLenumToString(GLenumGroup::GetFramebufferParameter, pname), - (uintptr_t)param); + framebuffer, GLenumToString(BigGLEnum::GetFramebufferParameter, pname), (uintptr_t)param); if (context) { @@ -4134,7 +4132,7 @@ void GL_APIENTRY GL_GetNamedRenderbufferParameteriv(GLuint renderbuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLGetNamedRenderbufferParameteriv, "context = %d, renderbuffer = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - renderbuffer, GLenumToString(GLenumGroup::RenderbufferParameterName, pname), + renderbuffer, GLenumToString(BigGLEnum::RenderbufferParameterName, pname), (uintptr_t)params); if (context) @@ -4166,7 +4164,7 @@ void GL_APIENTRY GL_GetQueryBufferObjecti64v(GLuint id, Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryBufferObjecti64v, "context = %d, id = %u, buffer = %u, pname = %s, offset = %llu", CID(context), id, buffer, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), static_cast(offset)); if (context) @@ -4195,7 +4193,7 @@ void GL_APIENTRY GL_GetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pnam Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryBufferObjectiv, "context = %d, id = %u, buffer = %u, pname = %s, offset = %llu", CID(context), id, buffer, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), static_cast(offset)); if (context) @@ -4227,7 +4225,7 @@ void GL_APIENTRY GL_GetQueryBufferObjectui64v(GLuint id, Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryBufferObjectui64v, "context = %d, id = %u, buffer = %u, pname = %s, offset = %llu", CID(context), id, buffer, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), static_cast(offset)); if (context) @@ -4256,7 +4254,7 @@ void GL_APIENTRY GL_GetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pna Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryBufferObjectuiv, "context = %d, id = %u, buffer = %u, pname = %s, offset = %llu", CID(context), id, buffer, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), + GLenumToString(BigGLEnum::QueryObjectParameterName, pname), static_cast(offset)); if (context) @@ -4291,8 +4289,8 @@ void GL_APIENTRY GL_GetTextureImage(GLuint texture, EVENT(context, GLGetTextureImage, "context = %d, texture = %u, level = %d, format = %s, type = %s, bufSize = %d, pixels = " "0x%016" PRIxPTR "", - CID(context), texture, level, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)pixels); + CID(context), texture, level, GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)pixels); if (context) { @@ -4323,7 +4321,7 @@ void GL_APIENTRY GL_GetTextureLevelParameterfv(GLuint texture, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureLevelParameterfv, "context = %d, texture = %u, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), texture, level, GLenumToString(GLenumGroup::GetTextureParameter, pname), + CID(context), texture, level, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) @@ -4355,7 +4353,7 @@ void GL_APIENTRY GL_GetTextureLevelParameteriv(GLuint texture, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureLevelParameteriv, "context = %d, texture = %u, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), texture, level, GLenumToString(GLenumGroup::GetTextureParameter, pname), + CID(context), texture, level, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) @@ -4384,7 +4382,7 @@ void GL_APIENTRY GL_GetTextureParameterIiv(GLuint texture, GLenum pname, GLint * Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureParameterIiv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -4412,7 +4410,7 @@ void GL_APIENTRY GL_GetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureParameterIuiv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -4440,7 +4438,7 @@ void GL_APIENTRY GL_GetTextureParameterfv(GLuint texture, GLenum pname, GLfloat Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureParameterfv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -4467,7 +4465,7 @@ void GL_APIENTRY GL_GetTextureParameteriv(GLuint texture, GLenum pname, GLint *p Context *context = GetValidGlobalContext(); EVENT(context, GLGetTextureParameteriv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -4509,8 +4507,8 @@ void GL_APIENTRY GL_GetTextureSubImage(GLuint texture, "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, zoffset, width, height, depth, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)pixels); + GLenumToString(BigGLEnum::PixelFormat, format), GLenumToString(BigGLEnum::PixelType, type), + bufSize, (uintptr_t)pixels); if (context) { @@ -4543,7 +4541,7 @@ void GL_APIENTRY GL_GetTransformFeedbacki64_v(GLuint xfb, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTransformFeedbacki64_v, "context = %d, xfb = %u, pname = %s, index = %u, param = 0x%016" PRIxPTR "", CID(context), - xfb, GLenumToString(GLenumGroup::TransformFeedbackPName, pname), index, (uintptr_t)param); + xfb, GLenumToString(BigGLEnum::TransformFeedbackPName, pname), index, (uintptr_t)param); if (context) { @@ -4569,7 +4567,7 @@ void GL_APIENTRY GL_GetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint ind Context *context = GetValidGlobalContext(); EVENT(context, GLGetTransformFeedbacki_v, "context = %d, xfb = %u, pname = %s, index = %u, param = 0x%016" PRIxPTR "", CID(context), - xfb, GLenumToString(GLenumGroup::TransformFeedbackPName, pname), index, (uintptr_t)param); + xfb, GLenumToString(BigGLEnum::TransformFeedbackPName, pname), index, (uintptr_t)param); if (context) { @@ -4595,7 +4593,7 @@ void GL_APIENTRY GL_GetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *para Context *context = GetValidGlobalContext(); EVENT(context, GLGetTransformFeedbackiv, "context = %d, xfb = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), xfb, - GLenumToString(GLenumGroup::TransformFeedbackPName, pname), (uintptr_t)param); + GLenumToString(BigGLEnum::TransformFeedbackPName, pname), (uintptr_t)param); if (context) { @@ -4624,7 +4622,7 @@ void GL_APIENTRY GL_GetVertexArrayIndexed64iv(GLuint vaobj, Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexArrayIndexed64iv, "context = %d, vaobj = %u, index = %u, pname = %s, param = 0x%016" PRIxPTR "", - CID(context), vaobj, index, GLenumToString(GLenumGroup::VertexArrayPName, pname), + CID(context), vaobj, index, GLenumToString(BigGLEnum::VertexArrayPName, pname), (uintptr_t)param); if (context) @@ -4653,7 +4651,7 @@ void GL_APIENTRY GL_GetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum p Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexArrayIndexediv, "context = %d, vaobj = %u, index = %u, pname = %s, param = 0x%016" PRIxPTR "", - CID(context), vaobj, index, GLenumToString(GLenumGroup::VertexArrayPName, pname), + CID(context), vaobj, index, GLenumToString(BigGLEnum::VertexArrayPName, pname), (uintptr_t)param); if (context) @@ -4682,7 +4680,7 @@ void GL_APIENTRY GL_GetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param) Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexArrayiv, "context = %d, vaobj = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), vaobj, - GLenumToString(GLenumGroup::VertexArrayPName, pname), (uintptr_t)param); + GLenumToString(BigGLEnum::VertexArrayPName, pname), (uintptr_t)param); if (context) { @@ -4710,9 +4708,9 @@ GL_GetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, vo EVENT(context, GLGetnColorTable, "context = %d, target = %s, format = %s, type = %s, bufSize = %d, table = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ColorTableTarget, target), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)table); + CID(context), GLenumToString(BigGLEnum::ColorTableTarget, target), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)table); if (context) { @@ -4738,7 +4736,7 @@ void GL_APIENTRY GL_GetnCompressedTexImage(GLenum target, GLint lod, GLsizei buf Context *context = GetValidGlobalContext(); EVENT(context, GLGetnCompressedTexImage, "context = %d, target = %s, lod = %d, bufSize = %d, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), lod, bufSize, + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), lod, bufSize, (uintptr_t)pixels); if (context) @@ -4768,9 +4766,9 @@ GL_GetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufS EVENT(context, GLGetnConvolutionFilter, "context = %d, target = %s, format = %s, type = %s, bufSize = %d, image = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ConvolutionTarget, target), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)image); + CID(context), GLenumToString(BigGLEnum::ConvolutionTarget, target), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)image); if (context) { @@ -4803,9 +4801,9 @@ void GL_APIENTRY GL_GetnHistogram(GLenum target, EVENT(context, GLGetnHistogram, "context = %d, target = %s, reset = %s, format = %s, type = %s, bufSize = %d, values = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::HistogramTargetEXT, target), - GLbooleanToString(reset), GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::HistogramTarget, target), + GLbooleanToString(reset), GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)values); if (context) { @@ -4831,8 +4829,8 @@ void GL_APIENTRY GL_GetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdo Context *context = GetValidGlobalContext(); EVENT(context, GLGetnMapdv, "context = %d, target = %s, query = %s, bufSize = %d, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::MapQuery, query), bufSize, (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::MapQuery, query), bufSize, (uintptr_t)v); if (context) { @@ -4857,8 +4855,8 @@ void GL_APIENTRY GL_GetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfl Context *context = GetValidGlobalContext(); EVENT(context, GLGetnMapfv, "context = %d, target = %s, query = %s, bufSize = %d, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::MapQuery, query), bufSize, (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::MapQuery, query), bufSize, (uintptr_t)v); if (context) { @@ -4883,8 +4881,8 @@ void GL_APIENTRY GL_GetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLin Context *context = GetValidGlobalContext(); EVENT(context, GLGetnMapiv, "context = %d, target = %s, query = %s, bufSize = %d, v = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MapTarget, target), - GLenumToString(GLenumGroup::MapQuery, query), bufSize, (uintptr_t)v); + CID(context), GLenumToString(BigGLEnum::MapTarget, target), + GLenumToString(BigGLEnum::MapQuery, query), bufSize, (uintptr_t)v); if (context) { @@ -4915,9 +4913,9 @@ void GL_APIENTRY GL_GetnMinmax(GLenum target, EVENT(context, GLGetnMinmax, "context = %d, target = %s, reset = %s, format = %s, type = %s, bufSize = %d, values = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MinmaxTargetEXT, target), - GLbooleanToString(reset), GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)values); + CID(context), GLenumToString(BigGLEnum::MinmaxTarget, target), GLbooleanToString(reset), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)values); if (context) { @@ -4943,7 +4941,7 @@ void GL_APIENTRY GL_GetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values) Context *context = GetValidGlobalContext(); EVENT(context, GLGetnPixelMapfv, "context = %d, map = %s, bufSize = %d, values = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PixelMap, map), bufSize, (uintptr_t)values); + GLenumToString(BigGLEnum::PixelMap, map), bufSize, (uintptr_t)values); if (context) { @@ -4968,7 +4966,7 @@ void GL_APIENTRY GL_GetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values) Context *context = GetValidGlobalContext(); EVENT(context, GLGetnPixelMapuiv, "context = %d, map = %s, bufSize = %d, values = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PixelMap, map), bufSize, (uintptr_t)values); + GLenumToString(BigGLEnum::PixelMap, map), bufSize, (uintptr_t)values); if (context) { @@ -4993,7 +4991,7 @@ void GL_APIENTRY GL_GetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *value Context *context = GetValidGlobalContext(); EVENT(context, GLGetnPixelMapusv, "context = %d, map = %s, bufSize = %d, values = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PixelMap, map), bufSize, (uintptr_t)values); + GLenumToString(BigGLEnum::PixelMap, map), bufSize, (uintptr_t)values); if (context) { @@ -5051,9 +5049,9 @@ void GL_APIENTRY GL_GetnSeparableFilter(GLenum target, EVENT(context, GLGetnSeparableFilter, "context = %d, target = %s, format = %s, type = %s, rowBufSize = %d, row = 0x%016" PRIxPTR ", columnBufSize = %d, column = 0x%016" PRIxPTR ", span = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::SeparableTargetEXT, target), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), rowBufSize, (uintptr_t)row, columnBufSize, + CID(context), GLenumToString(BigGLEnum::SeparableTarget, target), + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), rowBufSize, (uintptr_t)row, columnBufSize, (uintptr_t)column, (uintptr_t)span); if (context) @@ -5088,9 +5086,9 @@ void GL_APIENTRY GL_GetnTexImage(GLenum target, EVENT(context, GLGetnTexImage, "context = %d, target = %s, level = %d, format = %s, type = %s, bufSize = %d, pixels = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)pixels); + CID(context), GLenumToString(BigGLEnum::TextureTarget, target), level, + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), bufSize, (uintptr_t)pixels); if (context) { @@ -5210,7 +5208,7 @@ void *GL_APIENTRY GL_MapNamedBuffer(GLuint buffer, GLenum access) { Context *context = GetValidGlobalContext(); EVENT(context, GLMapNamedBuffer, "context = %d, buffer = %u, access = %s", CID(context), buffer, - GLenumToString(GLenumGroup::BufferAccessARB, access)); + GLenumToString(BigGLEnum::BufferAccessARB, access)); void *returnValue; if (context) @@ -5247,7 +5245,7 @@ void *GL_APIENTRY GL_MapNamedBufferRange(GLuint buffer, EVENT(context, GLMapNamedBufferRange, "context = %d, buffer = %u, offset = %llu, length = %llu, access = %s", CID(context), buffer, static_cast(offset), static_cast(length), - GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str()); + GLbitfieldToString(BigGLEnum::MapBufferAccessMask, access).c_str()); void *returnValue; if (context) @@ -5283,7 +5281,7 @@ void GL_APIENTRY GL_NamedBufferData(GLuint buffer, GLsizeiptr size, const void * EVENT(context, GLNamedBufferData, "context = %d, buffer = %u, size = %llu, data = 0x%016" PRIxPTR ", usage = %s", CID(context), buffer, static_cast(size), (uintptr_t)data, - GLenumToString(GLenumGroup::VertexBufferObjectUsage, usage)); + GLenumToString(BigGLEnum::VertexBufferObjectUsage, usage)); if (context) { @@ -5313,7 +5311,7 @@ void GL_APIENTRY GL_NamedBufferStorage(GLuint buffer, EVENT(context, GLNamedBufferStorage, "context = %d, buffer = %u, size = %llu, data = 0x%016" PRIxPTR ", flags = %s", CID(context), buffer, static_cast(size), (uintptr_t)data, - GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str()); + GLbitfieldToString(BigGLEnum::BufferStorageMask, flags).c_str()); if (context) { @@ -5371,7 +5369,7 @@ void GL_APIENTRY GL_NamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf) { Context *context = GetValidGlobalContext(); EVENT(context, GLNamedFramebufferDrawBuffer, "context = %d, framebuffer = %u, buf = %s", - CID(context), framebuffer, GLenumToString(GLenumGroup::ColorBuffer, buf)); + CID(context), framebuffer, GLenumToString(BigGLEnum::ColorBuffer, buf)); if (context) { @@ -5426,7 +5424,7 @@ void GL_APIENTRY GL_NamedFramebufferParameteri(GLuint framebuffer, GLenum pname, Context *context = GetValidGlobalContext(); EVENT(context, GLNamedFramebufferParameteri, "context = %d, framebuffer = %u, pname = %s, param = %d", CID(context), framebuffer, - GLenumToString(GLenumGroup::FramebufferParameterName, pname), param); + GLenumToString(BigGLEnum::FramebufferParameterName, pname), param); if (context) { @@ -5453,7 +5451,7 @@ void GL_APIENTRY GL_NamedFramebufferReadBuffer(GLuint framebuffer, GLenum src) { Context *context = GetValidGlobalContext(); EVENT(context, GLNamedFramebufferReadBuffer, "context = %d, framebuffer = %u, src = %s", - CID(context), framebuffer, GLenumToString(GLenumGroup::ColorBuffer, src)); + CID(context), framebuffer, GLenumToString(BigGLEnum::ColorBuffer, src)); if (context) { @@ -5484,8 +5482,8 @@ void GL_APIENTRY GL_NamedFramebufferRenderbuffer(GLuint framebuffer, EVENT(context, GLNamedFramebufferRenderbuffer, "context = %d, framebuffer = %u, attachment = %s, renderbuffertarget = %s, renderbuffer " "= %u", - CID(context), framebuffer, GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer); + CID(context), framebuffer, GLenumToString(BigGLEnum::FramebufferAttachment, attachment), + GLenumToString(BigGLEnum::RenderbufferTarget, renderbuffertarget), renderbuffer); if (context) { @@ -5519,7 +5517,7 @@ void GL_APIENTRY GL_NamedFramebufferTexture(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLNamedFramebufferTexture, "context = %d, framebuffer = %u, attachment = %s, texture = %u, level = %d", CID(context), - framebuffer, GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, + framebuffer, GLenumToString(BigGLEnum::FramebufferAttachment, attachment), texture, level); if (context) @@ -5553,7 +5551,7 @@ void GL_APIENTRY GL_NamedFramebufferTextureLayer(GLuint framebuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLNamedFramebufferTextureLayer, "context = %d, framebuffer = %u, attachment = %s, texture = %u, level = %d, layer = %d", - CID(context), framebuffer, GLenumToString(GLenumGroup::FramebufferAttachment, attachment), + CID(context), framebuffer, GLenumToString(BigGLEnum::FramebufferAttachment, attachment), texture, level, layer); if (context) @@ -5587,7 +5585,7 @@ void GL_APIENTRY GL_NamedRenderbufferStorage(GLuint renderbuffer, Context *context = GetValidGlobalContext(); EVENT(context, GLNamedRenderbufferStorage, "context = %d, renderbuffer = %u, internalformat = %s, width = %d, height = %d", - CID(context), renderbuffer, GLenumToString(GLenumGroup::InternalFormat, internalformat), + CID(context), renderbuffer, GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height); if (context) @@ -5622,7 +5620,7 @@ void GL_APIENTRY GL_NamedRenderbufferStorageMultisample(GLuint renderbuffer, "context = %d, renderbuffer = %u, samples = %d, internalformat = %s, width = %d, height " "= %d", CID(context), renderbuffer, samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + GLenumToString(BigGLEnum::InternalFormat, internalformat), width, height); if (context) { @@ -5672,7 +5670,7 @@ void GL_APIENTRY GL_TextureBuffer(GLuint texture, GLenum internalformat, GLuint { Context *context = GetValidGlobalContext(); EVENT(context, GLTextureBuffer, "context = %d, texture = %u, internalformat = %s, buffer = %u", - CID(context), texture, GLenumToString(GLenumGroup::InternalFormat, internalformat), + CID(context), texture, GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), buffer); if (context) @@ -5706,8 +5704,8 @@ void GL_APIENTRY GL_TextureBufferRange(GLuint texture, EVENT( context, GLTextureBufferRange, "context = %d, texture = %u, internalformat = %s, buffer = %u, offset = %llu, size = %llu", - CID(context), texture, GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer, - static_cast(offset), static_cast(size)); + CID(context), texture, GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), + buffer, static_cast(offset), static_cast(size)); if (context) { @@ -5736,7 +5734,7 @@ void GL_APIENTRY GL_TextureParameterIiv(GLuint texture, GLenum pname, const GLin Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameterIiv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -5763,7 +5761,7 @@ void GL_APIENTRY GL_TextureParameterIuiv(GLuint texture, GLenum pname, const GLu Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameterIuiv, "context = %d, texture = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + texture, GLenumToString(BigGLEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -5789,7 +5787,7 @@ void GL_APIENTRY GL_TextureParameterf(GLuint texture, GLenum pname, GLfloat para { Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameterf, "context = %d, texture = %u, pname = %s, param = %f", - CID(context), texture, GLenumToString(GLenumGroup::TextureParameterName, pname), param); + CID(context), texture, GLenumToString(BigGLEnum::TextureParameterName, pname), param); if (context) { @@ -5816,7 +5814,7 @@ void GL_APIENTRY GL_TextureParameterfv(GLuint texture, GLenum pname, const GLflo Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameterfv, "context = %d, texture = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)param); + texture, GLenumToString(BigGLEnum::TextureParameterName, pname), (uintptr_t)param); if (context) { @@ -5842,7 +5840,7 @@ void GL_APIENTRY GL_TextureParameteri(GLuint texture, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameteri, "context = %d, texture = %u, pname = %s, param = %d", - CID(context), texture, GLenumToString(GLenumGroup::TextureParameterName, pname), param); + CID(context), texture, GLenumToString(BigGLEnum::TextureParameterName, pname), param); if (context) { @@ -5869,7 +5867,7 @@ void GL_APIENTRY GL_TextureParameteriv(GLuint texture, GLenum pname, const GLint Context *context = GetValidGlobalContext(); EVENT(context, GLTextureParameteriv, "context = %d, texture = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - texture, GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)param); + texture, GLenumToString(BigGLEnum::TextureParameterName, pname), (uintptr_t)param); if (context) { @@ -5899,7 +5897,7 @@ void GL_APIENTRY GL_TextureStorage1D(GLuint texture, Context *context = GetValidGlobalContext(); EVENT(context, GLTextureStorage1D, "context = %d, texture = %u, levels = %d, internalformat = %s, width = %d", CID(context), - texture, levels, GLenumToString(GLenumGroup::InternalFormat, internalformat), width); + texture, levels, GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width); if (context) { @@ -5931,7 +5929,7 @@ void GL_APIENTRY GL_TextureStorage2D(GLuint texture, EVENT(context, GLTextureStorage2D, "context = %d, texture = %u, levels = %d, internalformat = %s, width = %d, height = %d", CID(context), texture, levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width, height); if (context) { @@ -5966,7 +5964,7 @@ void GL_APIENTRY GL_TextureStorage2DMultisample(GLuint texture, "context = %d, texture = %u, samples = %d, internalformat = %s, width = %d, height = %d, " "fixedsamplelocations = %s", CID(context), texture, samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width, height, GLbooleanToString(fixedsamplelocations)); if (context) @@ -6004,7 +6002,7 @@ void GL_APIENTRY GL_TextureStorage3D(GLuint texture, "context = %d, texture = %u, levels = %d, internalformat = %s, width = %d, height = %d, " "depth = %d", CID(context), texture, levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth); + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width, height, depth); if (context) { @@ -6040,7 +6038,7 @@ void GL_APIENTRY GL_TextureStorage3DMultisample(GLuint texture, "context = %d, texture = %u, samples = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, fixedsamplelocations = %s", CID(context), texture, samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, + GLenumToString(BigGLEnum::SizedInternalFormat, internalformat), width, height, depth, GLbooleanToString(fixedsamplelocations)); if (context) @@ -6079,8 +6077,8 @@ void GL_APIENTRY GL_TextureSubImage1D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, width = %d, format = %s, type = " "%s, pixels = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, width, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -6118,8 +6116,8 @@ void GL_APIENTRY GL_TextureSubImage2D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, width = %d, height " "= %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, width, height, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -6160,8 +6158,8 @@ void GL_APIENTRY GL_TextureSubImage3D(GLuint texture, "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", CID(context), texture, level, xoffset, yoffset, zoffset, width, height, depth, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + GLenumToString(BigGLEnum::PixelFormat, format), + GLenumToString(BigGLEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -6316,9 +6314,8 @@ void GL_APIENTRY GL_VertexArrayAttribFormat(GLuint vaobj, EVENT(context, GLVertexArrayAttribFormat, "context = %d, vaobj = %u, attribindex = %u, size = %d, type = %s, normalized = %s, " "relativeoffset = %u", - CID(context), vaobj, attribindex, size, - GLenumToString(GLenumGroup::VertexAttribType, type), GLbooleanToString(normalized), - relativeoffset); + CID(context), vaobj, attribindex, size, GLenumToString(BigGLEnum::VertexAttribType, type), + GLbooleanToString(normalized), relativeoffset); if (context) { @@ -6352,7 +6349,7 @@ void GL_APIENTRY GL_VertexArrayAttribIFormat(GLuint vaobj, EVENT(context, GLVertexArrayAttribIFormat, "context = %d, vaobj = %u, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), vaobj, attribindex, size, - GLenumToString(GLenumGroup::VertexAttribType, type), relativeoffset); + GLenumToString(BigGLEnum::VertexAttribIType, type), relativeoffset); if (context) { @@ -6385,7 +6382,7 @@ void GL_APIENTRY GL_VertexArrayAttribLFormat(GLuint vaobj, EVENT(context, GLVertexArrayAttribLFormat, "context = %d, vaobj = %u, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), vaobj, attribindex, size, - GLenumToString(GLenumGroup::VertexAttribType, type), relativeoffset); + GLenumToString(BigGLEnum::VertexAttribLType, type), relativeoffset); if (context) { @@ -6546,7 +6543,7 @@ void GL_APIENTRY GL_MultiDrawArraysIndirectCount(GLenum mode, EVENT(context, GLMultiDrawArraysIndirectCount, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %llu, maxdrawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), (uintptr_t)indirect, static_cast(drawcount), maxdrawcount, stride); if (context) @@ -6580,8 +6577,8 @@ void GL_APIENTRY GL_MultiDrawElementsIndirectCount(GLenum mode, EVENT(context, GLMultiDrawElementsIndirectCount, "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR ", drawcount = %llu, maxdrawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), - GLenumToString(GLenumGroup::DefaultGroup, type), (uintptr_t)indirect, + CID(context), GLenumToString(BigGLEnum::PrimitiveType, mode), + GLenumToString(BigGLEnum::DrawElementsType, type), (uintptr_t)indirect, static_cast(drawcount), maxdrawcount, stride); if (context) diff --git a/src/libGLESv2/entry_points_gl_4_autogen.h b/src/libGLESv2/entry_points_gl_4_autogen.h index 3b645f192..289564c87 100644 --- a/src/libGLESv2/entry_points_gl_4_autogen.h +++ b/src/libGLESv2/entry_points_gl_4_autogen.h @@ -24,13 +24,13 @@ ANGLE_EXPORT void GL_APIENTRY GL_EndQueryIndexed(GLenum target, GLuint index); ANGLE_EXPORT void GL_APIENTRY GL_GetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); ANGLE_EXPORT void GL_APIENTRY GL_GetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name); ANGLE_EXPORT void GL_APIENTRY GL_GetActiveSubroutineUniformiv(GLuint program, @@ -257,7 +257,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_ClearBufferSubData(GLenum target, ANGLE_EXPORT void GL_APIENTRY GL_GetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params); ANGLE_EXPORT GLint GL_APIENTRY GL_GetProgramResourceLocationIndex(GLuint program, GLenum programInterface, diff --git a/src/libGLESv2/entry_points_gles_1_0_autogen.cpp b/src/libGLESv2/entry_points_gles_1_0_autogen.cpp index a0b6d7e97..57406dee3 100644 --- a/src/libGLESv2/entry_points_gles_1_0_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_1_0_autogen.cpp @@ -26,7 +26,7 @@ void GL_APIENTRY GL_AlphaFunc(GLenum func, GLfloat ref) { Context *context = GetValidGlobalContext(); EVENT(context, GLAlphaFunc, "context = %d, func = %s, ref = %f", CID(context), - GLenumToString(GLenumGroup::AlphaFunction, func), ref); + GLenumToString(GLESEnum::AlphaFunction, func), ref); if (context) { @@ -51,7 +51,7 @@ void GL_APIENTRY GL_AlphaFuncx(GLenum func, GLfixed ref) { Context *context = GetValidGlobalContext(); EVENT(context, GLAlphaFuncx, "context = %d, func = %s, ref = 0x%X", CID(context), - GLenumToString(GLenumGroup::AlphaFunction, func), ref); + GLenumToString(GLESEnum::AlphaFunction, func), ref); if (context) { @@ -123,7 +123,7 @@ void GL_APIENTRY GL_ClientActiveTexture(GLenum texture) { Context *context = GetValidGlobalContext(); EVENT(context, GLClientActiveTexture, "context = %d, texture = %s", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture)); + GLenumToString(GLESEnum::TextureUnit, texture)); if (context) { @@ -147,7 +147,7 @@ void GL_APIENTRY GL_ClipPlanef(GLenum p, const GLfloat *eqn) { Context *context = GetValidGlobalContext(); EVENT(context, GLClipPlanef, "context = %d, p = %s, eqn = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ClipPlaneName, p), (uintptr_t)eqn); + GLenumToString(GLESEnum::ClipPlaneName, p), (uintptr_t)eqn); if (context) { @@ -170,7 +170,7 @@ void GL_APIENTRY GL_ClipPlanex(GLenum plane, const GLfixed *equation) { Context *context = GetValidGlobalContext(); EVENT(context, GLClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation); + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); if (context) { @@ -267,7 +267,7 @@ void GL_APIENTRY GL_ColorPointer(GLint size, GLenum type, GLsizei stride, const Context *context = GetValidGlobalContext(); EVENT(context, GLColorPointer, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::ColorPointerType, type), stride, + CID(context), size, GLenumToString(GLESEnum::ColorPointerType, type), stride, (uintptr_t)pointer); if (context) @@ -315,7 +315,7 @@ void GL_APIENTRY GL_DisableClientState(GLenum array) { Context *context = GetValidGlobalContext(); EVENT(context, GLDisableClientState, "context = %d, array = %s", CID(context), - GLenumToString(GLenumGroup::EnableCap, array)); + GLenumToString(GLESEnum::EnableCap, array)); if (context) { @@ -340,7 +340,7 @@ void GL_APIENTRY GL_EnableClientState(GLenum array) { Context *context = GetValidGlobalContext(); EVENT(context, GLEnableClientState, "context = %d, array = %s", CID(context), - GLenumToString(GLenumGroup::EnableCap, array)); + GLenumToString(GLESEnum::EnableCap, array)); if (context) { @@ -365,7 +365,7 @@ void GL_APIENTRY GL_Fogf(GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogf, "context = %d, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::FogParameter, pname), param); + GLenumToString(GLESEnum::FogParameter, pname), param); if (context) { @@ -388,7 +388,7 @@ void GL_APIENTRY GL_Fogfv(GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::FogParameter, pname), (uintptr_t)params); if (context) { @@ -411,7 +411,7 @@ void GL_APIENTRY GL_Fogx(GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogx, "context = %d, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::FogPName, pname), param); + GLenumToString(GLESEnum::FogPName, pname), param); if (context) { @@ -434,7 +434,7 @@ void GL_APIENTRY GL_Fogxv(GLenum pname, const GLfixed *param) { Context *context = GetValidGlobalContext(); EVENT(context, GLFogxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FogPName, pname), (uintptr_t)param); + GLenumToString(GLESEnum::FogPName, pname), (uintptr_t)param); if (context) { @@ -506,7 +506,7 @@ void GL_APIENTRY GL_GetClipPlanef(GLenum plane, GLfloat *equation) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetClipPlanef, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation); + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); if (context) { @@ -530,7 +530,7 @@ void GL_APIENTRY GL_GetClipPlanex(GLenum plane, GLfixed *equation) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation); + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); if (context) { @@ -554,7 +554,7 @@ void GL_APIENTRY GL_GetFixedv(GLenum pname, GLfixed *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetFixedv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)params); if (context) { @@ -578,8 +578,8 @@ void GL_APIENTRY GL_GetLightfv(GLenum light, GLenum pname, GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -604,8 +604,8 @@ void GL_APIENTRY GL_GetLightxv(GLenum light, GLenum pname, GLfixed *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -631,8 +631,8 @@ void GL_APIENTRY GL_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetMaterialfv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); if (context) { @@ -658,8 +658,8 @@ void GL_APIENTRY GL_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetMaterialxv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); if (context) { @@ -685,8 +685,8 @@ void GL_APIENTRY GL_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexEnvfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -713,8 +713,8 @@ void GL_APIENTRY GL_GetTexEnviv(GLenum target, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexEnviv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -741,8 +741,8 @@ void GL_APIENTRY GL_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexEnvxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -769,8 +769,8 @@ void GL_APIENTRY GL_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *para Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -796,7 +796,7 @@ void GL_APIENTRY GL_LightModelf(GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModelf, "context = %d, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::LightModelParameter, pname), param); + GLenumToString(GLESEnum::LightModelParameter, pname), param); if (context) { @@ -820,7 +820,7 @@ void GL_APIENTRY GL_LightModelfv(GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModelfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)params); if (context) { @@ -844,7 +844,7 @@ void GL_APIENTRY GL_LightModelx(GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModelx, "context = %d, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::LightModelParameter, pname), param); + GLenumToString(GLESEnum::LightModelParameter, pname), param); if (context) { @@ -868,7 +868,7 @@ void GL_APIENTRY GL_LightModelxv(GLenum pname, const GLfixed *param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightModelxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightModelParameter, pname), (uintptr_t)param); + CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)param); if (context) { @@ -892,8 +892,8 @@ void GL_APIENTRY GL_Lightf(GLenum light, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightf, "context = %d, light = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), param); + GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), param); if (context) { @@ -918,8 +918,8 @@ void GL_APIENTRY GL_Lightfv(GLenum light, GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -944,8 +944,8 @@ void GL_APIENTRY GL_Lightx(GLenum light, GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightx, "context = %d, light = %s, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), param); + GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), param); if (context) { @@ -970,8 +970,8 @@ void GL_APIENTRY GL_Lightxv(GLenum light, GLenum pname, const GLfixed *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::LightName, light), - GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); if (context) { @@ -1086,7 +1086,7 @@ void GL_APIENTRY GL_LogicOp(GLenum opcode) { Context *context = GetValidGlobalContext(); EVENT(context, GLLogicOp, "context = %d, opcode = %s", CID(context), - GLenumToString(GLenumGroup::LogicOp, opcode)); + GLenumToString(GLESEnum::LogicOp, opcode)); if (context) { @@ -1110,8 +1110,8 @@ void GL_APIENTRY GL_Materialf(GLenum face, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLMaterialf, "context = %d, face = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), param); + GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), param); if (context) { @@ -1136,8 +1136,8 @@ void GL_APIENTRY GL_Materialfv(GLenum face, GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLMaterialfv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); if (context) { @@ -1162,8 +1162,8 @@ void GL_APIENTRY GL_Materialx(GLenum face, GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLMaterialx, "context = %d, face = %s, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), param); + GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), param); if (context) { @@ -1188,8 +1188,8 @@ void GL_APIENTRY GL_Materialxv(GLenum face, GLenum pname, const GLfixed *param) { Context *context = GetValidGlobalContext(); EVENT(context, GLMaterialxv, "context = %d, face = %s, pname = %s, param = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::MaterialFace, face), - GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)param); + CID(context), GLenumToString(GLESEnum::MaterialFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)param); if (context) { @@ -1214,7 +1214,7 @@ void GL_APIENTRY GL_MatrixMode(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLMatrixMode, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::MatrixMode, mode)); + GLenumToString(GLESEnum::MatrixMode, mode)); if (context) { @@ -1285,7 +1285,7 @@ void GL_APIENTRY GL_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4f, "context = %d, target = %s, s = %f, t = %f, r = %f, q = %f", - CID(context), GLenumToString(GLenumGroup::TextureUnit, target), s, t, r, q); + CID(context), GLenumToString(GLESEnum::TextureUnit, target), s, t, r, q); if (context) { @@ -1310,7 +1310,7 @@ void GL_APIENTRY GL_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixe Context *context = GetValidGlobalContext(); EVENT(context, GLMultiTexCoord4x, "context = %d, texture = %s, s = 0x%X, t = 0x%X, r = 0x%X, q = 0x%X", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture), s, t, r, q); + GLenumToString(GLESEnum::TextureUnit, texture), s, t, r, q); if (context) { @@ -1380,7 +1380,7 @@ void GL_APIENTRY GL_NormalPointer(GLenum type, GLsizei stride, const void *point Context *context = GetValidGlobalContext(); EVENT(context, GLNormalPointer, "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::NormalPointerType, type), stride, (uintptr_t)pointer); + GLenumToString(GLESEnum::NormalPointerType, type), stride, (uintptr_t)pointer); if (context) { @@ -1452,7 +1452,7 @@ void GL_APIENTRY GL_PointParameterf(GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameterf, "context = %d, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, pname), param); + GLenumToString(GLESEnum::AllEnums, pname), param); if (context) { @@ -1477,7 +1477,7 @@ void GL_APIENTRY GL_PointParameterfv(GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameterfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -1502,7 +1502,7 @@ void GL_APIENTRY GL_PointParameterx(GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameterx, "context = %d, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, pname), param); + GLenumToString(GLESEnum::AllEnums, pname), param); if (context) { @@ -1527,7 +1527,7 @@ void GL_APIENTRY GL_PointParameterxv(GLenum pname, const GLfixed *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLPointParameterxv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -1778,7 +1778,7 @@ void GL_APIENTRY GL_ShadeModel(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLShadeModel, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::ShadingModel, mode)); + GLenumToString(GLESEnum::ShadingModel, mode)); if (context) { @@ -1804,7 +1804,7 @@ void GL_APIENTRY GL_TexCoordPointer(GLint size, GLenum type, GLsizei stride, con Context *context = GetValidGlobalContext(); EVENT(context, GLTexCoordPointer, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::TexCoordPointerType, type), stride, + CID(context), size, GLenumToString(GLESEnum::TexCoordPointerType, type), stride, (uintptr_t)pointer); if (context) @@ -1830,8 +1830,8 @@ void GL_APIENTRY GL_TexEnvf(GLenum target, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnvf, "context = %d, target = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), param); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); if (context) { @@ -1857,8 +1857,8 @@ void GL_APIENTRY GL_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnvfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -1884,8 +1884,8 @@ void GL_APIENTRY GL_TexEnvi(GLenum target, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnvi, "context = %d, target = %s, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), param); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); if (context) { @@ -1911,8 +1911,8 @@ void GL_APIENTRY GL_TexEnviv(GLenum target, GLenum pname, const GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnviv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -1938,8 +1938,8 @@ void GL_APIENTRY GL_TexEnvx(GLenum target, GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnvx, "context = %d, target = %s, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), param); + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); if (context) { @@ -1965,8 +1965,8 @@ void GL_APIENTRY GL_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexEnvxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target), - GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); if (context) { @@ -1992,8 +1992,8 @@ void GL_APIENTRY GL_TexParameterx(GLenum target, GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterx, "context = %d, target = %s, pname = %s, param = 0x%X", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), param); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), param); if (context) { @@ -2019,8 +2019,8 @@ void GL_APIENTRY GL_TexParameterxv(GLenum target, GLenum pname, const GLfixed *p Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -2091,7 +2091,7 @@ void GL_APIENTRY GL_VertexPointer(GLint size, GLenum type, GLsizei stride, const Context *context = GetValidGlobalContext(); EVENT(context, GLVertexPointer, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::VertexPointerType, type), stride, + CID(context), size, GLenumToString(GLESEnum::VertexPointerType, type), stride, (uintptr_t)pointer); if (context) diff --git a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp index fff51f369..e4dcf96c8 100644 --- a/src/libGLESv2/entry_points_gles_2_0_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_2_0_autogen.cpp @@ -26,7 +26,7 @@ void GL_APIENTRY GL_ActiveTexture(GLenum texture) { Context *context = GetValidGlobalContext(); EVENT(context, GLActiveTexture, "context = %d, texture = %s", CID(context), - GLenumToString(GLenumGroup::TextureUnit, texture)); + GLenumToString(GLESEnum::TextureUnit, texture)); if (context) { @@ -103,7 +103,7 @@ void GL_APIENTRY GL_BindBuffer(GLenum target, GLuint buffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindBuffer, "context = %d, target = %s, buffer = %u", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), buffer); + GLenumToString(GLESEnum::BufferTargetARB, target), buffer); if (context) { @@ -129,7 +129,7 @@ void GL_APIENTRY GL_BindFramebuffer(GLenum target, GLuint framebuffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindFramebuffer, "context = %d, target = %s, framebuffer = %u", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer); + GLenumToString(GLESEnum::FramebufferTarget, target), framebuffer); if (context) { @@ -154,7 +154,7 @@ void GL_APIENTRY GL_BindRenderbuffer(GLenum target, GLuint renderbuffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindRenderbuffer, "context = %d, target = %s, renderbuffer = %u", CID(context), - GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer); + GLenumToString(GLESEnum::RenderbufferTarget, target), renderbuffer); if (context) { @@ -179,7 +179,7 @@ void GL_APIENTRY GL_BindTexture(GLenum target, GLuint texture) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindTexture, "context = %d, target = %s, texture = %u", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), texture); + GLenumToString(GLESEnum::TextureTarget, target), texture); if (context) { @@ -229,7 +229,7 @@ void GL_APIENTRY GL_BlendEquation(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquation, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::BlendEquationModeEXT, mode)); + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); if (context) { @@ -253,8 +253,8 @@ void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationSeparate, "context = %d, modeRGB = %s, modeAlpha = %s", - CID(context), GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB), - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha)); + CID(context), GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB), + GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha)); if (context) { @@ -279,8 +279,8 @@ void GL_APIENTRY GL_BlendFunc(GLenum sfactor, GLenum dfactor) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFunc, "context = %d, sfactor = %s, dfactor = %s", CID(context), - GLenumToString(GLenumGroup::BlendingFactor, sfactor), - GLenumToString(GLenumGroup::BlendingFactor, dfactor)); + GLenumToString(GLESEnum::BlendingFactor, sfactor), + GLenumToString(GLESEnum::BlendingFactor, dfactor)); if (context) { @@ -308,10 +308,10 @@ void GL_APIENTRY GL_BlendFuncSeparate(GLenum sfactorRGB, Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFuncSeparate, "context = %d, sfactorRGB = %s, dfactorRGB = %s, sfactorAlpha = %s, dfactorAlpha = %s", - CID(context), GLenumToString(GLenumGroup::BlendingFactor, sfactorRGB), - GLenumToString(GLenumGroup::BlendingFactor, dfactorRGB), - GLenumToString(GLenumGroup::BlendingFactor, sfactorAlpha), - GLenumToString(GLenumGroup::BlendingFactor, dfactorAlpha)); + CID(context), GLenumToString(GLESEnum::BlendingFactor, sfactorRGB), + GLenumToString(GLESEnum::BlendingFactor, dfactorRGB), + GLenumToString(GLESEnum::BlendingFactor, sfactorAlpha), + GLenumToString(GLESEnum::BlendingFactor, dfactorAlpha)); if (context) { @@ -338,9 +338,9 @@ void GL_APIENTRY GL_BufferData(GLenum target, GLsizeiptr size, const void *data, Context *context = GetValidGlobalContext(); EVENT(context, GLBufferData, "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", usage = %s", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(size), (uintptr_t)data, - GLenumToString(GLenumGroup::BufferUsageARB, usage)); + GLenumToString(GLESEnum::BufferUsageARB, usage)); if (context) { @@ -367,7 +367,7 @@ void GL_APIENTRY GL_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr siz Context *context = GetValidGlobalContext(); EVENT(context, GLBufferSubData, "context = %d, target = %s, offset = %llu, size = %llu, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(offset), static_cast(size), (uintptr_t)data); @@ -394,7 +394,7 @@ GLenum GL_APIENTRY GL_CheckFramebufferStatus(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLCheckFramebufferStatus, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target)); + GLenumToString(GLESEnum::FramebufferTarget, target)); GLenum returnValue; if (context) @@ -426,7 +426,7 @@ void GL_APIENTRY GL_Clear(GLbitfield mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLClear, "context = %d, mask = %s", CID(context), - GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str()); + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str()); if (context) { @@ -575,8 +575,8 @@ void GL_APIENTRY GL_CompressedTexImage2D(GLenum target, EVENT(context, GLCompressedTexImage2D, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "border = %d, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, border, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, border, imageSize, (uintptr_t)data); if (context) @@ -615,8 +615,8 @@ void GL_APIENTRY GL_CompressedTexSubImage2D(GLenum target, EVENT(context, GLCompressedTexSubImage2D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " "%d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - width, height, GLenumToString(GLenumGroup::PixelFormat, format), imageSize, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + width, height, GLenumToString(GLESEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) @@ -654,8 +654,8 @@ void GL_APIENTRY GL_CopyTexImage2D(GLenum target, EVENT(context, GLCopyTexImage2D, "context = %d, target = %s, level = %d, internalformat = %s, x = %d, y = %d, width = %d, " "height = %d, border = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), x, y, width, height, border); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), x, y, width, height, border); if (context) { @@ -692,8 +692,8 @@ void GL_APIENTRY GL_CopyTexSubImage2D(GLenum target, EVENT(context, GLCopyTexSubImage2D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, x = %d, y = %d, " "width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - x, y, width, height); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, x, + y, width, height); if (context) { @@ -749,7 +749,7 @@ GLuint GL_APIENTRY GL_CreateShader(GLenum type) { Context *context = GetValidGlobalContext(); EVENT(context, GLCreateShader, "context = %d, type = %s", CID(context), - GLenumToString(GLenumGroup::ShaderType, type)); + GLenumToString(GLESEnum::ShaderType, type)); GLuint returnValue; if (context) @@ -781,7 +781,7 @@ void GL_APIENTRY GL_CullFace(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLCullFace, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::CullFaceMode, mode)); + GLenumToString(GLESEnum::CullFaceMode, mode)); if (context) { @@ -956,7 +956,7 @@ void GL_APIENTRY GL_DepthFunc(GLenum func) { Context *context = GetValidGlobalContext(); EVENT(context, GLDepthFunc, "context = %d, func = %s", CID(context), - GLenumToString(GLenumGroup::DepthFunction, func)); + GLenumToString(GLESEnum::DepthFunction, func)); if (context) { @@ -1049,7 +1049,7 @@ void GL_APIENTRY GL_Disable(GLenum cap) { Context *context = GetValidGlobalContext(); EVENT(context, GLDisable, "context = %d, cap = %s", CID(context), - GLenumToString(GLenumGroup::EnableCap, cap)); + GLenumToString(GLESEnum::EnableCap, cap)); if (context) { @@ -1095,7 +1095,7 @@ void GL_APIENTRY GL_DrawArrays(GLenum mode, GLint first, GLsizei count) { Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArrays, "context = %d, mode = %s, first = %d, count = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), first, count); + GLenumToString(GLESEnum::PrimitiveType, mode), first, count); if (context) { @@ -1121,8 +1121,8 @@ void GL_APIENTRY GL_DrawElements(GLenum mode, GLsizei count, GLenum type, const Context *context = GetValidGlobalContext(); EVENT(context, GLDrawElements, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices); if (context) { @@ -1149,7 +1149,7 @@ void GL_APIENTRY GL_Enable(GLenum cap) { Context *context = GetValidGlobalContext(); EVENT(context, GLEnable, "context = %d, cap = %s", CID(context), - GLenumToString(GLenumGroup::EnableCap, cap)); + GLenumToString(GLESEnum::EnableCap, cap)); if (context) { @@ -1243,9 +1243,9 @@ void GL_APIENTRY GL_FramebufferRenderbuffer(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferRenderbuffer, "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::RenderbufferTarget, renderbuffertarget), renderbuffer); if (context) { @@ -1278,9 +1278,9 @@ void GL_APIENTRY GL_FramebufferTexture2D(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTexture2D, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level); if (context) { @@ -1309,7 +1309,7 @@ void GL_APIENTRY GL_FrontFace(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLFrontFace, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::FrontFaceDirection, mode)); + GLenumToString(GLESEnum::FrontFaceDirection, mode)); if (context) { @@ -1432,7 +1432,7 @@ void GL_APIENTRY GL_GenerateMipmap(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLGenerateMipmap, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target)); + GLenumToString(GLESEnum::TextureTarget, target)); if (context) { @@ -1595,7 +1595,7 @@ void GL_APIENTRY GL_GetBooleanv(GLenum pname, GLboolean *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetBooleanv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -1620,8 +1620,8 @@ void GL_APIENTRY GL_GetBufferParameteriv(GLenum target, GLenum pname, GLint *par Context *context = GetValidGlobalContext(); EVENT(context, GLGetBufferParameteriv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -1676,7 +1676,7 @@ void GL_APIENTRY GL_GetFloatv(GLenum pname, GLfloat *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetFloatv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -1704,10 +1704,9 @@ void GL_APIENTRY GL_GetFramebufferAttachmentParameteriv(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetFramebufferAttachmentParameteriv, "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); if (context) { @@ -1733,7 +1732,7 @@ void GL_APIENTRY GL_GetIntegerv(GLenum pname, GLint *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetIntegerv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -1790,7 +1789,7 @@ void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params) Context *context = GetGlobalContext(); EVENT(context, GLGetProgramiv, "context = %d, program = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - program, GLenumToString(GLenumGroup::ProgramPropertyARB, pname), (uintptr_t)params); + program, GLenumToString(GLESEnum::ProgramPropertyARB, pname), (uintptr_t)params); if (context) { @@ -1814,8 +1813,8 @@ void GL_APIENTRY GL_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLin Context *context = GetValidGlobalContext(); EVENT(context, GLGetRenderbufferParameteriv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::RenderbufferTarget, target), - GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::RenderbufferParameterName, pname), (uintptr_t)params); if (context) { @@ -1876,8 +1875,8 @@ void GL_APIENTRY GL_GetShaderPrecisionFormat(GLenum shadertype, EVENT(context, GLGetShaderPrecisionFormat, "context = %d, shadertype = %s, precisiontype = %s, range = 0x%016" PRIxPTR ", precision = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), - GLenumToString(GLenumGroup::PrecisionType, precisiontype), (uintptr_t)range, + CID(context), GLenumToString(GLESEnum::ShaderType, shadertype), + GLenumToString(GLESEnum::PrecisionType, precisiontype), (uintptr_t)range, (uintptr_t)precision); if (context) @@ -1933,7 +1932,7 @@ void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params) Context *context = GetGlobalContext(); EVENT(context, GLGetShaderiv, "context = %d, shader = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), shader, - GLenumToString(GLenumGroup::ShaderParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::ShaderParameterName, pname), (uintptr_t)params); if (context) { @@ -1956,7 +1955,7 @@ const GLubyte *GL_APIENTRY GL_GetString(GLenum name) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetString, "context = %d, name = %s", CID(context), - GLenumToString(GLenumGroup::StringName, name)); + GLenumToString(GLESEnum::StringName, name)); const GLubyte *returnValue; if (context) @@ -1987,8 +1986,8 @@ void GL_APIENTRY GL_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *para Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -2015,8 +2014,8 @@ void GL_APIENTRY GL_GetTexParameteriv(GLenum target, GLenum pname, GLint *params Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameteriv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -2131,7 +2130,7 @@ void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, GLenum pname, void **p Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribPointerv, "context = %d, index = %u, pname = %s, pointer = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)pointer); + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)pointer); if (context) { @@ -2157,7 +2156,7 @@ void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *param Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribfv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -2183,7 +2182,7 @@ void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribiv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -2208,8 +2207,7 @@ void GL_APIENTRY GL_Hint(GLenum target, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLHint, "context = %d, target = %s, mode = %s", CID(context), - GLenumToString(GLenumGroup::HintTarget, target), - GLenumToString(GLenumGroup::HintMode, mode)); + GLenumToString(GLESEnum::HintTarget, target), GLenumToString(GLESEnum::HintMode, mode)); if (context) { @@ -2262,7 +2260,7 @@ GLboolean GL_APIENTRY GL_IsEnabled(GLenum cap) { Context *context = GetValidGlobalContext(); EVENT(context, GLIsEnabled, "context = %d, cap = %s", CID(context), - GLenumToString(GLenumGroup::EnableCap, cap)); + GLenumToString(GLESEnum::EnableCap, cap)); GLboolean returnValue; if (context) @@ -2492,7 +2490,7 @@ void GL_APIENTRY GL_PixelStorei(GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLPixelStorei, "context = %d, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::PixelStoreParameter, pname), param); + GLenumToString(GLESEnum::PixelStoreParameter, pname), param); if (context) { @@ -2548,8 +2546,8 @@ void GL_APIENTRY GL_ReadPixels(GLint x, EVENT(context, GLReadPixels, "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, pixels = " "0x%016" PRIxPTR "", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -2601,8 +2599,8 @@ void GL_APIENTRY GL_RenderbufferStorage(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLRenderbufferStorage, "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context), - GLenumToString(GLenumGroup::RenderbufferTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); if (context) { @@ -2674,16 +2672,16 @@ void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height) void GL_APIENTRY GL_ShaderBinary(GLsizei count, const GLuint *shaders, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length) { Context *context = GetValidGlobalContext(); EVENT(context, GLShaderBinary, "context = %d, count = %d, shaders = 0x%016" PRIxPTR - ", binaryformat = %s, binary = 0x%016" PRIxPTR ", length = %d", + ", binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d", CID(context), count, (uintptr_t)shaders, - GLenumToString(GLenumGroup::DefaultGroup, binaryformat), (uintptr_t)binary, length); + GLenumToString(GLESEnum::ShaderBinaryFormat, binaryFormat), (uintptr_t)binary, length); if (context) { @@ -2691,12 +2689,12 @@ void GL_APIENTRY GL_ShaderBinary(GLsizei count, SCOPED_SHARE_CONTEXT_LOCK(context); bool isCallValid = (context->skipValidation() || ValidateShaderBinary(context, angle::EntryPoint::GLShaderBinary, count, - shadersPacked, binaryformat, binary, length)); + shadersPacked, binaryFormat, binary, length)); if (isCallValid) { - context->shaderBinary(count, shadersPacked, binaryformat, binary, length); + context->shaderBinary(count, shadersPacked, binaryFormat, binary, length); } - ANGLE_CAPTURE_GL(ShaderBinary, isCallValid, context, count, shadersPacked, binaryformat, + ANGLE_CAPTURE_GL(ShaderBinary, isCallValid, context, count, shadersPacked, binaryFormat, binary, length); } else @@ -2739,7 +2737,7 @@ void GL_APIENTRY GL_StencilFunc(GLenum func, GLint ref, GLuint mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLStencilFunc, "context = %d, func = %s, ref = %d, mask = %u", CID(context), - GLenumToString(GLenumGroup::StencilFunction, func), ref, mask); + GLenumToString(GLESEnum::StencilFunction, func), ref, mask); if (context) { @@ -2763,8 +2761,8 @@ void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLu { Context *context = GetValidGlobalContext(); EVENT(context, GLStencilFuncSeparate, "context = %d, face = %s, func = %s, ref = %d, mask = %u", - CID(context), GLenumToString(GLenumGroup::StencilFaceDirection, face), - GLenumToString(GLenumGroup::StencilFunction, func), ref, mask); + CID(context), GLenumToString(GLESEnum::StencilFaceDirection, face), + GLenumToString(GLESEnum::StencilFunction, func), ref, mask); if (context) { @@ -2811,7 +2809,7 @@ void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLStencilMaskSeparate, "context = %d, face = %s, mask = %u", CID(context), - GLenumToString(GLenumGroup::StencilFaceDirection, face), mask); + GLenumToString(GLESEnum::StencilFaceDirection, face), mask); if (context) { @@ -2835,9 +2833,8 @@ void GL_APIENTRY GL_StencilOp(GLenum fail, GLenum zfail, GLenum zpass) { Context *context = GetValidGlobalContext(); EVENT(context, GLStencilOp, "context = %d, fail = %s, zfail = %s, zpass = %s", CID(context), - GLenumToString(GLenumGroup::StencilOp, fail), - GLenumToString(GLenumGroup::StencilOp, zfail), - GLenumToString(GLenumGroup::StencilOp, zpass)); + GLenumToString(GLESEnum::StencilOp, fail), GLenumToString(GLESEnum::StencilOp, zfail), + GLenumToString(GLESEnum::StencilOp, zpass)); if (context) { @@ -2862,10 +2859,9 @@ void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, Context *context = GetValidGlobalContext(); EVENT(context, GLStencilOpSeparate, "context = %d, face = %s, sfail = %s, dpfail = %s, dppass = %s", CID(context), - GLenumToString(GLenumGroup::StencilFaceDirection, face), - GLenumToString(GLenumGroup::StencilOp, sfail), - GLenumToString(GLenumGroup::StencilOp, dpfail), - GLenumToString(GLenumGroup::StencilOp, dppass)); + GLenumToString(GLESEnum::StencilFaceDirection, face), + GLenumToString(GLESEnum::StencilOp, sfail), GLenumToString(GLESEnum::StencilOp, dpfail), + GLenumToString(GLESEnum::StencilOp, dppass)); if (context) { @@ -2900,9 +2896,9 @@ void GL_APIENTRY GL_TexImage2D(GLenum target, EVENT(context, GLTexImage2D, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " "border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, - width, height, border, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat, + width, height, border, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -2930,8 +2926,8 @@ void GL_APIENTRY GL_TexParameterf(GLenum target, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterf, "context = %d, target = %s, pname = %s, param = %f", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), param); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), param); if (context) { @@ -2957,8 +2953,8 @@ void GL_APIENTRY GL_TexParameterfv(GLenum target, GLenum pname, const GLfloat *p Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -2983,8 +2979,8 @@ void GL_APIENTRY GL_TexParameteri(GLenum target, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameteri, "context = %d, target = %s, pname = %s, param = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), param); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), param); if (context) { @@ -3010,8 +3006,8 @@ void GL_APIENTRY GL_TexParameteriv(GLenum target, GLenum pname, const GLint *par Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameteriv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -3046,9 +3042,9 @@ void GL_APIENTRY GL_TexSubImage2D(GLenum target, EVENT(context, GLTexSubImage2D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " "%d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - width, height, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + width, height, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -3818,7 +3814,7 @@ void GL_APIENTRY GL_VertexAttribPointer(GLuint index, EVENT(context, GLVertexAttribPointer, "context = %d, index = %u, size = %d, type = %s, normalized = %s, stride = %d, pointer = " "0x%016" PRIxPTR "", - CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type), + CID(context), index, size, GLenumToString(GLESEnum::VertexAttribPointerType, type), GLbooleanToString(normalized), stride, (uintptr_t)pointer); if (context) diff --git a/src/libGLESv2/entry_points_gles_2_0_autogen.h b/src/libGLESv2/entry_points_gles_2_0_autogen.h index 5defcfd65..5f5bab31e 100644 --- a/src/libGLESv2/entry_points_gles_2_0_autogen.h +++ b/src/libGLESv2/entry_points_gles_2_0_autogen.h @@ -216,7 +216,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_SampleCoverage(GLfloat value, GLboolean invert) ANGLE_EXPORT void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height); ANGLE_EXPORT void GL_APIENTRY GL_ShaderBinary(GLsizei count, const GLuint *shaders, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length); ANGLE_EXPORT void GL_APIENTRY GL_ShaderSource(GLuint shader, diff --git a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp index 9a3d53644..a5d8c1172 100644 --- a/src/libGLESv2/entry_points_gles_3_0_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_3_0_autogen.cpp @@ -26,7 +26,7 @@ void GL_APIENTRY GL_BeginQuery(GLenum target, GLuint id) { Context *context = GetValidGlobalContext(); EVENT(context, GLBeginQuery, "context = %d, target = %s, id = %u", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target), id); + GLenumToString(GLESEnum::QueryTarget, target), id); if (context) { @@ -52,7 +52,7 @@ void GL_APIENTRY GL_BeginTransformFeedback(GLenum primitiveMode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBeginTransformFeedback, "context = %d, primitiveMode = %s", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, primitiveMode)); + GLenumToString(GLESEnum::PrimitiveType, primitiveMode)); if (context) { @@ -78,7 +78,7 @@ void GL_APIENTRY GL_BindBufferBase(GLenum target, GLuint index, GLuint buffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindBufferBase, "context = %d, target = %s, index = %u, buffer = %u", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer); + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), index, buffer); if (context) { @@ -106,7 +106,7 @@ GL_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, Context *context = GetValidGlobalContext(); EVENT(context, GLBindBufferRange, "context = %d, target = %s, index = %u, buffer = %u, offset = %llu, size = %llu", - CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, buffer, + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), index, buffer, static_cast(offset), static_cast(size)); if (context) @@ -160,7 +160,7 @@ void GL_APIENTRY GL_BindTransformFeedback(GLenum target, GLuint id) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindTransformFeedback, "context = %d, target = %s, id = %u", CID(context), - GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id); + GLenumToString(GLESEnum::BindTransformFeedbackTarget, target), id); if (context) { @@ -222,8 +222,8 @@ void GL_APIENTRY GL_BlitFramebuffer(GLint srcX0, "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(), - GLenumToString(GLenumGroup::BlitFramebufferFilter, filter)); + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); if (context) { @@ -251,7 +251,7 @@ void GL_APIENTRY GL_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth Context *context = GetValidGlobalContext(); EVENT(context, GLClearBufferfi, "context = %d, buffer = %s, drawbuffer = %d, depth = %f, stencil = %d", CID(context), - GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, depth, stencil); + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, depth, stencil); if (context) { @@ -276,7 +276,7 @@ void GL_APIENTRY GL_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat Context *context = GetValidGlobalContext(); EVENT(context, GLClearBufferfv, "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value); + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) { @@ -301,7 +301,7 @@ void GL_APIENTRY GL_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * Context *context = GetValidGlobalContext(); EVENT(context, GLClearBufferiv, "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value); + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) { @@ -326,7 +326,7 @@ void GL_APIENTRY GL_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLClearBufferuiv, "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::Buffer, buffer), drawbuffer, (uintptr_t)value); + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); if (context) { @@ -351,7 +351,7 @@ GLenum GL_APIENTRY GL_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 tim Context *context = GetValidGlobalContext(); EVENT(context, GLClientWaitSync, "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu", CID(context), - (uintptr_t)sync, GLbitfieldToString(GLenumGroup::SyncObjectMask, flags).c_str(), + (uintptr_t)sync, GLbitfieldToString(GLESEnum::SyncObjectMask, flags).c_str(), static_cast(timeout)); GLenum returnValue; @@ -393,8 +393,8 @@ void GL_APIENTRY GL_CompressedTexImage3D(GLenum target, EVENT(context, GLCompressedTexImage3D, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border, imageSize, (uintptr_t)data); if (context) @@ -436,8 +436,8 @@ void GL_APIENTRY GL_CompressedTexSubImage3D(GLenum target, EVENT(context, GLCompressedTexSubImage3D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format), + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) @@ -473,8 +473,8 @@ void GL_APIENTRY GL_CopyBufferSubData(GLenum readTarget, EVENT(context, GLCopyBufferSubData, "context = %d, readTarget = %s, writeTarget = %s, readOffset = %llu, writeOffset = %llu, " "size = %llu", - CID(context), GLenumToString(GLenumGroup::CopyBufferSubDataTarget, readTarget), - GLenumToString(GLenumGroup::CopyBufferSubDataTarget, writeTarget), + CID(context), GLenumToString(GLESEnum::CopyBufferSubDataTarget, readTarget), + GLenumToString(GLESEnum::CopyBufferSubDataTarget, writeTarget), static_cast(readOffset), static_cast(writeOffset), static_cast(size)); @@ -515,7 +515,7 @@ void GL_APIENTRY GL_CopyTexSubImage3D(GLenum target, EVENT(context, GLCopyTexSubImage3D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = " "%d, y = %d, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, zoffset, x, y, width, height); if (context) @@ -672,7 +672,7 @@ void GL_APIENTRY GL_DrawArraysInstanced(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstanced, "context = %d, mode = %s, first = %d, count = %d, instancecount = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, instancecount); + GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instancecount); if (context) { @@ -729,8 +729,8 @@ void GL_APIENTRY GL_DrawElementsInstanced(GLenum mode, EVENT(context, GLDrawElementsInstanced, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount); if (context) { @@ -765,8 +765,8 @@ void GL_APIENTRY GL_DrawRangeElements(GLenum mode, EVENT(context, GLDrawRangeElements, "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices); if (context) { @@ -794,7 +794,7 @@ void GL_APIENTRY GL_EndQuery(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLEndQuery, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target)); + GLenumToString(GLESEnum::QueryTarget, target)); if (context) { @@ -841,8 +841,8 @@ GLsync GL_APIENTRY GL_FenceSync(GLenum condition, GLbitfield flags) { Context *context = GetValidGlobalContext(); EVENT(context, GLFenceSync, "context = %d, condition = %s, flags = %s", CID(context), - GLenumToString(GLenumGroup::SyncCondition, condition), - GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str()); + GLenumToString(GLESEnum::SyncCondition, condition), + GLbitfieldToString(GLESEnum::SyncBehaviorFlags, flags).c_str()); GLsync returnValue; if (context) @@ -874,7 +874,7 @@ void GL_APIENTRY GL_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsiz Context *context = GetValidGlobalContext(); EVENT(context, GLFlushMappedBufferRange, "context = %d, target = %s, offset = %llu, length = %llu", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(offset), static_cast(length)); if (context) @@ -907,8 +907,8 @@ void GL_APIENTRY GL_FramebufferTextureLayer(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTextureLayer, "context = %d, target = %s, attachment = %s, texture = %u, level = %d, layer = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level, layer); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level, layer); if (context) { @@ -1079,7 +1079,7 @@ void GL_APIENTRY GL_GetActiveUniformBlockiv(GLuint program, "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), program, uniformBlockIndex, - GLenumToString(GLenumGroup::UniformBlockPName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::UniformBlockPName, pname), (uintptr_t)params); if (context) { @@ -1114,7 +1114,7 @@ void GL_APIENTRY GL_GetActiveUniformsiv(GLuint program, "context = %d, program = %u, uniformCount = %d, uniformIndices = 0x%016" PRIxPTR ", pname = %s, params = 0x%016" PRIxPTR "", CID(context), program, uniformCount, (uintptr_t)uniformIndices, - GLenumToString(GLenumGroup::UniformPName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::UniformPName, pname), (uintptr_t)params); if (context) { @@ -1143,8 +1143,8 @@ void GL_APIENTRY GL_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 Context *context = GetValidGlobalContext(); EVENT(context, GLGetBufferParameteri64v, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -1171,8 +1171,8 @@ void GL_APIENTRY GL_GetBufferPointerv(GLenum target, GLenum pname, void **params Context *context = GetValidGlobalContext(); EVENT(context, GLGetBufferPointerv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -1233,7 +1233,7 @@ void GL_APIENTRY GL_GetInteger64i_v(GLenum target, GLuint index, GLint64 *data) Context *context = GetValidGlobalContext(); EVENT(context, GLGetInteger64i_v, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); + GLenumToString(GLESEnum::GetPName, target), index, (uintptr_t)data); if (context) { @@ -1257,7 +1257,7 @@ void GL_APIENTRY GL_GetInteger64v(GLenum pname, GLint64 *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetInteger64v, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -1282,7 +1282,7 @@ void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLint *data) Context *context = GetValidGlobalContext(); EVENT(context, GLGetIntegeri_v, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); + GLenumToString(GLESEnum::GetPName, target), index, (uintptr_t)data); if (context) { @@ -1305,16 +1305,16 @@ void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLint *data) void GL_APIENTRY GL_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetInternalformativ, - "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, params = " + "context = %d, target = %s, internalformat = %s, pname = %s, count = %d, params = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), - GLenumToString(GLenumGroup::InternalFormatPName, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::InternalFormat, internalformat), + GLenumToString(GLESEnum::InternalFormatPName, pname), count, (uintptr_t)params); if (context) { @@ -1322,13 +1322,13 @@ void GL_APIENTRY GL_GetInternalformativ(GLenum target, bool isCallValid = (context->skipValidation() || ValidateGetInternalformativ(context, angle::EntryPoint::GLGetInternalformativ, target, - internalformat, pname, bufSize, params)); + internalformat, pname, count, params)); if (isCallValid) { - context->getInternalformativ(target, internalformat, pname, bufSize, params); + context->getInternalformativ(target, internalformat, pname, count, params); } ANGLE_CAPTURE_GL(GetInternalformativ, isCallValid, context, target, internalformat, pname, - bufSize, params); + count, params); } else { @@ -1375,7 +1375,7 @@ void GL_APIENTRY GL_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryObjectuiv, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -1402,8 +1402,8 @@ void GL_APIENTRY GL_GetQueryiv(GLenum target, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryiv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target), - GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryTarget, target), + GLenumToString(GLESEnum::QueryParameterName, pname), (uintptr_t)params); if (context) { @@ -1429,7 +1429,7 @@ void GL_APIENTRY GL_GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterfv, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), (uintptr_t)params); if (context) { @@ -1456,7 +1456,7 @@ void GL_APIENTRY GL_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *p Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameteriv, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -1482,7 +1482,7 @@ const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetStringi, "context = %d, name = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::StringName, name), index); + GLenumToString(GLESEnum::StringName, name), index); const GLubyte *returnValue; if (context) @@ -1510,26 +1510,26 @@ const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index) } void GL_APIENTRY -GL_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) +GL_GetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) { Context *context = GetGlobalContext(); EVENT(context, GLGetSynciv, - "context = %d, sync = 0x%016" PRIxPTR - ", pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", values = 0x%016" PRIxPTR "", - CID(context), (uintptr_t)sync, GLenumToString(GLenumGroup::SyncParameterName, pname), - bufSize, (uintptr_t)length, (uintptr_t)values); + "context = %d, sync = 0x%016" PRIxPTR ", pname = %s, count = %d, length = 0x%016" PRIxPTR + ", values = 0x%016" PRIxPTR "", + CID(context), (uintptr_t)sync, GLenumToString(GLESEnum::SyncParameterName, pname), count, + (uintptr_t)length, (uintptr_t)values); if (context) { SCOPED_SHARE_CONTEXT_LOCK(context); bool isCallValid = (context->skipValidation() || ValidateGetSynciv(context, angle::EntryPoint::GLGetSynciv, - sync, pname, bufSize, length, values)); + sync, pname, count, length, values)); if (isCallValid) { - context->getSynciv(sync, pname, bufSize, length, values); + context->getSynciv(sync, pname, count, length, values); } - ANGLE_CAPTURE_GL(GetSynciv, isCallValid, context, sync, pname, bufSize, length, values); + ANGLE_CAPTURE_GL(GetSynciv, isCallValid, context, sync, pname, count, length, values); } else {} @@ -1673,7 +1673,7 @@ void GL_APIENTRY GL_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribIiv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params); + GLenumToString(GLESEnum::VertexAttribEnum, pname), (uintptr_t)params); if (context) { @@ -1699,7 +1699,7 @@ void GL_APIENTRY GL_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *para Context *context = GetValidGlobalContext(); EVENT(context, GLGetVertexAttribIuiv, "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, - GLenumToString(GLenumGroup::VertexAttribEnum, pname), (uintptr_t)params); + GLenumToString(GLESEnum::VertexAttribEnum, pname), (uintptr_t)params); if (context) { @@ -1727,7 +1727,7 @@ void GL_APIENTRY GL_InvalidateFramebuffer(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLInvalidateFramebuffer, "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments, + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, (uintptr_t)attachments); if (context) @@ -1762,7 +1762,7 @@ void GL_APIENTRY GL_InvalidateSubFramebuffer(GLenum target, EVENT(context, GLInvalidateSubFramebuffer, "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR ", x = %d, y = %d, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments, + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, (uintptr_t)attachments, x, y, width, height); if (context) @@ -1948,9 +1948,9 @@ void *GL_APIENTRY GL_MapBufferRange(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLMapBufferRange, "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(offset), static_cast(length), - GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str()); + GLbitfieldToString(GLESEnum::MapBufferAccessMask, access).c_str()); void *returnValue; if (context) @@ -2010,7 +2010,7 @@ void GL_APIENTRY GL_ProgramBinary(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLProgramBinary, "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d", - CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat), + CID(context), program, GLenumToString(GLESEnum::AllEnums, binaryFormat), (uintptr_t)binary, length); if (context) @@ -2037,7 +2037,7 @@ void GL_APIENTRY GL_ProgramParameteri(GLuint program, GLenum pname, GLint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLProgramParameteri, "context = %d, program = %u, pname = %s, value = %d", - CID(context), program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value); + CID(context), program, GLenumToString(GLESEnum::ProgramParameterPName, pname), value); if (context) { @@ -2063,7 +2063,7 @@ void GL_APIENTRY GL_ReadBuffer(GLenum src) { Context *context = GetValidGlobalContext(); EVENT(context, GLReadBuffer, "context = %d, src = %s", CID(context), - GLenumToString(GLenumGroup::ReadBufferMode, src)); + GLenumToString(GLESEnum::ReadBufferMode, src)); if (context) { @@ -2091,8 +2091,8 @@ void GL_APIENTRY GL_RenderbufferStorageMultisample(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLRenderbufferStorageMultisample, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); if (context) { @@ -2141,7 +2141,7 @@ void GL_APIENTRY GL_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat para { Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterf, "context = %d, sampler = %u, pname = %s, param = %f", - CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param); + CID(context), sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), param); if (context) { @@ -2168,7 +2168,7 @@ void GL_APIENTRY GL_SamplerParameterfv(GLuint sampler, GLenum pname, const GLflo Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterfv, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), (uintptr_t)param); if (context) { @@ -2194,7 +2194,7 @@ void GL_APIENTRY GL_SamplerParameteri(GLuint sampler, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameteri, "context = %d, sampler = %u, pname = %s, param = %d", - CID(context), sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), param); + CID(context), sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), param); if (context) { @@ -2221,7 +2221,7 @@ void GL_APIENTRY GL_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameteriv, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -2258,9 +2258,9 @@ void GL_APIENTRY GL_TexImage3D(GLenum target, EVENT(context, GLTexImage3D, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, - width, height, depth, border, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat, + width, height, depth, border, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -2290,8 +2290,8 @@ GL_TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei wi Context *context = GetValidGlobalContext(); EVENT(context, GLTexStorage2D, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height); if (context) { @@ -2325,8 +2325,8 @@ void GL_APIENTRY GL_TexStorage3D(GLenum target, EVENT(context, GLTexStorage3D, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, " "depth = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth); if (context) { @@ -2365,9 +2365,9 @@ void GL_APIENTRY GL_TexSubImage3D(GLenum target, EVENT(context, GLTexSubImage3D, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -2400,7 +2400,7 @@ void GL_APIENTRY GL_TransformFeedbackVaryings(GLuint program, EVENT(context, GLTransformFeedbackVaryings, "context = %d, program = %u, count = %d, varyings = 0x%016" PRIxPTR ", bufferMode = %s", CID(context), program, count, (uintptr_t)varyings, - GLenumToString(GLenumGroup::DefaultGroup, bufferMode)); + GLenumToString(GLESEnum::TransformFeedbackBufferMode, bufferMode)); if (context) { @@ -2849,7 +2849,7 @@ GLboolean GL_APIENTRY GL_UnmapBuffer(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLUnmapBuffer, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target)); + GLenumToString(GLESEnum::BufferTargetARB, target)); GLboolean returnValue; if (context) @@ -3004,8 +3004,8 @@ GL_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, c EVENT(context, GLVertexAttribIPointer, "context = %d, index = %u, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type), - stride, (uintptr_t)pointer); + CID(context), index, size, GLenumToString(GLESEnum::VertexAttribIType, type), stride, + (uintptr_t)pointer); if (context) { @@ -3033,7 +3033,7 @@ void GL_APIENTRY GL_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) Context *context = GetValidGlobalContext(); EVENT(context, GLWaitSync, "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu", CID(context), (uintptr_t)sync, - GLbitfieldToString(GLenumGroup::DefaultGroup, flags).c_str(), + GLbitfieldToString(GLESEnum::SyncBehaviorFlags, flags).c_str(), static_cast(timeout)); if (context) diff --git a/src/libGLESv2/entry_points_gles_3_0_autogen.h b/src/libGLESv2/entry_points_gles_3_0_autogen.h index 4ce0f616a..7660b8a42 100644 --- a/src/libGLESv2/entry_points_gles_3_0_autogen.h +++ b/src/libGLESv2/entry_points_gles_3_0_autogen.h @@ -140,7 +140,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLin ANGLE_EXPORT void GL_APIENTRY GL_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params); ANGLE_EXPORT void GL_APIENTRY GL_GetProgramBinary(GLuint program, GLsizei bufSize, @@ -155,7 +155,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterfv(GLuint sampler, ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params); ANGLE_EXPORT const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index); ANGLE_EXPORT void GL_APIENTRY -GL_GetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values); +GL_GetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); ANGLE_EXPORT void GL_APIENTRY GL_GetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, diff --git a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp index ea11ed953..a1345d5a6 100644 --- a/src/libGLESv2/entry_points_gles_3_1_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_3_1_autogen.cpp @@ -62,8 +62,8 @@ void GL_APIENTRY GL_BindImageTexture(GLuint unit, "context = %d, unit = %u, texture = %u, level = %d, layered = %s, layer = %d, access = " "%s, format = %s", CID(context), unit, texture, level, GLbooleanToString(layered), layer, - GLenumToString(GLenumGroup::BufferAccessARB, access), - GLenumToString(GLenumGroup::InternalFormat, format)); + GLenumToString(GLESEnum::BufferAccessARB, access), + GLenumToString(GLESEnum::InternalFormat, format)); if (context) { @@ -145,7 +145,7 @@ GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, GLsizei count, const GLc Context *context = GetValidGlobalContext(); EVENT(context, GLCreateShaderProgramv, "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings); + GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings); GLuint returnValue; if (context) @@ -256,7 +256,7 @@ void GL_APIENTRY GL_DrawArraysIndirect(GLenum mode, const void *indirect) { Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysIndirect, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect); if (context) { @@ -283,8 +283,8 @@ void GL_APIENTRY GL_DrawElementsIndirect(GLenum mode, GLenum type, const void *i Context *context = GetValidGlobalContext(); EVENT(context, GLDrawElementsIndirect, "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect); + GLenumToString(GLESEnum::PrimitiveType, mode), + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect); if (context) { @@ -312,8 +312,8 @@ void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint par { Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferParameteri, "context = %d, target = %s, pname = %s, param = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferParameterName, pname), param); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferParameterName, pname), param); if (context) { @@ -365,7 +365,7 @@ void GL_APIENTRY GL_GetBooleani_v(GLenum target, GLuint index, GLboolean *data) Context *context = GetValidGlobalContext(); EVENT(context, GLGetBooleani_v, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data); + GLenumToString(GLESEnum::BufferTargetARB, target), index, (uintptr_t)data); if (context) { @@ -390,9 +390,8 @@ void GL_APIENTRY GL_GetFramebufferParameteriv(GLenum target, GLenum pname, GLint Context *context = GetValidGlobalContext(); EVENT(context, GLGetFramebufferParameteriv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), - (uintptr_t)params); + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); if (context) { @@ -418,7 +417,7 @@ void GL_APIENTRY GL_GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) Context *context = GetValidGlobalContext(); EVENT(context, GLGetMultisamplefv, "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val); + GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val); if (context) { @@ -447,8 +446,8 @@ void GL_APIENTRY GL_GetProgramInterfaceiv(GLuint program, EVENT(context, GLGetProgramInterfaceiv, "context = %d, program = %u, programInterface = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), - GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params); + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + GLenumToString(GLESEnum::ProgramInterfacePName, pname), (uintptr_t)params); if (context) { @@ -508,7 +507,7 @@ void GL_APIENTRY GL_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *p Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramPipelineiv, "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params); + pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params); if (context) { @@ -537,7 +536,7 @@ GLuint GL_APIENTRY GL_GetProgramResourceIndex(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramResourceIndex, "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), (uintptr_t)name); GLuint returnValue; @@ -576,7 +575,7 @@ GLint GL_APIENTRY GL_GetProgramResourceLocation(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramResourceLocation, "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), (uintptr_t)name); GLint returnValue; @@ -621,7 +620,7 @@ void GL_APIENTRY GL_GetProgramResourceName(GLuint program, EVENT(context, GLGetProgramResourceName, "context = %d, program = %u, programInterface = %s, index = %u, bufSize = %d, length = " "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), index, bufSize, (uintptr_t)length, (uintptr_t)name); if (context) @@ -651,33 +650,32 @@ void GL_APIENTRY GL_GetProgramResourceiv(GLuint program, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramResourceiv, "context = %d, program = %u, programInterface = %s, index = %u, propCount = %d, props = " - "0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), - index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params); + "0x%016" PRIxPTR ", count = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + index, propCount, (uintptr_t)props, count, (uintptr_t)length, (uintptr_t)params); if (context) { ShaderProgramID programPacked = PackParam(program); SCOPED_SHARE_CONTEXT_LOCK(context); - bool isCallValid = - (context->skipValidation() || - ValidateGetProgramResourceiv(context, angle::EntryPoint::GLGetProgramResourceiv, - programPacked, programInterface, index, propCount, props, - bufSize, length, params)); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramResourceiv( + context, angle::EntryPoint::GLGetProgramResourceiv, programPacked, + programInterface, index, propCount, props, count, length, params)); if (isCallValid) { context->getProgramResourceiv(programPacked, programInterface, index, propCount, props, - bufSize, length, params); + count, length, params); } ANGLE_CAPTURE_GL(GetProgramResourceiv, isCallValid, context, programPacked, - programInterface, index, propCount, props, bufSize, length, params); + programInterface, index, propCount, props, count, length, params); } else { @@ -693,8 +691,8 @@ void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexLevelParameterfv, "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -722,8 +720,8 @@ void GL_APIENTRY GL_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pn Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexLevelParameteriv, "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -782,7 +780,7 @@ void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers) { Context *context = GetValidGlobalContext(); EVENT(context, GLMemoryBarrier, "context = %d, barriers = %s", CID(context), - GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str()); + GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); if (context) { @@ -806,7 +804,7 @@ void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers) { Context *context = GetValidGlobalContext(); EVENT(context, GLMemoryBarrierByRegion, "context = %d, barriers = %s", CID(context), - GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str()); + GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); if (context) { @@ -1871,7 +1869,7 @@ void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLSampleMaski, "context = %d, maskNumber = %u, mask = %s", CID(context), - maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str()); + maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str()); if (context) { @@ -1902,8 +1900,8 @@ void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target, EVENT(context, GLTexStorage2DMultisample, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, GLbooleanToString(fixedsamplelocations)); if (context) @@ -1932,8 +1930,8 @@ void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint { Context *context = GetValidGlobalContext(); EVENT(context, GLUseProgramStages, "context = %d, pipeline = %u, stages = %s, program = %u", - CID(context), pipeline, - GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program); + CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(), + program); if (context) { @@ -2017,7 +2015,7 @@ void GL_APIENTRY GL_VertexAttribFormat(GLuint attribindex, EVENT(context, GLVertexAttribFormat, "context = %d, attribindex = %u, size = %d, type = %s, normalized = %s, relativeoffset = " "%u", - CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), + CID(context), attribindex, size, GLenumToString(GLESEnum::VertexAttribType, type), GLbooleanToString(normalized), relativeoffset); if (context) @@ -2049,7 +2047,7 @@ void GL_APIENTRY GL_VertexAttribIFormat(GLuint attribindex, Context *context = GetValidGlobalContext(); EVENT(context, GLVertexAttribIFormat, "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), - attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), relativeoffset); + attribindex, size, GLenumToString(GLESEnum::VertexAttribIType, type), relativeoffset); if (context) { diff --git a/src/libGLESv2/entry_points_gles_3_1_autogen.h b/src/libGLESv2/entry_points_gles_3_1_autogen.h index 91dd7ccd6..8af020ef1 100644 --- a/src/libGLESv2/entry_points_gles_3_1_autogen.h +++ b/src/libGLESv2/entry_points_gles_3_1_autogen.h @@ -74,7 +74,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_GetProgramResourceiv(GLuint program, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params); ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target, diff --git a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp index 1f6eb039b..831c92ace 100644 --- a/src/libGLESv2/entry_points_gles_3_2_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_3_2_autogen.cpp @@ -48,8 +48,8 @@ void GL_APIENTRY GL_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum mo { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationSeparatei, "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", - CID(context), buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB), - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha)); + CID(context), buf, GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB), + GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha)); if (context) { @@ -74,7 +74,7 @@ void GL_APIENTRY GL_BlendEquationi(GLuint buf, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationi, "context = %d, buf = %u, mode = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendEquationModeEXT, mode)); + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); if (context) { @@ -100,10 +100,10 @@ GL_BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFuncSeparatei, "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s", - CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB), - GLenumToString(GLenumGroup::BlendingFactor, dstRGB), - GLenumToString(GLenumGroup::BlendingFactor, srcAlpha), - GLenumToString(GLenumGroup::BlendingFactor, dstAlpha)); + CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB), + GLenumToString(GLESEnum::BlendingFactor, dstRGB), + GLenumToString(GLESEnum::BlendingFactor, srcAlpha), + GLenumToString(GLESEnum::BlendingFactor, dstAlpha)); if (context) { @@ -129,8 +129,8 @@ void GL_APIENTRY GL_BlendFunci(GLuint buf, GLenum src, GLenum dst) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFunci, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendingFactor, src), - GLenumToString(GLenumGroup::BlendingFactor, dst)); + GLenumToString(GLESEnum::BlendingFactor, src), + GLenumToString(GLESEnum::BlendingFactor, dst)); if (context) { @@ -196,10 +196,10 @@ void GL_APIENTRY GL_CopyImageSubData(GLuint srcName, "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = " "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, " "srcWidth = %d, srcHeight = %d, srcDepth = %d", - CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget), + CID(context), srcName, GLenumToString(GLESEnum::CopyImageSubDataTarget, srcTarget), srcLevel, srcX, srcY, srcZ, dstName, - GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, - dstZ, srcWidth, srcHeight, srcDepth); + GLenumToString(GLESEnum::CopyImageSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); if (context) { @@ -262,9 +262,9 @@ void GL_APIENTRY GL_DebugMessageControl(GLenum source, EVENT(context, GLDebugMessageControl, "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR ", enabled = %s", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), - GLenumToString(GLenumGroup::DebugType, type), - GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids, + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), + GLenumToString(GLESEnum::DebugSeverity, severity), count, (uintptr_t)ids, GLbooleanToString(enabled)); if (context) @@ -298,9 +298,9 @@ void GL_APIENTRY GL_DebugMessageInsert(GLenum source, EVENT(context, GLDebugMessageInsert, "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), - GLenumToString(GLenumGroup::DebugType, type), id, - GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf); + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), id, + GLenumToString(GLESEnum::DebugSeverity, severity), length, (uintptr_t)buf); if (context) { @@ -326,7 +326,7 @@ void GL_APIENTRY GL_Disablei(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLDisablei, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -356,8 +356,8 @@ void GL_APIENTRY GL_DrawElementsBaseVertex(GLenum mode, EVENT(context, GLDrawElementsBaseVertex, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -392,8 +392,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertex(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseVertex, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, basevertex); if (context) @@ -431,8 +431,8 @@ void GL_APIENTRY GL_DrawRangeElementsBaseVertex(GLenum mode, EVENT(context, GLDrawRangeElementsBaseVertex, "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " "0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -461,7 +461,7 @@ void GL_APIENTRY GL_Enablei(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLEnablei, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -488,8 +488,8 @@ void GL_APIENTRY GL_FramebufferTexture(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTexture, "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level); + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level); if (context) { @@ -595,7 +595,7 @@ GL_GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *leng EVENT(context, GLGetObjectLabel, "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR ", label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize, + CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, bufSize, (uintptr_t)length, (uintptr_t)label); if (context) @@ -651,7 +651,7 @@ void GL_APIENTRY GL_GetPointerv(GLenum pname, void **params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetPointerv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPointervPName, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::GetPointervPName, pname), (uintptr_t)params); if (context) { @@ -676,7 +676,7 @@ void GL_APIENTRY GL_GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint * Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIiv, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -704,7 +704,7 @@ void GL_APIENTRY GL_GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIuiv, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -732,8 +732,8 @@ void GL_APIENTRY GL_GetTexParameterIiv(GLenum target, GLenum pname, GLint *param Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIiv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -760,8 +760,8 @@ void GL_APIENTRY GL_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *par Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIuiv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -871,7 +871,7 @@ GLboolean GL_APIENTRY GL_IsEnabledi(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLIsEnabledi, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); GLboolean returnValue; if (context) @@ -926,7 +926,7 @@ void GL_APIENTRY GL_ObjectLabel(GLenum identifier, GLuint name, GLsizei length, Context *context = GetValidGlobalContext(); EVENT(context, GLObjectLabel, "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length, + CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, length, (uintptr_t)label); if (context) @@ -976,7 +976,7 @@ void GL_APIENTRY GL_PatchParameteri(GLenum pname, GLint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLPatchParameteri, "context = %d, pname = %s, value = %d", CID(context), - GLenumToString(GLenumGroup::PatchParameterName, pname), value); + GLenumToString(GLESEnum::PatchParameterName, pname), value); if (context) { @@ -1058,7 +1058,7 @@ void GL_APIENTRY GL_PushDebugGroup(GLenum source, GLuint id, GLsizei length, con Context *context = GetValidGlobalContext(); EVENT(context, GLPushDebugGroup, "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length, + CID(context), GLenumToString(GLESEnum::DebugSource, source), id, length, (uintptr_t)message); if (context) @@ -1092,8 +1092,8 @@ void GL_APIENTRY GL_ReadnPixels(GLint x, EVENT(context, GLReadnPixels, "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " "= %d, data = 0x%016" PRIxPTR "", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data); + CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), bufSize, (uintptr_t)data); if (context) { @@ -1119,7 +1119,7 @@ void GL_APIENTRY GL_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLin Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIiv, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -1146,7 +1146,7 @@ void GL_APIENTRY GL_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLu Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIuiv, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -1172,8 +1172,8 @@ void GL_APIENTRY GL_TexBuffer(GLenum target, GLenum internalformat, GLuint buffe { Context *context = GetValidGlobalContext(); EVENT(context, GLTexBuffer, "context = %d, target = %s, internalformat = %s, buffer = %u", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer); if (context) { @@ -1205,8 +1205,8 @@ void GL_APIENTRY GL_TexBufferRange(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexBufferRange, "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer, static_cast(offset), static_cast(size)); if (context) @@ -1236,8 +1236,8 @@ void GL_APIENTRY GL_TexParameterIiv(GLenum target, GLenum pname, const GLint *pa Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIiv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -1263,8 +1263,8 @@ void GL_APIENTRY GL_TexParameterIuiv(GLenum target, GLenum pname, const GLuint * Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIuiv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -1297,8 +1297,8 @@ void GL_APIENTRY GL_TexStorage3DMultisample(GLenum target, EVENT(context, GLTexStorage3DMultisample, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth, GLbooleanToString(fixedsamplelocations)); if (context) diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/src/libGLESv2/entry_points_gles_ext_autogen.cpp index 28df8359b..042a882e3 100644 --- a/src/libGLESv2/entry_points_gles_ext_autogen.cpp +++ b/src/libGLESv2/entry_points_gles_ext_autogen.cpp @@ -141,7 +141,7 @@ void GL_APIENTRY GL_GetPerfMonitorCounterDataAMD(GLuint monitor, EVENT(context, GLGetPerfMonitorCounterDataAMD, "context = %d, monitor = %u, pname = %s, dataSize = %d, data = 0x%016" PRIxPTR ", bytesWritten = 0x%016" PRIxPTR "", - CID(context), monitor, GLenumToString(GLenumGroup::DefaultGroup, pname), dataSize, + CID(context), monitor, GLenumToString(GLESEnum::AllEnums, pname), dataSize, (uintptr_t)data, (uintptr_t)bytesWritten); if (context) @@ -172,8 +172,7 @@ void GL_APIENTRY GL_GetPerfMonitorCounterInfoAMD(GLuint group, Context *context = GetValidGlobalContext(); EVENT(context, GLGetPerfMonitorCounterInfoAMD, "context = %d, group = %u, counter = %u, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), group, counter, GLenumToString(GLenumGroup::DefaultGroup, pname), - (uintptr_t)data); + CID(context), group, counter, GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)data); if (context) { @@ -365,8 +364,8 @@ void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstancedBaseInstanceANGLE, "context = %d, mode = %s, first = %d, count = %d, instanceCount = %d, baseInstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, - instanceCount, baseInstance); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instanceCount, + baseInstance); if (context) { @@ -402,8 +401,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceANGLE, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instanceCount = %d, baseVertex = %d, baseInstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instanceCount, baseVertex, baseInstance); if (context) @@ -442,7 +441,7 @@ void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode, EVENT(context, GLMultiDrawArraysInstancedBaseInstanceANGLE, "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR ", instanceCounts = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount); if (context) @@ -483,8 +482,8 @@ GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR ", instanceCounts = 0x%016" PRIxPTR ", baseVertices = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount); if (context) @@ -532,10 +531,10 @@ void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId, "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = " "%s, unpackUnmultiplyAlpha = %s", - CID(context), sourceId, sourceLevel, - GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat, - GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY), - GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType), + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); if (context) { @@ -589,10 +588,10 @@ void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId, "= %d, xoffset = %d, yoffset = %d, zoffset = %d, x = %d, y = %d, z = %d, width = %d, " "height = %d, depth = %d, unpackFlipY = %s, unpackPremultiplyAlpha = %s, " "unpackUnmultiplyAlpha = %s", - CID(context), sourceId, sourceLevel, - GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset, - yoffset, zoffset, x, y, z, width, height, depth, GLbooleanToString(unpackFlipY), - GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, depth, + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); if (context) { @@ -643,8 +642,8 @@ void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0, "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(), - GLenumToString(GLenumGroup::BlitFramebufferFilter, filter)); + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); if (context) { @@ -677,8 +676,8 @@ void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLRenderbufferStorageMultisampleANGLE, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); if (context) { @@ -708,9 +707,9 @@ GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void EVENT(context, GLGetTexImageANGLE, "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type), + (uintptr_t)pixels); if (context) { @@ -737,7 +736,7 @@ void GL_APIENTRY GL_GetCompressedTexImageANGLE(GLenum target, GLint level, void Context *context = GetValidGlobalContext(); EVENT(context, GLGetCompressedTexImageANGLE, "context = %d, target = %s, level = %d, pixels = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), level, (uintptr_t)pixels); + GLenumToString(GLESEnum::TextureTarget, target), level, (uintptr_t)pixels); if (context) { @@ -768,9 +767,9 @@ void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetRenderbufferImageANGLE, "context = %d, target = %s, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type), + (uintptr_t)pixels); if (context) { @@ -801,8 +800,8 @@ void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexLevelParameterivANGLE, "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -833,8 +832,8 @@ void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexLevelParameterfvANGLE, "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -866,7 +865,7 @@ void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstancedANGLE, "context = %d, mode = %s, first = %d, count = %d, primcount = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount); + GLenumToString(GLESEnum::PrimitiveType, mode), first, count, primcount); if (context) { @@ -899,8 +898,8 @@ void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode, EVENT(context, GLDrawElementsInstancedANGLE, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", primcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, primcount); if (context) { @@ -966,11 +965,11 @@ void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target, "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " "memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, imageCreateInfoPNext = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, memory, static_cast(offset), - GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(), - GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), (uintptr_t)imageCreateInfoPNext); if (context) @@ -1016,11 +1015,11 @@ void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target, "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " "fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, usageFlags = " "%s, imageCreateInfoPNext = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, GLbooleanToString(fixedSampleLocations), memory, static_cast(offset), - GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(), - GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), (uintptr_t)imageCreateInfoPNext); if (context) @@ -1067,11 +1066,11 @@ void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target, "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " "depth = %d, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, " "imageCreateInfoPNext = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth, memory, static_cast(offset), - GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(), - GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), (uintptr_t)imageCreateInfoPNext); if (context) @@ -1119,11 +1118,11 @@ void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target, "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, " "usageFlags = %s, imageCreateInfoPNext = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth, GLbooleanToString(fixedSampleLocations), memory, static_cast(offset), - GLbitfieldToString(GLenumGroup::DefaultGroup, createFlags).c_str(), - GLbitfieldToString(GLenumGroup::DefaultGroup, usageFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), (uintptr_t)imageCreateInfoPNext); if (context) @@ -1163,7 +1162,7 @@ void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory, EVENT(context, GLImportMemoryZirconHandleANGLE, "context = %d, memory = %u, size = %llu, handleType = %s, handle = %u", CID(context), memory, static_cast(size), - GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle); + GLenumToString(GLESEnum::ExternalHandleType, handleType), handle); if (context) { @@ -1197,7 +1196,7 @@ void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode, EVENT(context, GLMultiDrawArraysANGLE, "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, (uintptr_t)counts, drawcount); if (context) @@ -1231,7 +1230,7 @@ void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode, EVENT(context, GLMultiDrawArraysInstancedANGLE, "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount); if (context) @@ -1266,8 +1265,8 @@ void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode, EVENT(context, GLMultiDrawElementsANGLE, "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount); if (context) { @@ -1302,8 +1301,8 @@ void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode, EVENT(context, GLMultiDrawElementsInstancedANGLE, "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, (uintptr_t)instanceCounts, drawcount); if (context) @@ -1339,7 +1338,7 @@ void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLProvokingVertexANGLE, "context = %d, mode = %s", CID(context), - GLenumToString(GLenumGroup::VertexProvokingMode, mode)); + GLenumToString(GLESEnum::VertexProvokingMode, mode)); if (context) { @@ -1419,8 +1418,8 @@ void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname, EVENT(context, GLGetBooleanvRobustANGLE, "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -1452,9 +1451,8 @@ void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target, EVENT(context, GLGetBufferParameterivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -1486,8 +1484,8 @@ void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname, EVENT(context, GLGetFloatvRobustANGLE, "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -1520,10 +1518,9 @@ void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target EVENT(context, GLGetFramebufferAttachmentParameterivRobustANGLE, "context = %d, target = %s, attachment = %s, pname = %s, bufSize = %d, length = " "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, attachment), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, attachment), GLenumToString(GLESEnum::AllEnums, pname), + bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -1556,8 +1553,8 @@ void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname, EVENT(context, GLGetIntegervRobustANGLE, "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)data); if (context) { @@ -1589,7 +1586,7 @@ void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program, EVENT(context, GLGetProgramivRobustANGLE, "context = %d, program = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), program, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -1621,9 +1618,8 @@ void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target, EVENT(context, GLGetRenderbufferParameterivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -1655,7 +1651,7 @@ void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader, EVENT(context, GLGetShaderivRobustANGLE, "context = %d, shader = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), shader, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -1687,9 +1683,8 @@ void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target, EVENT(context, GLGetTexParameterfvRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -1722,9 +1717,8 @@ void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target, EVENT(context, GLGetTexParameterivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -1825,7 +1819,7 @@ void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index, EVENT(context, GLGetVertexAttribfvRobustANGLE, "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -1858,7 +1852,7 @@ void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index, EVENT(context, GLGetVertexAttribivRobustANGLE, "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -1891,7 +1885,7 @@ void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index, EVENT(context, GLGetVertexAttribPointervRobustANGLE, "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", pointer = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)pointer); if (context) @@ -1931,9 +1925,9 @@ void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x, "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR ", pixels = 0x%016" PRIxPTR "", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length, - (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)pixels); + CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns, + (uintptr_t)rows, (uintptr_t)pixels); if (context) { @@ -1971,9 +1965,9 @@ void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target, EVENT(context, GLTexImage2DRobustANGLE, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " "border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat, - width, height, border, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width, + height, border, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); if (context) { @@ -2006,8 +2000,8 @@ void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterfvRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); if (context) { @@ -2038,8 +2032,8 @@ void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); if (context) { @@ -2077,9 +2071,9 @@ void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target, EVENT(context, GLTexSubImage2DRobustANGLE, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " "%d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, - width, height, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width, + height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); if (context) { @@ -2121,9 +2115,9 @@ void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " "depth = %d, border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, internalformat, - width, height, depth, border, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width, + height, depth, border, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); if (context) { @@ -2168,9 +2162,9 @@ void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width = " "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, zoffset, + width, height, depth, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); if (context) { @@ -2210,9 +2204,9 @@ void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target, EVENT(context, GLCompressedTexImage2DRobustANGLE, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, - GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border, - imageSize, dataSize, (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, border, imageSize, + dataSize, (uintptr_t)data); if (context) { @@ -2252,9 +2246,8 @@ void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target, EVENT(context, GLCompressedTexSubImage2DRobustANGLE, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " "%d, format = %s, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, - width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize, - (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width, + height, GLenumToString(GLESEnum::AllEnums, format), imageSize, dataSize, (uintptr_t)data); if (context) { @@ -2294,8 +2287,8 @@ void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target, EVENT(context, GLCompressedTexImage3DRobustANGLE, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, - GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border, + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, depth, border, imageSize, dataSize, (uintptr_t)data); if (context) @@ -2339,9 +2332,9 @@ void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, imageSize = %d, dataSize = %d, data = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::DefaultGroup, format), - imageSize, dataSize, (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::AllEnums, format), imageSize, + dataSize, (uintptr_t)data); if (context) { @@ -2378,9 +2371,8 @@ void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target, EVENT(context, GLGetQueryivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2413,8 +2405,8 @@ void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id, EVENT(context, GLGetQueryObjectuivRobustANGLE, "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -2447,9 +2439,8 @@ void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target, EVENT(context, GLGetBufferPointervRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2482,7 +2473,7 @@ void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target, EVENT(context, GLGetIntegeri_vRobustANGLE, "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, (uintptr_t)length, (uintptr_t)data); if (context) @@ -2516,10 +2507,9 @@ void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target, EVENT(context, GLGetInternalformativRobustANGLE, "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, length = " "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, internalformat), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, internalformat), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2552,7 +2542,7 @@ void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index, EVENT(context, GLGetVertexAttribIivRobustANGLE, "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -2585,7 +2575,7 @@ void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index, EVENT(context, GLGetVertexAttribIuivRobustANGLE, "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -2653,9 +2643,8 @@ void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program, EVENT(context, GLGetActiveUniformBlockivRobustANGLE, "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, bufSize = %d, length = " "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), program, uniformBlockIndex, - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), program, uniformBlockIndex, GLenumToString(GLESEnum::AllEnums, pname), + bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2690,8 +2679,8 @@ void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname, EVENT(context, GLGetInteger64vRobustANGLE, "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)data); if (context) { @@ -2723,7 +2712,7 @@ void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target, EVENT(context, GLGetInteger64i_vRobustANGLE, "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, (uintptr_t)length, (uintptr_t)data); if (context) @@ -2756,9 +2745,8 @@ void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target, EVENT(context, GLGetBufferParameteri64vRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2820,7 +2808,7 @@ void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler, Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterfvRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)param); if (context) @@ -2854,7 +2842,7 @@ void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler, EVENT(context, GLGetSamplerParameterivRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -2888,7 +2876,7 @@ void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler, EVENT(context, GLGetSamplerParameterfvRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -2922,9 +2910,8 @@ void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target, EVENT(context, GLGetFramebufferParameterivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2957,9 +2944,8 @@ void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program, EVENT(context, GLGetProgramInterfaceivRobustANGLE, "context = %d, program = %u, programInterface = %s, pname = %s, bufSize = %d, length = " "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), program, GLenumToString(GLESEnum::AllEnums, programInterface), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -2993,7 +2979,7 @@ void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target, EVENT(context, GLGetBooleani_vRobustANGLE, "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, (uintptr_t)length, (uintptr_t)data); if (context) @@ -3026,7 +3012,7 @@ void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname, EVENT(context, GLGetMultisamplefvRobustANGLE, "context = %d, pname = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR ", val = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, pname), index, bufSize, (uintptr_t)length, (uintptr_t)val); if (context) @@ -3060,9 +3046,8 @@ void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target, EVENT(context, GLGetTexLevelParameterivRobustANGLE, "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -3097,9 +3082,8 @@ void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target, EVENT(context, GLGetTexLevelParameterfvRobustANGLE, "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -3132,8 +3116,8 @@ void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname, EVENT(context, GLGetPointervRobustANGLERobustANGLE, "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -3172,9 +3156,9 @@ void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x, "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR ", data = 0x%016" PRIxPTR "", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::DefaultGroup, format), - GLenumToString(GLenumGroup::DefaultGroup, type), bufSize, (uintptr_t)length, - (uintptr_t)columns, (uintptr_t)rows, (uintptr_t)data); + CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns, + (uintptr_t)rows, (uintptr_t)data); if (context) { @@ -3307,8 +3291,8 @@ void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); if (context) { @@ -3339,8 +3323,8 @@ void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIuivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); if (context) { @@ -3373,9 +3357,8 @@ void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target, EVENT(context, GLGetTexParameterIivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -3408,9 +3391,8 @@ void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target, EVENT(context, GLGetTexParameterIuivRobustANGLE, "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) { @@ -3441,7 +3423,7 @@ void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler, Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIivRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)param); if (context) @@ -3473,7 +3455,7 @@ void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler, Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIuivRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)param); if (context) @@ -3507,7 +3489,7 @@ void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler, EVENT(context, GLGetSamplerParameterIivRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -3541,7 +3523,7 @@ void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler, EVENT(context, GLGetSamplerParameterIuivRobustANGLE, "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); if (context) @@ -3575,8 +3557,8 @@ void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id, EVENT(context, GLGetQueryObjectivRobustANGLE, "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -3607,8 +3589,8 @@ void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id, EVENT(context, GLGetQueryObjecti64vRobustANGLE, "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -3639,8 +3621,8 @@ void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id, EVENT(context, GLGetQueryObjectui64vRobustANGLE, "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", - CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, - (uintptr_t)length, (uintptr_t)params); + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); if (context) { @@ -3673,7 +3655,7 @@ void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore, Context *context = GetValidGlobalContext(); EVENT(context, GLImportSemaphoreZirconHandleANGLE, "context = %d, semaphore = %u, handleType = %s, handle = %u", CID(context), semaphore, - GLenumToString(GLenumGroup::ExternalHandleType, handleType), handle); + GLenumToString(GLESEnum::ExternalHandleType, handleType), handle); if (context) { @@ -3715,9 +3697,9 @@ void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target, EVENT(context, GLTexImage2DExternalANGLE, "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " "border = %d, format = %s, type = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, - width, height, border, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type)); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat, + width, height, border, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type)); if (context) { @@ -3745,7 +3727,7 @@ void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLInvalidateTextureANGLE, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target)); + GLenumToString(GLESEnum::TextureTarget, target)); if (context) { @@ -3779,8 +3761,8 @@ void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target, EVENT(context, GLTexStorage2DMultisampleANGLE, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), samples, - GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, + CID(context), GLenumToString(GLESEnum::AllEnums, target), samples, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, GLbooleanToString(fixedsamplelocations)); if (context) @@ -3811,7 +3793,7 @@ void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *v Context *context = GetValidGlobalContext(); EVENT(context, GLGetMultisamplefvANGLE, "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val); + GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val); if (context) { @@ -3836,7 +3818,7 @@ void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask) { Context *context = GetValidGlobalContext(); EVENT(context, GLSampleMaskiANGLE, "context = %d, maskNumber = %u, mask = %s", CID(context), - maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str()); + maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str()); if (context) { @@ -3864,15 +3846,15 @@ void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask) // GL_ANGLE_translated_shader_source void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetTranslatedShaderSourceANGLE, - "context = %d, shader = %u, bufsize = %d, length = 0x%016" PRIxPTR + "context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR ", source = 0x%016" PRIxPTR "", - CID(context), shader, bufsize, (uintptr_t)length, (uintptr_t)source); + CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source); if (context) { @@ -3881,13 +3863,13 @@ void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader, bool isCallValid = (context->skipValidation() || ValidateGetTranslatedShaderSourceANGLE( context, angle::EntryPoint::GLGetTranslatedShaderSourceANGLE, - shaderPacked, bufsize, length, source)); + shaderPacked, bufSize, length, source)); if (isCallValid) { - context->getTranslatedShaderSource(shaderPacked, bufsize, length, source); + context->getTranslatedShaderSource(shaderPacked, bufSize, length, source); } ANGLE_CAPTURE_GL(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, - bufsize, length, source); + bufSize, length, source); } else { @@ -4051,10 +4033,10 @@ void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId, "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = " "%s, unpackUnmultiplyAlpha = %s", - CID(context), sourceId, sourceLevel, - GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat, - GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY), - GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType), + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); if (context) { @@ -4104,9 +4086,8 @@ void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId, "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " "= %d, xoffset = %d, yoffset = %d, x = %d, y = %d, width = %d, height = %d, unpackFlipY " "= %s, unpackPremultiplyAlpha = %s, unpackUnmultiplyAlpha = %s", - CID(context), sourceId, sourceLevel, - GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, xoffset, - yoffset, x, y, width, height, GLbooleanToString(unpackFlipY), + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, xoffset, yoffset, x, y, width, height, GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); if (context) @@ -4142,7 +4123,7 @@ void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components) { Context *context = GetValidGlobalContext(); EVENT(context, GLCoverageModulationCHROMIUM, "context = %d, components = %s", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, components)); + GLenumToString(GLESEnum::AllEnums, components)); if (context) { @@ -4168,8 +4149,8 @@ void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other) { Context *context = GetValidGlobalContext(); EVENT(context, GLLoseContextCHROMIUM, "context = %d, current = %s, other = %s", CID(context), - GLenumToString(GLenumGroup::GraphicsResetStatus, current), - GLenumToString(GLenumGroup::GraphicsResetStatus, other)); + GLenumToString(GLESEnum::GraphicsResetStatus, current), + GLenumToString(GLESEnum::GraphicsResetStatus, other)); if (context) { @@ -4202,7 +4183,7 @@ void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLEGLImageTargetTexStorageEXT, "context = %d, target = %s, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image, + CID(context), GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image, (uintptr_t)attrib_list); if (context) @@ -4266,8 +4247,8 @@ void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceEXT(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstancedBaseInstanceEXT, "context = %d, mode = %s, first = %d, count = %d, instancecount = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, - instancecount, baseinstance); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instancecount, + baseinstance); if (context) { @@ -4302,8 +4283,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseInstanceEXT(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseInstanceEXT, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, instancecount, baseinstance); if (context) @@ -4342,8 +4323,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceEXT, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, basevertex = %d, baseinstance = %u", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, basevertex, baseinstance); if (context) @@ -4471,7 +4452,7 @@ GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramResourceLocationIndexEXT, "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", - CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), (uintptr_t)name); GLint returnValue; @@ -4517,9 +4498,9 @@ void GL_APIENTRY GL_BufferStorageEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLBufferStorageEXT, "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s", - CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target), + CID(context), GLenumToString(GLESEnum::BufferStorageTarget, target), static_cast(size), (uintptr_t)data, - GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str()); + GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); if (context) { @@ -4545,8 +4526,7 @@ void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth) { Context *context = GetValidGlobalContext(); EVENT(context, GLClipControlEXT, "context = %d, origin = %s, depth = %s", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, origin), - GLenumToString(GLenumGroup::DefaultGroup, depth)); + GLenumToString(GLESEnum::AllEnums, origin), GLenumToString(GLESEnum::AllEnums, depth)); if (context) { @@ -4594,10 +4574,10 @@ void GL_APIENTRY GL_CopyImageSubDataEXT(GLuint srcName, "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = " "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, " "srcWidth = %d, srcHeight = %d, srcDepth = %d", - CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget), + CID(context), srcName, GLenumToString(GLESEnum::CopyBufferSubDataTarget, srcTarget), srcLevel, srcX, srcY, srcZ, dstName, - GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, - dstZ, srcWidth, srcHeight, srcDepth); + GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); if (context) { @@ -4631,7 +4611,7 @@ GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *lengt EVENT(context, GLGetObjectLabelEXT, "context = %d, type = %s, object = %u, bufSize = %d, length = 0x%016" PRIxPTR ", label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, type), object, bufSize, (uintptr_t)length, (uintptr_t)label); if (context) @@ -4659,8 +4639,7 @@ void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, c Context *context = GetValidGlobalContext(); EVENT(context, GLLabelObjectEXT, "context = %d, type = %s, object = %u, length = %d, label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, type), object, length, - (uintptr_t)label); + CID(context), GLenumToString(GLESEnum::AllEnums, type), object, length, (uintptr_t)label); if (context) { @@ -4767,7 +4746,7 @@ void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLDiscardFramebufferEXT, "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments, + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, (uintptr_t)attachments); if (context) @@ -4795,7 +4774,7 @@ void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id) { Context *context = GetValidGlobalContext(); EVENT(context, GLBeginQueryEXT, "context = %d, target = %s, id = %u", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target), id); + GLenumToString(GLESEnum::QueryTarget, target), id); if (context) { @@ -4846,7 +4825,7 @@ void GL_APIENTRY GL_EndQueryEXT(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLEndQueryEXT, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target)); + GLenumToString(GLESEnum::QueryTarget, target)); if (context) { @@ -4896,7 +4875,7 @@ void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetInteger64vEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -4921,7 +4900,7 @@ void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *para Context *context = GetGlobalContext(); EVENT(context, GLGetQueryObjecti64vEXT, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -4946,7 +4925,7 @@ void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params) Context *context = GetGlobalContext(); EVENT(context, GLGetQueryObjectivEXT, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -4971,7 +4950,7 @@ void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *pa Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryObjectui64vEXT, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -4998,7 +4977,7 @@ void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryObjectuivEXT, "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, - GLenumToString(GLenumGroup::QueryObjectParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); if (context) { @@ -5025,8 +5004,8 @@ void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetQueryivEXT, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::QueryTarget, target), - GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::QueryTarget, target), + GLenumToString(GLESEnum::QueryParameterName, pname), (uintptr_t)params); if (context) { @@ -5081,7 +5060,7 @@ void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLQueryCounterEXT, "context = %d, id = %u, target = %s", CID(context), id, - GLenumToString(GLenumGroup::QueryTarget, target)); + GLenumToString(GLESEnum::QueryCounterTarget, target)); if (context) { @@ -5134,8 +5113,8 @@ void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationSeparateiEXT, "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB), - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha)); + GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB), + GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha)); if (context) { @@ -5160,7 +5139,7 @@ void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationiEXT, "context = %d, buf = %u, mode = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendEquationModeEXT, mode)); + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); if (context) { @@ -5186,10 +5165,10 @@ GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlp Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFuncSeparateiEXT, "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s", - CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB), - GLenumToString(GLenumGroup::BlendingFactor, dstRGB), - GLenumToString(GLenumGroup::BlendingFactor, srcAlpha), - GLenumToString(GLenumGroup::BlendingFactor, dstAlpha)); + CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB), + GLenumToString(GLESEnum::BlendingFactor, dstRGB), + GLenumToString(GLESEnum::BlendingFactor, srcAlpha), + GLenumToString(GLESEnum::BlendingFactor, dstAlpha)); if (context) { @@ -5215,8 +5194,8 @@ void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFunciEXT, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendingFactor, src), - GLenumToString(GLenumGroup::BlendingFactor, dst)); + GLenumToString(GLESEnum::BlendingFactor, src), + GLenumToString(GLESEnum::BlendingFactor, dst)); if (context) { @@ -5265,7 +5244,7 @@ void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLDisableiEXT, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -5289,7 +5268,7 @@ void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLEnableiEXT, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -5313,7 +5292,7 @@ GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLIsEnablediEXT, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); GLboolean returnValue; if (context) @@ -5351,8 +5330,8 @@ void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode, EVENT(context, GLDrawElementsBaseVertexEXT, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -5387,8 +5366,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseVertexEXT, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, basevertex); if (context) @@ -5426,8 +5405,8 @@ void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode, EVENT(context, GLDrawRangeElementsBaseVertexEXT, "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " "0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -5456,15 +5435,15 @@ void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex) { Context *context = GetValidGlobalContext(); EVENT(context, GLMultiDrawElementsBaseVertexEXT, "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR - ", primcount = %d, basevertex = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount, + ", drawcount = %d, basevertex = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount, (uintptr_t)basevertex); if (context) @@ -5475,14 +5454,14 @@ void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode, bool isCallValid = (context->skipValidation() || ValidateMultiDrawElementsBaseVertexEXT( context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, - modePacked, count, typePacked, indices, primcount, basevertex)); + modePacked, count, typePacked, indices, drawcount, basevertex)); if (isCallValid) { - context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, primcount, + context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount, basevertex); } ANGLE_CAPTURE_GL(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count, - typePacked, indices, primcount, basevertex); + typePacked, indices, drawcount, basevertex); } else { @@ -5501,10 +5480,9 @@ void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target, EVENT(context, GLBufferStorageExternalEXT, "context = %d, target = %s, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR ", flags = %s", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), + CID(context), GLenumToString(GLESEnum::AllEnums, target), static_cast(offset), static_cast(size), - (uintptr_t)clientBuffer, - GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str()); + (uintptr_t)clientBuffer, GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); if (context) { @@ -5539,7 +5517,7 @@ void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer, ", flags = %s", CID(context), buffer, static_cast(offset), static_cast(size), (uintptr_t)clientBuffer, - GLbitfieldToString(GLenumGroup::MapBufferUsageMask, flags).c_str()); + GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); if (context) { @@ -5572,8 +5550,8 @@ void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTextureEXT, "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level); + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level); if (context) { @@ -5607,7 +5585,7 @@ void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLDrawArraysInstancedEXT, "context = %d, mode = %s, start = %d, count = %d, primcount = %d", CID(context), - GLenumToString(GLenumGroup::PrimitiveType, mode), start, count, primcount); + GLenumToString(GLESEnum::PrimitiveType, mode), start, count, primcount); if (context) { @@ -5640,8 +5618,8 @@ void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode, EVENT(context, GLDrawElementsInstancedEXT, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", primcount = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, primcount); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, primcount); if (context) { @@ -5696,7 +5674,7 @@ void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GL Context *context = GetValidGlobalContext(); EVENT(context, GLFlushMappedBufferRangeEXT, "context = %d, target = %s, offset = %llu, length = %llu", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(offset), static_cast(length)); if (context) @@ -5728,9 +5706,9 @@ void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLMapBufferRangeEXT, "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(offset), static_cast(length), - GLbitfieldToString(GLenumGroup::BufferAccessMask, access).c_str()); + GLbitfieldToString(GLESEnum::MapBufferAccessMask, access).c_str()); void *returnValue; if (context) @@ -5769,8 +5747,8 @@ void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLBufferStorageMemEXT, "context = %d, target = %s, size = %llu, memory = %u, offset = %llu", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - static_cast(size), memory, static_cast(offset)); + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast(size), + memory, static_cast(offset)); if (context) { @@ -5854,7 +5832,7 @@ void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pn Context *context = GetValidGlobalContext(); EVENT(context, GLGetMemoryObjectParameterivEXT, "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname), + memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname), (uintptr_t)params); if (context) @@ -5882,7 +5860,7 @@ void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetUnsignedBytevEXT, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data); + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data); if (context) { @@ -5907,7 +5885,7 @@ void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte * Context *context = GetValidGlobalContext(); EVENT(context, GLGetUnsignedBytei_vEXT, "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, target), index, (uintptr_t)data); + GLenumToString(GLESEnum::AllEnums, target), index, (uintptr_t)data); if (context) { @@ -5969,7 +5947,7 @@ void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject, Context *context = GetValidGlobalContext(); EVENT(context, GLMemoryObjectParameterivEXT, "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - memoryObject, GLenumToString(GLenumGroup::MemoryObjectParameterName, pname), + memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname), (uintptr_t)params); if (context) @@ -6005,8 +5983,8 @@ void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target, EVENT(context, GLTexStorageMem2DEXT, "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " "memory = %u, offset = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, memory, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, memory, static_cast(offset)); if (context) @@ -6045,8 +6023,8 @@ void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target, EVENT(context, GLTexStorageMem2DMultisampleEXT, "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " "fixedSampleLocations = %s, memory = %u, offset = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, GLbooleanToString(fixedSampleLocations), memory, static_cast(offset)); if (context) @@ -6086,9 +6064,9 @@ void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target, EVENT(context, GLTexStorageMem3DEXT, "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " "depth = %d, memory = %u, offset = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, memory, - static_cast(offset)); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth, + memory, static_cast(offset)); if (context) { @@ -6128,8 +6106,8 @@ void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target, EVENT(context, GLTexStorageMem3DMultisampleEXT, "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::DefaultGroup, internalFormat), width, height, depth, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth, GLbooleanToString(fixedSampleLocations), memory, static_cast(offset)); if (context) @@ -6165,7 +6143,7 @@ void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handl EVENT(context, GLImportMemoryFdEXT, "context = %d, memory = %u, size = %llu, handleType = %s, fd = %d", CID(context), memory, static_cast(size), - GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd); + GLenumToString(GLESEnum::ExternalHandleType, handleType), fd); if (context) { @@ -6198,7 +6176,7 @@ void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode, Context *context = GetValidGlobalContext(); EVENT(context, GLMultiDrawArraysIndirectEXT, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect, drawcount, stride); if (context) @@ -6232,9 +6210,8 @@ void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode, EVENT(context, GLMultiDrawElementsIndirectEXT, "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect, drawcount, - stride); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect, drawcount, stride); if (context) { @@ -6270,9 +6247,9 @@ void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target, EVENT(context, GLFramebufferTexture2DMultisampleEXT, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, " "samples = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, samples); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, samples); if (context) { @@ -6307,8 +6284,8 @@ void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLRenderbufferStorageMultisampleEXT, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); if (context) { @@ -6331,6 +6308,8 @@ void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target, } } +// GL_EXT_multisampled_render_to_texture2 + // GL_EXT_occlusion_query_boolean // BeginQueryEXT is already defined. @@ -6495,8 +6474,8 @@ void GL_APIENTRY GL_ReadnPixelsEXT(GLint x, EVENT(context, GLReadnPixelsEXT, "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " "= %d, data = 0x%016" PRIxPTR "", - CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), bufSize, (uintptr_t)data); + CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), bufSize, (uintptr_t)data); if (context) { @@ -6578,7 +6557,7 @@ void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname Context *context = GetValidGlobalContext(); EVENT(context, GLGetSemaphoreParameterui64vEXT, "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params); + semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params); if (context) { @@ -6639,7 +6618,7 @@ void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore, Context *context = GetValidGlobalContext(); EVENT(context, GLSemaphoreParameterui64vEXT, "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - semaphore, GLenumToString(GLenumGroup::SemaphoreParameterName, pname), (uintptr_t)params); + semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params); if (context) { @@ -6750,7 +6729,7 @@ void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GL { Context *context = GetValidGlobalContext(); EVENT(context, GLImportSemaphoreFdEXT, "context = %d, semaphore = %u, handleType = %s, fd = %d", - CID(context), semaphore, GLenumToString(GLenumGroup::ExternalHandleType, handleType), fd); + CID(context), semaphore, GLenumToString(GLESEnum::ExternalHandleType, handleType), fd); if (context) { @@ -6833,7 +6812,7 @@ GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const Context *context = GetValidGlobalContext(); EVENT(context, GLCreateShaderProgramvEXT, "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings); + GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings); GLuint returnValue; if (context) @@ -6954,7 +6933,7 @@ void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint Context *context = GetValidGlobalContext(); EVENT(context, GLGetProgramPipelineivEXT, "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), (uintptr_t)params); + pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params); if (context) { @@ -7014,7 +6993,7 @@ void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint val { Context *context = GetValidGlobalContext(); EVENT(context, GLProgramParameteriEXT, "context = %d, program = %u, pname = %s, value = %d", - CID(context), program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value); + CID(context), program, GLenumToString(GLESEnum::ProgramParameterPName, pname), value); if (context) { @@ -8094,8 +8073,8 @@ void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLui { Context *context = GetValidGlobalContext(); EVENT(context, GLUseProgramStagesEXT, "context = %d, pipeline = %u, stages = %s, program = %u", - CID(context), pipeline, - GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program); + CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(), + program); if (context) { @@ -8184,7 +8163,7 @@ void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value) { Context *context = GetValidGlobalContext(); EVENT(context, GLPatchParameteriEXT, "context = %d, pname = %s, value = %d", CID(context), - GLenumToString(GLenumGroup::PatchParameterName, pname), value); + GLenumToString(GLESEnum::PatchParameterName, pname), value); if (context) { @@ -8210,7 +8189,7 @@ void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLin Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIivEXT, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -8238,7 +8217,7 @@ void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLu Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIuivEXT, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -8266,8 +8245,8 @@ void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *pa Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIivEXT, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -8294,8 +8273,8 @@ void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint * Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIuivEXT, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -8322,7 +8301,7 @@ void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, GLenum pname, const G Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIivEXT, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -8349,7 +8328,7 @@ void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, GLenum pname, const Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIuivEXT, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -8377,8 +8356,8 @@ void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, GLenum pname, const GLint Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIivEXT, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -8405,8 +8384,8 @@ void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, GLenum pname, const GLuin Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIuivEXT, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -8433,8 +8412,8 @@ void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint bu { Context *context = GetValidGlobalContext(); EVENT(context, GLTexBufferEXT, "context = %d, target = %s, internalformat = %s, buffer = %u", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer); if (context) { @@ -8466,8 +8445,8 @@ void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexBufferRangeEXT, "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer, static_cast(offset), static_cast(size)); if (context) @@ -8529,8 +8508,8 @@ void GL_APIENTRY GL_TexStorage1DEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexStorage1DEXT, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width); + GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width); if (context) { @@ -8560,8 +8539,8 @@ void GL_APIENTRY GL_TexStorage2DEXT(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexStorage2DEXT, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height); if (context) { @@ -8595,8 +8574,8 @@ void GL_APIENTRY GL_TexStorage3DEXT(GLenum target, EVENT(context, GLTexStorage3DEXT, "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, " "depth = %d", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), levels, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth); if (context) { @@ -8688,9 +8667,9 @@ void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source, EVENT(context, GLDebugMessageControlKHR, "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR ", enabled = %s", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), - GLenumToString(GLenumGroup::DebugType, type), - GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids, + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), + GLenumToString(GLESEnum::DebugSeverity, severity), count, (uintptr_t)ids, GLbooleanToString(enabled)); if (context) @@ -8724,9 +8703,9 @@ void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source, EVENT(context, GLDebugMessageInsertKHR, "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = " "0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), - GLenumToString(GLenumGroup::DebugType, type), id, - GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf); + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), id, + GLenumToString(GLESEnum::DebugSeverity, severity), length, (uintptr_t)buf); if (context) { @@ -8804,7 +8783,7 @@ void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier, EVENT(context, GLGetObjectLabelKHR, "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR ", label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize, + CID(context), GLenumToString(GLESEnum::AllEnums, identifier), name, bufSize, (uintptr_t)length, (uintptr_t)label); if (context) @@ -8861,7 +8840,7 @@ void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params) { Context *context = GetValidGlobalContext(); EVENT(context, GLGetPointervKHR, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -8889,7 +8868,7 @@ void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier, Context *context = GetValidGlobalContext(); EVENT(context, GLObjectLabelKHR, "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length, + CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, length, (uintptr_t)label); if (context) @@ -8967,7 +8946,7 @@ void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source, Context *context = GetValidGlobalContext(); EVENT(context, GLPushDebugGroupKHR, "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length, + CID(context), GLenumToString(GLESEnum::DebugSource, source), id, length, (uintptr_t)message); if (context) @@ -9028,8 +9007,8 @@ void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, GLenum pname, GLint { Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferParameteriMESA, "context = %d, target = %s, pname = %s, param = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferParameterName, pname), param); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferParameterName, pname), param); if (context) { @@ -9055,9 +9034,8 @@ void GL_APIENTRY GL_GetFramebufferParameterivMESA(GLenum target, GLenum pname, G Context *context = GetValidGlobalContext(); EVENT(context, GLGetFramebufferParameterivMESA, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), - (uintptr_t)params); + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); if (context) { @@ -9159,7 +9137,7 @@ void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetFenceivNV, "context = %d, fence = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), fence, - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -9215,7 +9193,7 @@ void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition) { Context *context = GetValidGlobalContext(); EVENT(context, GLSetFenceNV, "context = %d, fence = %u, condition = %s", CID(context), fence, - GLenumToString(GLenumGroup::DefaultGroup, condition)); + GLenumToString(GLESEnum::AllEnums, condition)); if (context) { @@ -9284,8 +9262,8 @@ void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0, "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, - GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(), - GLenumToString(GLenumGroup::BlitFramebufferFilter, filter)); + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); if (context) { @@ -9326,7 +9304,7 @@ void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglIma Context *context = GetValidGlobalContext(); EVENT(context, GLEGLImageTargetRenderbufferStorageOES, "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image); + GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image); if (context) { @@ -9352,7 +9330,7 @@ void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES imag Context *context = GetValidGlobalContext(); EVENT(context, GLEGLImageTargetTexture2DOES, "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, target), (uintptr_t)image); + GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image); if (context) { @@ -9402,10 +9380,10 @@ void GL_APIENTRY GL_CopyImageSubDataOES(GLuint srcName, "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = " "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, " "srcWidth = %d, srcHeight = %d, srcDepth = %d", - CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget), + CID(context), srcName, GLenumToString(GLESEnum::CopyBufferSubDataTarget, srcTarget), srcLevel, srcX, srcY, srcZ, dstName, - GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, - dstZ, srcWidth, srcHeight, srcDepth); + GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); if (context) { @@ -9443,8 +9421,8 @@ void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationSeparateiOES, "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB), - GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha)); + GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB), + GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha)); if (context) { @@ -9469,7 +9447,7 @@ void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendEquationiOES, "context = %d, buf = %u, mode = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendEquationModeEXT, mode)); + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); if (context) { @@ -9495,10 +9473,10 @@ GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlp Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFuncSeparateiOES, "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s", - CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB), - GLenumToString(GLenumGroup::BlendingFactor, dstRGB), - GLenumToString(GLenumGroup::BlendingFactor, srcAlpha), - GLenumToString(GLenumGroup::BlendingFactor, dstAlpha)); + CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB), + GLenumToString(GLESEnum::BlendingFactor, dstRGB), + GLenumToString(GLESEnum::BlendingFactor, srcAlpha), + GLenumToString(GLESEnum::BlendingFactor, dstAlpha)); if (context) { @@ -9524,8 +9502,8 @@ void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst) { Context *context = GetValidGlobalContext(); EVENT(context, GLBlendFunciOES, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf, - GLenumToString(GLenumGroup::BlendingFactor, src), - GLenumToString(GLenumGroup::BlendingFactor, dst)); + GLenumToString(GLESEnum::BlendingFactor, src), + GLenumToString(GLESEnum::BlendingFactor, dst)); if (context) { @@ -9574,7 +9552,7 @@ void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLDisableiOES, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -9598,7 +9576,7 @@ void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLEnableiOES, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); if (context) { @@ -9622,7 +9600,7 @@ GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index) { Context *context = GetValidGlobalContext(); EVENT(context, GLIsEnablediOES, "context = %d, target = %s, index = %u", CID(context), - GLenumToString(GLenumGroup::EnableCap, target), index); + GLenumToString(GLESEnum::EnableCap, target), index); GLboolean returnValue; if (context) @@ -9660,8 +9638,8 @@ void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode, EVENT(context, GLDrawElementsBaseVertexOES, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -9696,8 +9674,8 @@ void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode, EVENT(context, GLDrawElementsInstancedBaseVertexOES, "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR ", instancecount = %d, basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instancecount, + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, basevertex); if (context) @@ -9735,8 +9713,8 @@ void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode, EVENT(context, GLDrawRangeElementsBaseVertexOES, "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " "0x%016" PRIxPTR ", basevertex = %d", - CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), start, end, count, - GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, basevertex); + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); if (context) { @@ -9966,7 +9944,7 @@ void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindFramebufferOES, "context = %d, target = %s, framebuffer = %u", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), framebuffer); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), framebuffer); if (context) { @@ -9992,7 +9970,7 @@ void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer) { Context *context = GetValidGlobalContext(); EVENT(context, GLBindRenderbufferOES, "context = %d, target = %s, renderbuffer = %u", - CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), renderbuffer); + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), renderbuffer); if (context) { @@ -10018,7 +9996,7 @@ GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLCheckFramebufferStatusOES, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target)); + GLenumToString(GLESEnum::FramebufferTarget, target)); GLenum returnValue; if (context) @@ -10110,9 +10088,9 @@ void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferRenderbufferOES, "context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::RenderbufferTarget, renderbuffertarget), renderbuffer); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::RenderbufferTarget, renderbuffertarget), renderbuffer); if (context) { @@ -10145,9 +10123,9 @@ void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTexture2DOES, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level); if (context) { @@ -10228,7 +10206,7 @@ void GL_APIENTRY GL_GenerateMipmapOES(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLGenerateMipmapOES, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target)); + GLenumToString(GLESEnum::TextureTarget, target)); if (context) { @@ -10257,10 +10235,9 @@ void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLGetFramebufferAttachmentParameterivOES, "context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), - (uintptr_t)params); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); if (context) { @@ -10288,8 +10265,8 @@ void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, GLenum pname, G Context *context = GetValidGlobalContext(); EVENT(context, GLGetRenderbufferParameterivOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::RenderbufferTarget, target), - GLenumToString(GLenumGroup::RenderbufferParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::RenderbufferParameterName, pname), (uintptr_t)params); if (context) { @@ -10384,8 +10361,8 @@ void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLRenderbufferStorageOES, "context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context), - GLenumToString(GLenumGroup::RenderbufferTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); + GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); if (context) { @@ -10416,8 +10393,8 @@ void GL_APIENTRY GL_FramebufferTextureOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLFramebufferTextureOES, "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context), - GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level); + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level); if (context) { @@ -10483,7 +10460,7 @@ void GL_APIENTRY GL_ProgramBinaryOES(GLuint program, Context *context = GetValidGlobalContext(); EVENT(context, GLProgramBinaryOES, "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d", - CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat), + CID(context), program, GLenumToString(GLESEnum::AllEnums, binaryFormat), (uintptr_t)binary, length); if (context) @@ -10512,8 +10489,8 @@ void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **par Context *context = GetValidGlobalContext(); EVENT(context, GLGetBufferPointervOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::DefaultGroup, pname), (uintptr_t)params); + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); if (context) { @@ -10539,8 +10516,8 @@ void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access) { Context *context = GetValidGlobalContext(); EVENT(context, GLMapBufferOES, "context = %d, target = %s, access = %s", CID(context), - GLenumToString(GLenumGroup::BufferTargetARB, target), - GLenumToString(GLenumGroup::BufferAccessARB, access)); + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferAccessARB, access)); void *returnValue; if (context) @@ -10572,7 +10549,7 @@ GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target) { Context *context = GetValidGlobalContext(); EVENT(context, GLUnmapBufferOES, "context = %d, target = %s", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, target)); + GLenumToString(GLESEnum::AllEnums, target)); GLboolean returnValue; if (context) @@ -10657,8 +10634,7 @@ void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size, Context *context = GetValidGlobalContext(); EVENT(context, GLMatrixIndexPointerOES, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride, - (uintptr_t)pointer); + CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); if (context) { @@ -10684,8 +10660,7 @@ void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, co Context *context = GetValidGlobalContext(); EVENT(context, GLWeightPointerOES, "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", - CID(context), size, GLenumToString(GLenumGroup::DefaultGroup, type), stride, - (uintptr_t)pointer); + CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); if (context) { @@ -10713,7 +10688,7 @@ void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void Context *context = GetValidGlobalContext(); EVENT(context, GLPointSizePointerOES, "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::DefaultGroup, type), stride, (uintptr_t)pointer); + GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); if (context) { @@ -10859,8 +10834,8 @@ void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target, EVENT(context, GLCompressedTexImage3DOES, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border, imageSize, (uintptr_t)data); if (context) @@ -10902,8 +10877,8 @@ void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target, EVENT(context, GLCompressedTexSubImage3DOES, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format), + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::InternalFormat, format), imageSize, (uintptr_t)data); if (context) @@ -10943,7 +10918,7 @@ void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target, EVENT(context, GLCopyTexSubImage3DOES, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = " "%d, y = %d, width = %d, height = %d", - CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, zoffset, x, y, width, height); if (context) @@ -10979,9 +10954,9 @@ void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target, EVENT(context, GLFramebufferTexture3DOES, "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, " "zoffset = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), - GLenumToString(GLenumGroup::TextureTarget, textarget), texture, level, zoffset); + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, zoffset); if (context) { @@ -11021,10 +10996,10 @@ void GL_APIENTRY GL_TexImage3DOES(GLenum target, EVENT(context, GLTexImage3DOES, "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, border, - GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border, + GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type), + (uintptr_t)pixels); if (context) { @@ -11064,9 +11039,9 @@ void GL_APIENTRY GL_TexSubImage3DOES(GLenum target, EVENT(context, GLTexSubImage3DOES, "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, xoffset, yoffset, - zoffset, width, height, depth, GLenumToString(GLenumGroup::PixelFormat, format), - GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels); if (context) { @@ -11096,7 +11071,7 @@ void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLin Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIivOES, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -11124,7 +11099,7 @@ void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLu Context *context = GetValidGlobalContext(); EVENT(context, GLGetSamplerParameterIuivOES, "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)params); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); if (context) { @@ -11152,8 +11127,8 @@ void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *pa Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIivOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -11180,8 +11155,8 @@ void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint * Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexParameterIuivOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); if (context) { @@ -11208,7 +11183,7 @@ void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, GLenum pname, const G Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIivOES, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -11235,7 +11210,7 @@ void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, GLenum pname, const Context *context = GetValidGlobalContext(); EVENT(context, GLSamplerParameterIuivOES, "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), - sampler, GLenumToString(GLenumGroup::SamplerParameterName, pname), (uintptr_t)param); + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); if (context) { @@ -11263,8 +11238,8 @@ void GL_APIENTRY GL_TexParameterIivOES(GLenum target, GLenum pname, const GLint Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIivOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -11291,8 +11266,8 @@ void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, GLenum pname, const GLuin Context *context = GetValidGlobalContext(); EVENT(context, GLTexParameterIuivOES, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::TextureParameterName, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params); if (context) { @@ -11319,8 +11294,8 @@ void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint bu { Context *context = GetValidGlobalContext(); EVENT(context, GLTexBufferOES, "context = %d, target = %s, internalformat = %s, buffer = %u", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer); + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer); if (context) { @@ -11352,8 +11327,8 @@ void GL_APIENTRY GL_TexBufferRangeOES(GLenum target, Context *context = GetValidGlobalContext(); EVENT(context, GLTexBufferRangeOES, "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), - GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer, static_cast(offset), static_cast(size)); if (context) @@ -11386,8 +11361,8 @@ void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGenfvOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11412,8 +11387,8 @@ void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGenivOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11438,8 +11413,8 @@ void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) Context *context = GetValidGlobalContext(); EVENT(context, GLGetTexGenxvOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11463,8 +11438,8 @@ void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenfOES, "context = %d, coord = %s, pname = %s, param = %f", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); if (context) { @@ -11489,8 +11464,8 @@ void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *param Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenfvOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11514,8 +11489,8 @@ void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGeniOES, "context = %d, coord = %s, pname = %s, param = %d", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); if (context) { @@ -11540,8 +11515,8 @@ void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params) Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenivOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11565,8 +11540,8 @@ void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param) { Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenxOES, "context = %d, coord = %s, pname = %s, param = 0x%X", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), param); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); if (context) { @@ -11591,8 +11566,8 @@ void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *param Context *context = GetValidGlobalContext(); EVENT(context, GLTexGenxvOES, "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), - GLenumToString(GLenumGroup::TextureCoordName, coord), - GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params); + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); if (context) { @@ -11639,8 +11614,8 @@ void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target, EVENT(context, GLTexStorage3DMultisampleOES, "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " "depth = %d, fixedsamplelocations = %s", - CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, - GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth, GLbooleanToString(fixedsamplelocations)); if (context) @@ -11789,8 +11764,8 @@ void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target, EVENT(context, GLFramebufferTextureMultiviewOVR, "context = %d, target = %s, attachment = %s, texture = %u, level = %d, baseViewIndex = " "%d, numViews = %d", - CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), - GLenumToString(GLenumGroup::FramebufferAttachment, attachment), texture, level, + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level, baseViewIndex, numViews); if (context) @@ -11822,7 +11797,7 @@ void GL_APIENTRY GL_ShadingRateQCOM(GLenum rate) { Context *context = GetValidGlobalContext(); EVENT(context, GLShadingRateQCOM, "context = %d, rate = %s", CID(context), - GLenumToString(GLenumGroup::ShadingRate, rate)); + GLenumToString(GLESEnum::ShadingRateQCOM, rate)); if (context) { diff --git a/src/libGLESv2/entry_points_gles_ext_autogen.h b/src/libGLESv2/entry_points_gles_ext_autogen.h index dca66d567..c400bb015 100644 --- a/src/libGLESv2/entry_points_gles_ext_autogen.h +++ b/src/libGLESv2/entry_points_gles_ext_autogen.h @@ -667,7 +667,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield // GL_ANGLE_translated_shader_source ANGLE_EXPORT void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source); @@ -878,7 +878,7 @@ ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex); // GL_EXT_external_buffer @@ -1003,6 +1003,8 @@ ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target GLsizei width, GLsizei height); +// GL_EXT_multisampled_render_to_texture2 + // GL_EXT_occlusion_query_boolean // GL_EXT_primitive_bounding_box diff --git a/src/libGLESv2/libGLESv2_autogen.cpp b/src/libGLESv2/libGLESv2_autogen.cpp index c33fd6a39..d9f873d27 100644 --- a/src/libGLESv2/libGLESv2_autogen.cpp +++ b/src/libGLESv2/libGLESv2_autogen.cpp @@ -592,11 +592,11 @@ void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height) void GL_APIENTRY glShaderBinary(GLsizei count, const GLuint *shaders, - GLenum binaryformat, + GLenum binaryFormat, const void *binary, GLsizei length) { - return GL_ShaderBinary(count, shaders, binaryformat, binary, length); + return GL_ShaderBinary(count, shaders, binaryFormat, binary, length); } void GL_APIENTRY glShaderSource(GLuint shader, @@ -1147,10 +1147,10 @@ void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data) void GL_APIENTRY glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint *params) { - return GL_GetInternalformativ(target, internalformat, pname, bufSize, params); + return GL_GetInternalformativ(target, internalformat, pname, count, params); } void GL_APIENTRY glGetProgramBinary(GLuint program, @@ -1188,9 +1188,9 @@ const GLubyte *GL_APIENTRY glGetStringi(GLenum name, GLuint index) } void GL_APIENTRY -glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values) +glGetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) { - return GL_GetSynciv(sync, pname, bufSize, length, values); + return GL_GetSynciv(sync, pname, count, length, values); } void GL_APIENTRY glGetTransformFeedbackVarying(GLuint program, @@ -1666,11 +1666,11 @@ void GL_APIENTRY glGetProgramResourceiv(GLuint program, GLuint index, GLsizei propCount, const GLenum *props, - GLsizei bufSize, + GLsizei count, GLsizei *length, GLint *params) { - return GL_GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, + return GL_GetProgramResourceiv(program, programInterface, index, propCount, props, count, length, params); } @@ -3811,11 +3811,11 @@ void GL_APIENTRY glSampleMaskiANGLE(GLuint maskNumber, GLbitfield mask) // GL_ANGLE_translated_shader_source void GL_APIENTRY glGetTranslatedShaderSourceANGLE(GLuint shader, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *source) { - return GL_GetTranslatedShaderSourceANGLE(shader, bufsize, length, source); + return GL_GetTranslatedShaderSourceANGLE(shader, bufSize, length, source); } // GL_ANGLE_vulkan_image @@ -4200,10 +4200,10 @@ void GL_APIENTRY glMultiDrawElementsBaseVertexEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, - GLsizei primcount, + GLsizei drawcount, const GLint *basevertex) { - return GL_MultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex); + return GL_MultiDrawElementsBaseVertexEXT(mode, count, type, indices, drawcount, basevertex); } // GL_EXT_external_buffer @@ -4417,6 +4417,8 @@ void GL_APIENTRY glRenderbufferStorageMultisampleEXT(GLenum target, return GL_RenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height); } +// GL_EXT_multisampled_render_to_texture2 + // GL_EXT_occlusion_query_boolean // GL_EXT_primitive_bounding_box @@ -8110,21 +8112,21 @@ void GL_APIENTRY glEndQueryIndexed(GLenum target, GLuint index) void GL_APIENTRY glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { - return GL_GetActiveSubroutineName(program, shadertype, index, bufsize, length, name); + return GL_GetActiveSubroutineName(program, shadertype, index, bufSize, length, name); } void GL_APIENTRY glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, - GLsizei bufsize, + GLsizei bufSize, GLsizei *length, GLchar *name) { - return GL_GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name); + return GL_GetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); } void GL_APIENTRY glGetActiveSubroutineUniformiv(GLuint program, @@ -8615,10 +8617,10 @@ void GL_APIENTRY glClearBufferSubData(GLenum target, void GL_APIENTRY glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, - GLsizei bufSize, + GLsizei count, GLint64 *params) { - return GL_GetInternalformati64v(target, internalformat, pname, bufSize, params); + return GL_GetInternalformati64v(target, internalformat, pname, count, params); } GLint GL_APIENTRY glGetProgramResourceLocationIndex(GLuint program, diff --git a/src/libGLESv2/libGLESv2_autogen.def b/src/libGLESv2/libGLESv2_autogen.def index 8c7604f9d..0a1b47dc7 100644 --- a/src/libGLESv2/libGLESv2_autogen.def +++ b/src/libGLESv2/libGLESv2_autogen.def @@ -772,6 +772,8 @@ EXPORTS glFramebufferTexture2DMultisampleEXT glRenderbufferStorageMultisampleEXT + ; GL_EXT_multisampled_render_to_texture2 + ; GL_EXT_occlusion_query_boolean ; GL_EXT_primitive_bounding_box diff --git a/src/libGLESv2/libGLESv2_no_capture_autogen.def b/src/libGLESv2/libGLESv2_no_capture_autogen.def index b29231135..b3ff44264 100644 --- a/src/libGLESv2/libGLESv2_no_capture_autogen.def +++ b/src/libGLESv2/libGLESv2_no_capture_autogen.def @@ -772,6 +772,8 @@ EXPORTS glFramebufferTexture2DMultisampleEXT glRenderbufferStorageMultisampleEXT + ; GL_EXT_multisampled_render_to_texture2 + ; GL_EXT_occlusion_query_boolean ; GL_EXT_primitive_bounding_box diff --git a/src/libGLESv2/libGLESv2_with_capture_autogen.def b/src/libGLESv2/libGLESv2_with_capture_autogen.def index 2e2ae2580..f709e9ade 100644 --- a/src/libGLESv2/libGLESv2_with_capture_autogen.def +++ b/src/libGLESv2/libGLESv2_with_capture_autogen.def @@ -772,6 +772,8 @@ EXPORTS glFramebufferTexture2DMultisampleEXT glRenderbufferStorageMultisampleEXT + ; GL_EXT_multisampled_render_to_texture2 + ; GL_EXT_occlusion_query_boolean ; GL_EXT_primitive_bounding_box diff --git a/src/libGLESv2/opengl32_autogen.def b/src/libGLESv2/opengl32_autogen.def index ffa108496..c6ba10aa1 100644 --- a/src/libGLESv2/opengl32_autogen.def +++ b/src/libGLESv2/opengl32_autogen.def @@ -772,6 +772,8 @@ EXPORTS glFramebufferTexture2DMultisampleEXT glRenderbufferStorageMultisampleEXT + ; GL_EXT_multisampled_render_to_texture2 + ; GL_EXT_occlusion_query_boolean ; GL_EXT_primitive_bounding_box diff --git a/src/tests/gl_tests/FormatPrintTest.cpp b/src/tests/gl_tests/FormatPrintTest.cpp index c62d206ee..ce6e3200c 100644 --- a/src/tests/gl_tests/FormatPrintTest.cpp +++ b/src/tests/gl_tests/FormatPrintTest.cpp @@ -65,10 +65,10 @@ TEST_P(FormatPrintTest, PrintAllSupportedFormats) // Lookup enum strings from enum std::stringstream resultStringStream; - gl::OutputGLenumString(resultStringStream, gl::GLenumGroup::InternalFormat, + gl::OutputGLenumString(resultStringStream, gl::GLESEnum::InternalFormat, internalFormat.first); resultStringStream << ","; - gl::OutputGLenumString(resultStringStream, gl::GLenumGroup::PixelType, + gl::OutputGLenumString(resultStringStream, gl::GLESEnum::PixelType, typeFormatPair.first); resultStringStream << ","; diff --git a/src/tests/perf_tests/ANGLEPerfTest.cpp b/src/tests/perf_tests/ANGLEPerfTest.cpp index dd35288a9..600873527 100644 --- a/src/tests/perf_tests/ANGLEPerfTest.cpp +++ b/src/tests/perf_tests/ANGLEPerfTest.cpp @@ -1233,7 +1233,7 @@ void ANGLERenderTest::skipTestIfFailsIntegerPrerequisite() std::stringstream ss; ss << "Test skipped due to value (" << std::to_string(static_cast(driverValue)) << ") being less than the prerequisite minimum (" << std::to_string(minRequired) - << ") for GL constant " << gl::GLenumToString(gl::GLenumGroup::DefaultGroup, target); + << ") for GL constant " << gl::GLenumToString(gl::GLESEnum::AllEnums, target); skipTest(ss.str()); } }