blob: 79dd76cc30693cd635f445e652e4d37076540297 [file] [log] [blame]
// 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 =