| // GENERATED FILE - DO NOT EDIT. |
| // Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.xml. |
| // |
| // Copyright 2019 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // entry_points_gles_ext_autogen.cpp: |
| // Defines the GLES extension entry points. |
| |
| #include "libGLESv2/entry_points_gles_ext_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/Context.inl.h" |
| #include "libANGLE/capture_gles_ext_autogen.h" |
| #include "libANGLE/entry_points_utils.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationESEXT.h" |
| #include "libGLESv2/global_state.h" |
| |
| #include "libANGLE/capture_gles_1_0_autogen.h" |
| #include "libANGLE/capture_gles_2_0_autogen.h" |
| #include "libANGLE/capture_gles_3_0_autogen.h" |
| #include "libANGLE/capture_gles_3_1_autogen.h" |
| #include "libANGLE/capture_gles_3_2_autogen.h" |
| #include "libANGLE/validationES1.h" |
| #include "libANGLE/validationES2.h" |
| #include "libANGLE/validationES3.h" |
| #include "libANGLE/validationES31.h" |
| #include "libANGLE/validationES32.h" |
| |
| namespace gl |
| { |
| |
| // GL_ANGLE_base_vertex_base_instance |
| void GL_APIENTRY DrawArraysInstancedBaseInstanceANGLE(GLenum mode, |
| GLint first, |
| GLsizei count, |
| GLsizei instanceCount, |
| GLuint baseInstance) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDrawArraysInstancedBaseInstanceANGLE", |
| "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei " |
| "instanceCount = %d, GLuint baseInstance = %u", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, |
| instanceCount, baseInstance); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateDrawArraysInstancedBaseInstanceANGLE( |
| context, modePacked, first, count, instanceCount, baseInstance)); |
| if (isCallValid) |
| { |
| context->drawArraysInstancedBaseInstance(modePacked, first, count, instanceCount, |
| baseInstance); |
| } |
| ANGLE_CAPTURE(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, first, |
| count, instanceCount, baseInstance); |
| } |
| } |
| |
| void GL_APIENTRY DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const GLvoid *indices, |
| GLsizei instanceCounts, |
| GLint baseVertex, |
| GLuint baseInstance) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDrawElementsInstancedBaseVertexBaseInstanceANGLE", |
| "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const GLvoid " |
| "*indices = 0x%016" PRIxPTR |
| ", GLsizei instanceCounts = %d, GLint baseVertex = %d, GLuint baseInstance = %u", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, instanceCounts, |
| baseVertex, baseInstance); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE( |
| context, modePacked, count, typePacked, indices, |
| instanceCounts, baseVertex, baseInstance)); |
| if (isCallValid) |
| { |
| context->drawElementsInstancedBaseVertexBaseInstance( |
| modePacked, count, typePacked, indices, instanceCounts, baseVertex, baseInstance); |
| } |
| ANGLE_CAPTURE(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context, |
| modePacked, count, typePacked, indices, instanceCounts, baseVertex, |
| baseInstance); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode, |
| const GLint *firsts, |
| const GLsizei *counts, |
| const GLsizei *instanceCounts, |
| const GLuint *baseInstances, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawArraysInstancedBaseInstanceANGLE", |
| "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR |
| ", const GLsizei *counts = 0x%016" PRIxPTR |
| ", const GLsizei *instanceCounts = 0x%016" PRIxPTR |
| ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, |
| (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateMultiDrawArraysInstancedBaseInstanceANGLE( |
| context, modePacked, firsts, counts, instanceCounts, baseInstances, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts, |
| instanceCounts, baseInstances, drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, |
| firsts, counts, instanceCounts, baseInstances, drawcount); |
| } |
| } |
| |
| void GL_APIENTRY |
| MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, |
| const GLsizei *counts, |
| GLenum type, |
| const GLvoid *const *indices, |
| const GLsizei *instanceCounts, |
| const GLint *baseVertices, |
| const GLuint *baseInstances, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE", |
| "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR |
| ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR |
| ", const GLsizei *instanceCounts = 0x%016" PRIxPTR |
| ", const GLint *baseVertices = 0x%016" PRIxPTR |
| ", const GLuint *baseInstances = 0x%016" PRIxPTR ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, |
| (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE( |
| context, modePacked, counts, typePacked, indices, instanceCounts, |
| baseVertices, baseInstances, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawElementsInstancedBaseVertexBaseInstance( |
| modePacked, counts, typePacked, indices, instanceCounts, baseVertices, |
| baseInstances, drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context, |
| modePacked, counts, typePacked, indices, instanceCounts, baseVertices, |
| baseInstances, drawcount); |
| } |
| } |
| |
| // GL_ANGLE_copy_texture_3d |
| void GL_APIENTRY CopyTexture3DANGLE(GLuint sourceId, |
| GLint sourceLevel, |
| GLenum destTarget, |
| GLuint destId, |
| GLint destLevel, |
| GLint internalFormat, |
| GLenum destType, |
| GLboolean unpackFlipY, |
| GLboolean unpackPremultiplyAlpha, |
| GLboolean unpackUnmultiplyAlpha) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCopyTexture3DANGLE", |
| "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, " |
| "GLuint destId = %u, GLint destLevel = %d, GLint internalFormat = %d, GLenum destType = " |
| "%s, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = %s, GLboolean " |
| "unpackUnmultiplyAlpha = %s", |
| CID(context), sourceId, sourceLevel, |
| GLenumToString(GLenumGroup::DefaultGroup, destTarget), destId, destLevel, internalFormat, |
| GLenumToString(GLenumGroup::DefaultGroup, destType), GLbooleanToString(unpackFlipY), |
| GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); |
| |
| if (context) |
| { |
| TextureID sourceIdPacked = FromGL<TextureID>(sourceId); |
| TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget); |
| TextureID destIdPacked = FromGL<TextureID>(destId); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateCopyTexture3DANGLE( |
| context, sourceIdPacked, sourceLevel, destTargetPacked, |
| destIdPacked, destLevel, internalFormat, destType, unpackFlipY, |
| unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); |
| if (isCallValid) |
| { |
| context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, |
| destLevel, internalFormat, destType, unpackFlipY, |
| unpackPremultiplyAlpha, unpackUnmultiplyAlpha); |
| } |
| ANGLE_CAPTURE(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel, |
| destTargetPacked, destIdPacked, destLevel, internalFormat, destType, |
| unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); |
| } |
| } |
| |
| void GL_APIENTRY CopySubTexture3DANGLE(GLuint sourceId, |
| GLint sourceLevel, |
| GLenum destTarget, |
| GLuint destId, |
| GLint destLevel, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLint x, |
| GLint y, |
| GLint z, |
| GLint width, |
| GLint height, |
| GLint depth, |
| GLboolean unpackFlipY, |
| GLboolean unpackPremultiplyAlpha, |
| GLboolean unpackUnmultiplyAlpha) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCopySubTexture3DANGLE", |
| "context = %d, GLuint sourceId = %u, GLint sourceLevel = %d, GLenum destTarget = %s, " |
| "GLuint destId = %u, GLint destLevel = %d, GLint xoffset = %d, GLint yoffset = %d, GLint " |
| "zoffset = %d, GLint x = %d, GLint y = %d, GLint z = %d, GLint width = %d, GLint height " |
| "= %d, GLint depth = %d, GLboolean unpackFlipY = %s, GLboolean unpackPremultiplyAlpha = " |
| "%s, GLboolean 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)); |
| |
| if (context) |
| { |
| TextureID sourceIdPacked = FromGL<TextureID>(sourceId); |
| TextureTarget destTargetPacked = FromGL<TextureTarget>(destTarget); |
| TextureID destIdPacked = FromGL<TextureID>(destId); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateCopySubTexture3DANGLE(context, sourceIdPacked, sourceLevel, destTargetPacked, |
| destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, |
| z, width, height, depth, unpackFlipY, |
| unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); |
| if (isCallValid) |
| { |
| context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, |
| destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, |
| depth, unpackFlipY, unpackPremultiplyAlpha, |
| unpackUnmultiplyAlpha); |
| } |
| ANGLE_CAPTURE(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel, |
| destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z, |
| width, height, depth, unpackFlipY, unpackPremultiplyAlpha, |
| unpackUnmultiplyAlpha); |
| } |
| } |
| |
| // GL_ANGLE_framebuffer_blit |
| void GL_APIENTRY BlitFramebufferANGLE(GLint srcX0, |
| GLint srcY0, |
| GLint srcX1, |
| GLint srcY1, |
| GLint dstX0, |
| GLint dstY0, |
| GLint dstX1, |
| GLint dstY1, |
| GLbitfield mask, |
| GLenum filter) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glBlitFramebufferANGLE", |
| "context = %d, GLint srcX0 = %d, GLint srcY0 = %d, GLint srcX1 = %d, GLint srcY1 = %d, " |
| "GLint dstX0 = %d, GLint dstY0 = %d, GLint dstX1 = %d, GLint dstY1 = %d, GLbitfield mask " |
| "= %s, GLenum filter = %s", |
| CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, |
| GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str(), |
| GLenumToString(GLenumGroup::BlitFramebufferFilter, filter)); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateBlitFramebufferANGLE(context, srcX0, srcY0, srcX1, srcY1, dstX0, |
| dstY0, dstX1, dstY1, mask, filter)); |
| if (isCallValid) |
| { |
| context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, |
| filter); |
| } |
| ANGLE_CAPTURE(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0, |
| dstY0, dstX1, dstY1, mask, filter); |
| } |
| } |
| |
| // GL_ANGLE_framebuffer_multisample |
| void GL_APIENTRY RenderbufferStorageMultisampleANGLE(GLenum target, |
| GLsizei samples, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glRenderbufferStorageMultisampleANGLE", |
| "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, " |
| "GLsizei width = %d, GLsizei height = %d", |
| CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), samples, |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateRenderbufferStorageMultisampleANGLE( |
| context, target, samples, internalformat, width, height)); |
| if (isCallValid) |
| { |
| context->renderbufferStorageMultisample(target, samples, internalformat, width, height); |
| } |
| ANGLE_CAPTURE(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples, |
| internalformat, width, height); |
| } |
| } |
| |
| // GL_ANGLE_get_image |
| void GL_APIENTRY |
| GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexImageANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum format = %s, GLenum type = " |
| "%s, void *pixels = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, |
| GLenumToString(GLenumGroup::PixelFormat, format), |
| GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetTexImageANGLE(context, targetPacked, level, format, type, pixels)); |
| if (isCallValid) |
| { |
| context->getTexImage(targetPacked, level, format, type, pixels); |
| } |
| ANGLE_CAPTURE(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type, |
| pixels); |
| } |
| } |
| |
| void GL_APIENTRY GetRenderbufferImageANGLE(GLenum target, GLenum format, GLenum type, void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetRenderbufferImageANGLE", |
| "context = %d, GLenum target = %s, GLenum format = %s, GLenum type = %s, void *pixels = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::RenderbufferTarget, target), |
| GLenumToString(GLenumGroup::PixelFormat, format), |
| GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetRenderbufferImageANGLE(context, target, format, type, pixels)); |
| if (isCallValid) |
| { |
| context->getRenderbufferImage(target, format, type, pixels); |
| } |
| ANGLE_CAPTURE(GetRenderbufferImageANGLE, isCallValid, context, target, format, type, |
| pixels); |
| } |
| } |
| |
| // GL_ANGLE_instanced_arrays |
| void GL_APIENTRY DrawArraysInstancedANGLE(GLenum mode, |
| GLint first, |
| GLsizei count, |
| GLsizei primcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDrawArraysInstancedANGLE", |
| "context = %d, GLenum mode = %s, GLint first = %d, GLsizei count = %d, GLsizei primcount " |
| "= %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), first, count, primcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDrawArraysInstancedANGLE(context, modePacked, first, count, primcount)); |
| if (isCallValid) |
| { |
| context->drawArraysInstanced(modePacked, first, count, primcount); |
| } |
| ANGLE_CAPTURE(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count, |
| primcount); |
| } |
| } |
| |
| void GL_APIENTRY DrawElementsInstancedANGLE(GLenum mode, |
| GLsizei count, |
| GLenum type, |
| const void *indices, |
| GLsizei primcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDrawElementsInstancedANGLE", |
| "context = %d, GLenum mode = %s, GLsizei count = %d, GLenum type = %s, const void " |
| "*indices = 0x%016" PRIxPTR ", GLsizei primcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), count, |
| GLenumToString(GLenumGroup::PrimitiveType, type), (uintptr_t)indices, primcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateDrawElementsInstancedANGLE(context, modePacked, count, |
| typePacked, indices, primcount)); |
| if (isCallValid) |
| { |
| context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount); |
| } |
| ANGLE_CAPTURE(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count, |
| typePacked, indices, primcount); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribDivisorANGLE(GLuint index, GLuint divisor) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribDivisorANGLE", "context = %d, GLuint index = %u, GLuint divisor = %u", |
| CID(context), index, divisor); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexAttribDivisorANGLE(context, index, divisor)); |
| if (isCallValid) |
| { |
| context->vertexAttribDivisor(index, divisor); |
| } |
| ANGLE_CAPTURE(VertexAttribDivisorANGLE, isCallValid, context, index, divisor); |
| } |
| } |
| |
| // GL_ANGLE_multi_draw |
| void GL_APIENTRY MultiDrawArraysANGLE(GLenum mode, |
| const GLint *firsts, |
| const GLsizei *counts, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawArraysANGLE", |
| "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR |
| ", const GLsizei *counts = 0x%016" PRIxPTR ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, |
| (uintptr_t)counts, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateMultiDrawArraysANGLE(context, modePacked, firsts, counts, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawArrays(modePacked, firsts, counts, drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts, |
| drawcount); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawArraysInstancedANGLE(GLenum mode, |
| const GLint *firsts, |
| const GLsizei *counts, |
| const GLsizei *instanceCounts, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawArraysInstancedANGLE", |
| "context = %d, GLenum mode = %s, const GLint *firsts = 0x%016" PRIxPTR |
| ", const GLsizei *counts = 0x%016" PRIxPTR |
| ", const GLsizei *instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)firsts, |
| (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateMultiDrawArraysInstancedANGLE( |
| context, modePacked, firsts, counts, instanceCounts, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts, |
| drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts, |
| counts, instanceCounts, drawcount); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawElementsANGLE(GLenum mode, |
| const GLsizei *counts, |
| GLenum type, |
| const GLvoid *const *indices, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawElementsANGLE", |
| "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR |
| ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR |
| ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateMultiDrawElementsANGLE(context, modePacked, counts, typePacked, |
| indices, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, typePacked, |
| indices, drawcount); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawElementsInstancedANGLE(GLenum mode, |
| const GLsizei *counts, |
| GLenum type, |
| const GLvoid *const *indices, |
| const GLsizei *instanceCounts, |
| GLsizei drawcount) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMultiDrawElementsInstancedANGLE", |
| "context = %d, GLenum mode = %s, const GLsizei *counts = 0x%016" PRIxPTR |
| ", GLenum type = %s, const GLvoid *const*indices = 0x%016" PRIxPTR |
| ", const GLsizei*instanceCounts = 0x%016" PRIxPTR ", GLsizei drawcount = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)counts, |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indices, |
| (uintptr_t)instanceCounts, drawcount); |
| |
| if (context) |
| { |
| PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode); |
| DrawElementsType typePacked = FromGL<DrawElementsType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateMultiDrawElementsInstancedANGLE(context, modePacked, counts, typePacked, |
| indices, instanceCounts, drawcount)); |
| if (isCallValid) |
| { |
| context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices, |
| instanceCounts, drawcount); |
| } |
| ANGLE_CAPTURE(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts, |
| typePacked, indices, instanceCounts, drawcount); |
| } |
| } |
| |
| // GL_ANGLE_program_binary |
| |
| // GL_ANGLE_provoking_vertex |
| void GL_APIENTRY ProvokingVertexANGLE(GLenum mode) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProvokingVertexANGLE", "context = %d, GLenum mode = %s", CID(context), |
| GLenumToString(GLenumGroup::VertexProvokingMode, mode)); |
| |
| if (context) |
| { |
| ProvokingVertexConvention modePacked = FromGL<ProvokingVertexConvention>(mode); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateProvokingVertexANGLE(context, modePacked)); |
| if (isCallValid) |
| { |
| context->provokingVertex(modePacked); |
| } |
| ANGLE_CAPTURE(ProvokingVertexANGLE, isCallValid, context, modePacked); |
| } |
| } |
| |
| // GL_ANGLE_request_extension |
| void GL_APIENTRY RequestExtensionANGLE(const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glRequestExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "", |
| CID(context), (uintptr_t)name); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateRequestExtensionANGLE(context, name)); |
| if (isCallValid) |
| { |
| context->requestExtension(name); |
| } |
| ANGLE_CAPTURE(RequestExtensionANGLE, isCallValid, context, name); |
| } |
| } |
| |
| void GL_APIENTRY DisableExtensionANGLE(const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDisableExtensionANGLE", "context = %d, const GLchar * name = 0x%016" PRIxPTR "", |
| CID(context), (uintptr_t)name); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDisableExtensionANGLE(context, name)); |
| if (isCallValid) |
| { |
| context->disableExtension(name); |
| } |
| ANGLE_CAPTURE(DisableExtensionANGLE, isCallValid, context, name); |
| } |
| } |
| |
| // GL_ANGLE_robust_client_memory |
| void GL_APIENTRY GetBooleanvRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLboolean *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetBooleanvRobustANGLE", |
| "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLboolean * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetBooleanvRobustANGLE(context, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getBooleanvRobust(pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetBufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetBufferParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| BufferBinding targetPacked = FromGL<BufferBinding>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetBufferParameterivRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetFloatvRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetFloatvRobustANGLE", |
| "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetFloatvRobustANGLE(context, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getFloatvRobust(pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetFramebufferAttachmentParameterivRobustANGLE(GLenum target, |
| GLenum attachment, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetFramebufferAttachmentParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum attachment = %s, GLenum pname = %s, GLsizei " |
| "bufSize = %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * 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); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetFramebufferAttachmentParameterivRobustANGLE( |
| context, target, attachment, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize, |
| length, params); |
| } |
| ANGLE_CAPTURE(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, target, |
| attachment, pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetIntegervRobustANGLE(GLenum pname, GLsizei bufSize, GLsizei *length, GLint *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetIntegervRobustANGLE", |
| "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLint * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetIntegervRobustANGLE(context, pname, bufSize, length, data)); |
| if (isCallValid) |
| { |
| context->getIntegervRobust(pname, bufSize, length, data); |
| } |
| ANGLE_CAPTURE(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, data); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramivRobustANGLE(GLuint program, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetGlobalContext(); |
| EVENT("glGetProgramivRobustANGLE", |
| "context = %d, GLuint program = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetProgramivRobustANGLE(context, programPacked, pname, bufSize, |
| length, params)); |
| if (isCallValid) |
| { |
| context->getProgramivRobust(programPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetRenderbufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetRenderbufferParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetRenderbufferParameterivRobustANGLE( |
| context, target, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY |
| GetShaderivRobustANGLE(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params) |
| { |
| Context *context = GetGlobalContext(); |
| EVENT("glGetShaderivRobustANGLE", |
| "context = %d, GLuint shader = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), shader, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID shaderPacked = FromGL<ShaderProgramID>(shader); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetShaderivRobustANGLE(context, shaderPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getShaderivRobust(shaderPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexParameterfvRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexParameterfvRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexParameterfvRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexParameterivRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetUniformfvRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetUniformfvRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetUniformfvRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getUniformfvRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetUniformfvRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetUniformivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetUniformivRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetUniformivRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getUniformivRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetUniformivRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribfvRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribfvRobustANGLE", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetVertexAttribfvRobustANGLE(context, index, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getVertexAttribfvRobust(index, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribivRobustANGLE", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetVertexAttribivRobustANGLE(context, index, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getVertexAttribivRobust(index, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribPointervRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| void **pointer) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribPointervRobustANGLE", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", void ** pointer = 0x%016" PRIxPTR "", |
| CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)pointer); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetVertexAttribPointervRobustANGLE( |
| context, index, pname, bufSize, length, pointer)); |
| if (isCallValid) |
| { |
| context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer); |
| } |
| ANGLE_CAPTURE(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname, |
| bufSize, length, pointer); |
| } |
| } |
| |
| void GL_APIENTRY ReadPixelsRobustANGLE(GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLsizei *columns, |
| GLsizei *rows, |
| void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glReadPixelsRobustANGLE", |
| "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum " |
| "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR |
| ", void * 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); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateReadPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize, |
| length, columns, rows, pixels)); |
| if (isCallValid) |
| { |
| context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns, |
| rows, pixels); |
| } |
| ANGLE_CAPTURE(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format, |
| type, bufSize, length, columns, rows, pixels); |
| } |
| } |
| |
| void GL_APIENTRY TexImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLint internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLint border, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| const void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexImage2DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei " |
| "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = " |
| "%s, GLsizei bufSize = %d, const void * 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); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexImage2DRobustANGLE(context, targetPacked, level, internalformat, width, |
| height, border, format, type, bufSize, pixels)); |
| if (isCallValid) |
| { |
| context->texImage2DRobust(targetPacked, level, internalformat, width, height, border, |
| format, type, bufSize, pixels); |
| } |
| ANGLE_CAPTURE(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level, |
| internalformat, width, height, border, format, type, bufSize, pixels); |
| } |
| } |
| |
| void GL_APIENTRY TexParameterfvRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexParameterfvRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const " |
| "GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexParameterfvRobustANGLE(context, targetPacked, pname, bufSize, params)); |
| if (isCallValid) |
| { |
| context->texParameterfvRobust(targetPacked, pname, bufSize, params); |
| } |
| ANGLE_CAPTURE(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, bufSize, |
| params); |
| } |
| } |
| |
| void GL_APIENTRY TexParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint " |
| "* params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexParameterivRobustANGLE(context, targetPacked, pname, bufSize, params)); |
| if (isCallValid) |
| { |
| context->texParameterivRobust(targetPacked, pname, bufSize, params); |
| } |
| ANGLE_CAPTURE(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize, |
| params); |
| } |
| } |
| |
| void GL_APIENTRY TexSubImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| const void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexSubImage2DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = " |
| "%d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type = %s, " |
| "GLsizei bufSize = %d, const void * 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); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexSubImage2DRobustANGLE(context, targetPacked, level, xoffset, yoffset, width, |
| height, format, type, bufSize, pixels)); |
| if (isCallValid) |
| { |
| context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height, |
| format, type, bufSize, pixels); |
| } |
| ANGLE_CAPTURE(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, xoffset, |
| yoffset, width, height, format, type, bufSize, pixels); |
| } |
| } |
| |
| void GL_APIENTRY TexImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLint internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| const void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexImage3DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei " |
| "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLenum format = " |
| "%s, GLenum type = %s, GLsizei bufSize = %d, const void * 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); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexImage3DRobustANGLE(context, targetPacked, level, internalformat, width, |
| height, depth, border, format, type, bufSize, pixels)); |
| if (isCallValid) |
| { |
| context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth, |
| border, format, type, bufSize, pixels); |
| } |
| ANGLE_CAPTURE(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level, |
| internalformat, width, height, depth, border, format, type, bufSize, pixels); |
| } |
| } |
| |
| void GL_APIENTRY TexSubImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| const void *pixels) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexSubImage3DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = " |
| "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, " |
| "GLenum format = %s, GLenum type = %s, GLsizei bufSize = %d, const void * 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); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateTexSubImage3DRobustANGLE(context, targetPacked, level, xoffset, |
| yoffset, zoffset, width, height, depth, |
| format, type, bufSize, pixels)); |
| if (isCallValid) |
| { |
| context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width, |
| height, depth, format, type, bufSize, pixels); |
| } |
| ANGLE_CAPTURE(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, xoffset, |
| yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); |
| } |
| } |
| |
| void GL_APIENTRY CompressedTexImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLint border, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const GLvoid *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCompressedTexImage2DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei " |
| "width = %d, GLsizei height = %d, GLint border = %d, GLsizei imageSize = %d, GLsizei " |
| "dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, |
| GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, border, |
| imageSize, dataSize, (uintptr_t)data); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateCompressedTexImage2DRobustANGLE( |
| context, targetPacked, level, internalformat, width, |
| height, border, imageSize, dataSize, data)); |
| if (isCallValid) |
| { |
| context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height, |
| border, imageSize, dataSize, data); |
| } |
| ANGLE_CAPTURE(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level, |
| internalformat, width, height, border, imageSize, dataSize, data); |
| } |
| } |
| |
| void GL_APIENTRY CompressedTexSubImage2DRobustANGLE(GLenum target, |
| GLint level, |
| GLsizei xoffset, |
| GLsizei yoffset, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const GLvoid *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCompressedTexSubImage2DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLsizei xoffset = %d, GLsizei " |
| "yoffset = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLsizei " |
| "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, xoffset, yoffset, |
| width, height, GLenumToString(GLenumGroup::DefaultGroup, format), imageSize, dataSize, |
| (uintptr_t)data); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateCompressedTexSubImage2DRobustANGLE( |
| context, targetPacked, level, xoffset, yoffset, width, |
| height, format, imageSize, dataSize, data)); |
| if (isCallValid) |
| { |
| context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, |
| height, format, imageSize, dataSize, data); |
| } |
| ANGLE_CAPTURE(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, |
| xoffset, yoffset, width, height, format, imageSize, dataSize, data); |
| } |
| } |
| |
| void GL_APIENTRY CompressedTexImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLint border, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const GLvoid *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCompressedTexImage3DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum internalformat = %s, GLsizei " |
| "width = %d, GLsizei height = %d, GLsizei depth = %d, GLint border = %d, GLsizei " |
| "imageSize = %d, GLsizei dataSize = %d, const GLvoid * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, |
| GLenumToString(GLenumGroup::DefaultGroup, internalformat), width, height, depth, border, |
| imageSize, dataSize, (uintptr_t)data); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateCompressedTexImage3DRobustANGLE( |
| context, targetPacked, level, internalformat, width, |
| height, depth, border, imageSize, dataSize, data)); |
| if (isCallValid) |
| { |
| context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height, |
| depth, border, imageSize, dataSize, data); |
| } |
| ANGLE_CAPTURE(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level, |
| internalformat, width, height, depth, border, imageSize, dataSize, data); |
| } |
| } |
| |
| void GL_APIENTRY CompressedTexSubImage3DRobustANGLE(GLenum target, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLenum format, |
| GLsizei imageSize, |
| GLsizei dataSize, |
| const GLvoid *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCompressedTexSubImage3DRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint xoffset = %d, GLint yoffset = " |
| "%d, GLint zoffset = %d, GLsizei width = %d, GLsizei height = %d, GLsizei depth = %d, " |
| "GLenum format = %s, GLsizei imageSize = %d, GLsizei dataSize = %d, const GLvoid * 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); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateCompressedTexSubImage3DRobustANGLE( |
| context, targetPacked, level, xoffset, yoffset, zoffset, width, |
| height, depth, format, imageSize, dataSize, data)); |
| if (isCallValid) |
| { |
| context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, |
| width, height, depth, format, imageSize, |
| dataSize, data); |
| } |
| ANGLE_CAPTURE(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, |
| xoffset, yoffset, zoffset, width, height, depth, format, imageSize, dataSize, |
| data); |
| } |
| } |
| |
| void GL_APIENTRY |
| GetQueryivRobustANGLE(GLenum target, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetQueryivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| QueryType targetPacked = FromGL<QueryType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetQueryivRobustANGLE(context, targetPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getQueryivRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetQueryObjectuivRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetQueryObjectuivRobustANGLE", |
| "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length " |
| "= 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| QueryID idPacked = FromGL<QueryID>(id); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetQueryObjectuivRobustANGLE( |
| context, idPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetBufferPointervRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| void **params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetBufferPointervRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", void ** params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| BufferBinding targetPacked = FromGL<BufferBinding>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetBufferPointervRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY |
| GetIntegeri_vRobustANGLE(GLenum target, GLuint index, GLsizei bufSize, GLsizei *length, GLint *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetIntegeri_vRobustANGLE", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, |
| (uintptr_t)length, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetIntegeri_vRobustANGLE(context, target, index, bufSize, length, data)); |
| if (isCallValid) |
| { |
| context->getIntegeri_vRobust(target, index, bufSize, length, data); |
| } |
| ANGLE_CAPTURE(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize, |
| length, data); |
| } |
| } |
| |
| void GL_APIENTRY GetInternalformativRobustANGLE(GLenum target, |
| GLenum internalformat, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetInternalformativRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum internalformat = %s, GLenum pname = %s, " |
| "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLint * 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); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetInternalformativRobustANGLE(context, target, internalformat, |
| pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getInternalformativRobust(target, internalformat, pname, bufSize, length, |
| params); |
| } |
| ANGLE_CAPTURE(GetInternalformativRobustANGLE, isCallValid, context, target, internalformat, |
| pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribIivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribIivRobustANGLE", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetVertexAttribIivRobustANGLE(context, index, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getVertexAttribIivRobust(index, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribIuivRobustANGLE(GLuint index, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribIuivRobustANGLE", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), index, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetVertexAttribIuivRobustANGLE( |
| context, index, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getVertexAttribIuivRobust(index, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetUniformuivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetUniformuivRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetUniformuivRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getUniformuivRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetUniformuivRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetActiveUniformBlockivRobustANGLE(GLuint program, |
| GLuint uniformBlockIndex, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetActiveUniformBlockivRobustANGLE", |
| "context = %d, GLuint program = %u, GLuint uniformBlockIndex = %u, GLenum pname = %s, " |
| "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), program, uniformBlockIndex, |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetActiveUniformBlockivRobustANGLE(context, programPacked, uniformBlockIndex, |
| pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndex, pname, bufSize, |
| length, params); |
| } |
| ANGLE_CAPTURE(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked, |
| uniformBlockIndex, pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetInteger64vRobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint64 *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetInteger64vRobustANGLE", |
| "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLint64 * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetInteger64vRobustANGLE(context, pname, bufSize, length, data)); |
| if (isCallValid) |
| { |
| context->getInteger64vRobust(pname, bufSize, length, data); |
| } |
| ANGLE_CAPTURE(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, data); |
| } |
| } |
| |
| void GL_APIENTRY GetInteger64i_vRobustANGLE(GLenum target, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint64 *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetInteger64i_vRobustANGLE", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint64 * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, |
| (uintptr_t)length, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetInteger64i_vRobustANGLE(context, target, index, bufSize, length, data)); |
| if (isCallValid) |
| { |
| context->getInteger64i_vRobust(target, index, bufSize, length, data); |
| } |
| ANGLE_CAPTURE(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize, |
| length, data); |
| } |
| } |
| |
| void GL_APIENTRY GetBufferParameteri64vRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint64 *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetBufferParameteri64vRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| BufferBinding targetPacked = FromGL<BufferBinding>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetBufferParameteri64vRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY SamplerParameterivRobustANGLE(GLuint sampler, |
| GLuint pname, |
| GLsizei bufSize, |
| const GLint *param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glSamplerParameterivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLuint pname = %u, GLsizei bufSize = %d, const GLint " |
| "* param = 0x%016" PRIxPTR "", |
| CID(context), sampler, pname, bufSize, (uintptr_t)param); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateSamplerParameterivRobustANGLE(context, samplerPacked, pname, bufSize, param)); |
| if (isCallValid) |
| { |
| context->samplerParameterivRobust(samplerPacked, pname, bufSize, param); |
| } |
| ANGLE_CAPTURE(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, param); |
| } |
| } |
| |
| void GL_APIENTRY SamplerParameterfvRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLfloat *param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glSamplerParameterfvRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const " |
| "GLfloat * param = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)param); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateSamplerParameterfvRobustANGLE(context, samplerPacked, pname, bufSize, param)); |
| if (isCallValid) |
| { |
| context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param); |
| } |
| ANGLE_CAPTURE(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, param); |
| } |
| } |
| |
| void GL_APIENTRY GetSamplerParameterivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetSamplerParameterivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetSamplerParameterivRobustANGLE(context, samplerPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetSamplerParameterfvRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetSamplerParameterfvRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetSamplerParameterfvRobustANGLE(context, samplerPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetFramebufferParameterivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetFramebufferParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetFramebufferParameterivRobustANGLE( |
| context, target, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getFramebufferParameterivRobust(target, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramInterfaceivRobustANGLE(GLuint program, |
| GLenum programInterface, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramInterfaceivRobustANGLE", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, " |
| "GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, programInterface), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramInterfaceivRobustANGLE(context, programPacked, programInterface, |
| pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize, |
| length, params); |
| } |
| ANGLE_CAPTURE(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked, |
| programInterface, pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetBooleani_vRobustANGLE(GLenum target, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLboolean *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetBooleani_vRobustANGLE", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLboolean * data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index, bufSize, |
| (uintptr_t)length, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetBooleani_vRobustANGLE(context, target, index, bufSize, length, data)); |
| if (isCallValid) |
| { |
| context->getBooleani_vRobust(target, index, bufSize, length, data); |
| } |
| ANGLE_CAPTURE(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize, |
| length, data); |
| } |
| } |
| |
| void GL_APIENTRY GetMultisamplefvRobustANGLE(GLenum pname, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *val) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetMultisamplefvRobustANGLE", |
| "context = %d, GLenum pname = %s, GLuint index = %u, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * val = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, bufSize, |
| (uintptr_t)length, (uintptr_t)val); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetMultisamplefvRobustANGLE(context, pname, index, bufSize, length, val)); |
| if (isCallValid) |
| { |
| context->getMultisamplefvRobust(pname, index, bufSize, length, val); |
| } |
| ANGLE_CAPTURE(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize, |
| length, val); |
| } |
| } |
| |
| void GL_APIENTRY GetTexLevelParameterivRobustANGLE(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexLevelParameterivRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize " |
| "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexLevelParameterivRobustANGLE( |
| context, targetPacked, level, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length, |
| params); |
| } |
| ANGLE_CAPTURE(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, level, |
| pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexLevelParameterfvRobustANGLE(GLenum target, |
| GLint level, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexLevelParameterfvRobustANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLsizei bufSize " |
| "= %d, GLsizei * length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), level, |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexLevelParameterfvRobustANGLE( |
| context, targetPacked, level, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length, |
| params); |
| } |
| ANGLE_CAPTURE(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, level, |
| pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetPointervRobustANGLERobustANGLE(GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| void **params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetPointervRobustANGLERobustANGLE", |
| "context = %d, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", void ** params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetPointervRobustANGLERobustANGLE(context, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getPointervRobustANGLERobust(pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY ReadnPixelsRobustANGLE(GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height, |
| GLenum format, |
| GLenum type, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLsizei *columns, |
| GLsizei *rows, |
| void *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glReadnPixelsRobustANGLE", |
| "context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, GLenum " |
| "format = %s, GLenum type = %s, GLsizei bufSize = %d, GLsizei * length = 0x%016" PRIxPTR |
| ", GLsizei * columns = 0x%016" PRIxPTR ", GLsizei * rows = 0x%016" PRIxPTR |
| ", void * 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); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateReadnPixelsRobustANGLE(context, x, y, width, height, format, type, bufSize, |
| length, columns, rows, data)); |
| if (isCallValid) |
| { |
| context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns, |
| rows, data); |
| } |
| ANGLE_CAPTURE(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format, |
| type, bufSize, length, columns, rows, data); |
| } |
| } |
| |
| void GL_APIENTRY GetnUniformfvRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetnUniformfvRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLfloat * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetnUniformfvRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getnUniformfvRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetnUniformivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetnUniformivRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetnUniformivRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getnUniformivRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetnUniformivRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetnUniformuivRobustANGLE(GLuint program, |
| GLint location, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetnUniformuivRobustANGLE", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetnUniformuivRobustANGLE(context, programPacked, location, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getnUniformuivRobust(programPacked, location, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetnUniformuivRobustANGLE, isCallValid, context, programPacked, location, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY TexParameterIivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexParameterIivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLint " |
| "* params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexParameterIivRobustANGLE(context, targetPacked, pname, bufSize, params)); |
| if (isCallValid) |
| { |
| context->texParameterIivRobust(targetPacked, pname, bufSize, params); |
| } |
| ANGLE_CAPTURE(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, params); |
| } |
| } |
| |
| void GL_APIENTRY TexParameterIuivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexParameterIuivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, const GLuint " |
| "* params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexParameterIuivRobustANGLE(context, targetPacked, pname, bufSize, params)); |
| if (isCallValid) |
| { |
| context->texParameterIuivRobust(targetPacked, pname, bufSize, params); |
| } |
| ANGLE_CAPTURE(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexParameterIivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexParameterIivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexParameterIivRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexParameterIuivRobustANGLE(GLenum target, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexParameterIuivRobustANGLE", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, (uintptr_t)length, |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetTexParameterIuivRobustANGLE(context, targetPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY SamplerParameterIivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLint *param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glSamplerParameterIivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const GLint " |
| "* param = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)param); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateSamplerParameterIivRobustANGLE(context, samplerPacked, pname, bufSize, param)); |
| if (isCallValid) |
| { |
| context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param); |
| } |
| ANGLE_CAPTURE(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, param); |
| } |
| } |
| |
| void GL_APIENTRY SamplerParameterIuivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| const GLuint *param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glSamplerParameterIuivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, const " |
| "GLuint * param = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)param); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateSamplerParameterIuivRobustANGLE( |
| context, samplerPacked, pname, bufSize, param)); |
| if (isCallValid) |
| { |
| context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param); |
| } |
| ANGLE_CAPTURE(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, param); |
| } |
| } |
| |
| void GL_APIENTRY GetSamplerParameterIivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetSamplerParameterIivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetSamplerParameterIivRobustANGLE(context, samplerPacked, pname, |
| bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetSamplerParameterIuivRobustANGLE(GLuint sampler, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetSamplerParameterIuivRobustANGLE", |
| "context = %d, GLuint sampler = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * " |
| "length = 0x%016" PRIxPTR ", GLuint * params = 0x%016" PRIxPTR "", |
| CID(context), sampler, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| SamplerID samplerPacked = FromGL<SamplerID>(sampler); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetSamplerParameterIuivRobustANGLE( |
| context, samplerPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, |
| pname, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetQueryObjectivRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetGlobalContext(); |
| EVENT("glGetQueryObjectivRobustANGLE", |
| "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length " |
| "= 0x%016" PRIxPTR ", GLint * params = 0x%016" PRIxPTR "", |
| CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| QueryID idPacked = FromGL<QueryID>(id); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetQueryObjectivRobustANGLE( |
| context, idPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetQueryObjecti64vRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint64 *params) |
| { |
| Context *context = GetGlobalContext(); |
| EVENT("glGetQueryObjecti64vRobustANGLE", |
| "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length " |
| "= 0x%016" PRIxPTR ", GLint64 * params = 0x%016" PRIxPTR "", |
| CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| QueryID idPacked = FromGL<QueryID>(id); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetQueryObjecti64vRobustANGLE( |
| context, idPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, bufSize, |
| length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetQueryObjectui64vRobustANGLE(GLuint id, |
| GLenum pname, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLuint64 *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetQueryObjectui64vRobustANGLE", |
| "context = %d, GLuint id = %u, GLenum pname = %s, GLsizei bufSize = %d, GLsizei * length " |
| "= 0x%016" PRIxPTR ", GLuint64 * params = 0x%016" PRIxPTR "", |
| CID(context), id, GLenumToString(GLenumGroup::DefaultGroup, pname), bufSize, |
| (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| QueryID idPacked = FromGL<QueryID>(id); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetQueryObjectui64vRobustANGLE( |
| context, idPacked, pname, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname, |
| bufSize, length, params); |
| } |
| } |
| |
| // GL_ANGLE_texture_external_update |
| void GL_APIENTRY TexImage2DExternalANGLE(GLenum target, |
| GLint level, |
| GLint internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLint border, |
| GLenum format, |
| GLenum type) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glTexImage2DExternalANGLE", |
| "context = %d, GLenum target = %s, GLint level = %d, GLint internalformat = %d, GLsizei " |
| "width = %d, GLsizei height = %d, GLint border = %d, GLenum format = %s, GLenum type = %s", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, internalformat, |
| width, height, border, GLenumToString(GLenumGroup::PixelFormat, format), |
| GLenumToString(GLenumGroup::PixelType, type)); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid <
|
