mozilla-central/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.cpp (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml.
//
// Copyright 2020 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_2_0_autogen.cpp:
// Defines the GLES 2.0 entry points.
#include "libGLESv2/entry_points_gles_2_0_autogen.h"
#include "common/entry_points_enum_autogen.h"
#include "libANGLE/Context.h"
#include "libANGLE/Context.inl.h"
#include "libANGLE/capture/capture_gles_2_0_autogen.h"
#include "libANGLE/capture/gl_enum_utils.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/validationES2.h"
#include "libGLESv2/global_state.h"
using namespace gl;
extern "C" {
void GL_APIENTRY GL_ActiveTexture(GLenum texture)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLActiveTexture, "context = %d, texture = %s", CID(context),
GLenumToString(GLESEnum::TextureUnit, texture));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateActiveTexture(context, angle::EntryPoint::GLActiveTexture, texture));
if (isCallValid)
{
context->activeTexture(texture);
}
ANGLE_CAPTURE_GL(ActiveTexture, isCallValid, context, texture);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_AttachShader(GLuint program, GLuint shader)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLAttachShader, "context = %d, program = %u, shader = %u", CID(context), program,
shader);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateAttachShader(context, angle::EntryPoint::GLAttachShader,
programPacked, shaderPacked));
if (isCallValid)
{
context->attachShader(programPacked, shaderPacked);
}
ANGLE_CAPTURE_GL(AttachShader, isCallValid, context, programPacked, shaderPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BindAttribLocation(GLuint program, GLuint index, const GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBindAttribLocation,
"context = %d, program = %u, index = %u, name = 0x%016" PRIxPTR "", CID(context), program,
index, (uintptr_t)name);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBindAttribLocation(context, angle::EntryPoint::GLBindAttribLocation,
programPacked, index, name));
if (isCallValid)
{
context->bindAttribLocation(programPacked, index, name);
}
ANGLE_CAPTURE_GL(BindAttribLocation, isCallValid, context, programPacked, index, name);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BindBuffer(GLenum target, GLuint buffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBindBuffer, "context = %d, target = %s, buffer = %u", CID(context),
GLenumToString(GLESEnum::BufferTargetARB, target), buffer);
if (context)
{
BufferBinding targetPacked = PackParam<BufferBinding>(target);
BufferID bufferPacked = PackParam<BufferID>(buffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBindBuffer(context, angle::EntryPoint::GLBindBuffer,
targetPacked, bufferPacked));
if (isCallValid)
{
context->bindBuffer(targetPacked, bufferPacked);
}
ANGLE_CAPTURE_GL(BindBuffer, isCallValid, context, targetPacked, bufferPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BindFramebuffer(GLenum target, GLuint framebuffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBindFramebuffer, "context = %d, target = %s, framebuffer = %u", CID(context),
GLenumToString(GLESEnum::FramebufferTarget, target), framebuffer);
if (context)
{
FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBindFramebuffer(context, angle::EntryPoint::GLBindFramebuffer,
target, framebufferPacked));
if (isCallValid)
{
context->bindFramebuffer(target, framebufferPacked);
}
ANGLE_CAPTURE_GL(BindFramebuffer, isCallValid, context, target, framebufferPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BindRenderbuffer(GLenum target, GLuint renderbuffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBindRenderbuffer, "context = %d, target = %s, renderbuffer = %u", CID(context),
GLenumToString(GLESEnum::RenderbufferTarget, target), renderbuffer);
if (context)
{
RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBindRenderbuffer(context, angle::EntryPoint::GLBindRenderbuffer,
target, renderbufferPacked));
if (isCallValid)
{
context->bindRenderbuffer(target, renderbufferPacked);
}
ANGLE_CAPTURE_GL(BindRenderbuffer, isCallValid, context, target, renderbufferPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BindTexture(GLenum target, GLuint texture)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBindTexture, "context = %d, target = %s, texture = %u", CID(context),
GLenumToString(GLESEnum::TextureTarget, target), texture);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
TextureID texturePacked = PackParam<TextureID>(texture);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBindTexture(context, angle::EntryPoint::GLBindTexture,
targetPacked, texturePacked));
if (isCallValid)
{
context->bindTexture(targetPacked, texturePacked);
}
ANGLE_CAPTURE_GL(BindTexture, isCallValid, context, targetPacked, texturePacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBlendColor, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendColor(context, angle::EntryPoint::GLBlendColor, red, green, blue, alpha));
if (isCallValid)
{
context->blendColor(red, green, blue, alpha);
}
ANGLE_CAPTURE_GL(BlendColor, isCallValid, context, red, green, blue, alpha);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BlendEquation(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBlendEquation, "context = %d, mode = %s", CID(context),
GLenumToString(GLESEnum::BlendEquationModeEXT, mode));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendEquation(context, angle::EntryPoint::GLBlendEquation, mode));
if (isCallValid)
{
context->blendEquation(mode);
}
ANGLE_CAPTURE_GL(BlendEquation, isCallValid, context, mode);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBlendEquationSeparate, "context = %d, modeRGB = %s, modeAlpha = %s",
CID(context), GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB),
GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendEquationSeparate(context, angle::EntryPoint::GLBlendEquationSeparate,
modeRGB, modeAlpha));
if (isCallValid)
{
context->blendEquationSeparate(modeRGB, modeAlpha);
}
ANGLE_CAPTURE_GL(BlendEquationSeparate, isCallValid, context, modeRGB, modeAlpha);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BlendFunc(GLenum sfactor, GLenum dfactor)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBlendFunc, "context = %d, sfactor = %s, dfactor = %s", CID(context),
GLenumToString(GLESEnum::BlendingFactor, sfactor),
GLenumToString(GLESEnum::BlendingFactor, dfactor));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendFunc(context, angle::EntryPoint::GLBlendFunc, sfactor, dfactor));
if (isCallValid)
{
context->blendFunc(sfactor, dfactor);
}
ANGLE_CAPTURE_GL(BlendFunc, isCallValid, context, sfactor, dfactor);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BlendFuncSeparate(GLenum sfactorRGB,
GLenum dfactorRGB,
GLenum sfactorAlpha,
GLenum dfactorAlpha)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBlendFuncSeparate,
"context = %d, sfactorRGB = %s, dfactorRGB = %s, sfactorAlpha = %s, dfactorAlpha = %s",
CID(context), GLenumToString(GLESEnum::BlendingFactor, sfactorRGB),
GLenumToString(GLESEnum::BlendingFactor, dfactorRGB),
GLenumToString(GLESEnum::BlendingFactor, sfactorAlpha),
GLenumToString(GLESEnum::BlendingFactor, dfactorAlpha));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendFuncSeparate(context, angle::EntryPoint::GLBlendFuncSeparate, sfactorRGB,
dfactorRGB, sfactorAlpha, dfactorAlpha));
if (isCallValid)
{
context->blendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}
ANGLE_CAPTURE_GL(BlendFuncSeparate, isCallValid, context, sfactorRGB, dfactorRGB,
sfactorAlpha, dfactorAlpha);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBufferData,
"context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", usage = %s",
CID(context), GLenumToString(GLESEnum::BufferTargetARB, target),
static_cast<unsigned long long>(size), (uintptr_t)data,
GLenumToString(GLESEnum::BufferUsageARB, usage));
if (context)
{
BufferBinding targetPacked = PackParam<BufferBinding>(target);
BufferUsage usagePacked = PackParam<BufferUsage>(usage);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBufferData(context, angle::EntryPoint::GLBufferData,
targetPacked, size, data, usagePacked));
if (isCallValid)
{
context->bufferData(targetPacked, size, data, usagePacked);
}
ANGLE_CAPTURE_GL(BufferData, isCallValid, context, targetPacked, size, data, usagePacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_BufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLBufferSubData,
"context = %d, target = %s, offset = %llu, size = %llu, data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::BufferTargetARB, target),
static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size),
(uintptr_t)data);
if (context)
{
BufferBinding targetPacked = PackParam<BufferBinding>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateBufferSubData(context, angle::EntryPoint::GLBufferSubData,
targetPacked, offset, size, data));
if (isCallValid)
{
context->bufferSubData(targetPacked, offset, size, data);
}
ANGLE_CAPTURE_GL(BufferSubData, isCallValid, context, targetPacked, offset, size, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLenum GL_APIENTRY GL_CheckFramebufferStatus(GLenum target)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCheckFramebufferStatus, "context = %d, target = %s", CID(context),
GLenumToString(GLESEnum::FramebufferTarget, target));
GLenum returnValue;
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateCheckFramebufferStatus(
context, angle::EntryPoint::GLCheckFramebufferStatus, target));
if (isCallValid)
{
returnValue = context->checkFramebufferStatus(target);
}
else
{
returnValue =
GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatus, GLenum>();
}
ANGLE_CAPTURE_GL(CheckFramebufferStatus, isCallValid, context, target, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatus, GLenum>();
}
return returnValue;
}
void GL_APIENTRY GL_Clear(GLbitfield mask)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLClear, "context = %d, mask = %s", CID(context),
GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str());
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateClear(context, angle::EntryPoint::GLClear, mask));
if (isCallValid)
{
context->clear(mask);
}
ANGLE_CAPTURE_GL(Clear, isCallValid, context, mask);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLClearColor, "context = %d, red = %f, green = %f, blue = %f, alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateClearColor(context, angle::EntryPoint::GLClearColor, red, green, blue, alpha));
if (isCallValid)
{
context->clearColor(red, green, blue, alpha);
}
ANGLE_CAPTURE_GL(ClearColor, isCallValid, context, red, green, blue, alpha);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ClearDepthf(GLfloat d)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLClearDepthf, "context = %d, d = %f", CID(context), d);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateClearDepthf(context, angle::EntryPoint::GLClearDepthf, d));
if (isCallValid)
{
context->clearDepthf(d);
}
ANGLE_CAPTURE_GL(ClearDepthf, isCallValid, context, d);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ClearStencil(GLint s)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLClearStencil, "context = %d, s = %d", CID(context), s);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateClearStencil(context, angle::EntryPoint::GLClearStencil, s));
if (isCallValid)
{
context->clearStencil(s);
}
ANGLE_CAPTURE_GL(ClearStencil, isCallValid, context, s);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLColorMask, "context = %d, red = %s, green = %s, blue = %s, alpha = %s",
CID(context), GLbooleanToString(red), GLbooleanToString(green), GLbooleanToString(blue),
GLbooleanToString(alpha));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateColorMask(context, angle::EntryPoint::GLColorMask, red, green, blue, alpha));
if (isCallValid)
{
context->colorMask(red, green, blue, alpha);
}
ANGLE_CAPTURE_GL(ColorMask, isCallValid, context, red, green, blue, alpha);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_CompileShader(GLuint shader)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCompileShader, "context = %d, shader = %u", CID(context), shader);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateCompileShader(context, angle::EntryPoint::GLCompileShader, shaderPacked));
if (isCallValid)
{
context->compileShader(shaderPacked);
}
ANGLE_CAPTURE_GL(CompileShader, isCallValid, context, shaderPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_CompressedTexImage2D(GLenum target,
GLint level,
GLenum internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLsizei imageSize,
const void *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCompressedTexImage2D,
"context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, "
"border = %d, imageSize = %d, data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, border,
imageSize, (uintptr_t)data);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateCompressedTexImage2D(
context, angle::EntryPoint::GLCompressedTexImage2D, targetPacked,
level, internalformat, width, height, border, imageSize, data));
if (isCallValid)
{
context->compressedTexImage2D(targetPacked, level, internalformat, width, height,
border, imageSize, data);
}
ANGLE_CAPTURE_GL(CompressedTexImage2D, isCallValid, context, targetPacked, level,
internalformat, width, height, border, imageSize, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_CompressedTexSubImage2D(GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLsizei imageSize,
const void *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCompressedTexSubImage2D,
"context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
"%d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
width, height, GLenumToString(GLESEnum::InternalFormat, format), imageSize,
(uintptr_t)data);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateCompressedTexSubImage2D(
context, angle::EntryPoint::GLCompressedTexSubImage2D, targetPacked,
level, xoffset, yoffset, width, height, format, imageSize, data));
if (isCallValid)
{
context->compressedTexSubImage2D(targetPacked, level, xoffset, yoffset, width, height,
format, imageSize, data);
}
ANGLE_CAPTURE_GL(CompressedTexSubImage2D, isCallValid, context, targetPacked, level,
xoffset, yoffset, width, height, format, imageSize, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_CopyTexImage2D(GLenum target,
GLint level,
GLenum internalformat,
GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLint border)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCopyTexImage2D,
"context = %d, target = %s, level = %d, internalformat = %s, x = %d, y = %d, width = %d, "
"height = %d, border = %d",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level,
GLenumToString(GLESEnum::InternalFormat, internalformat), x, y, width, height, border);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateCopyTexImage2D(context, angle::EntryPoint::GLCopyTexImage2D, targetPacked,
level, internalformat, x, y, width, height, border));
if (isCallValid)
{
context->copyTexImage2D(targetPacked, level, internalformat, x, y, width, height,
border);
}
ANGLE_CAPTURE_GL(CopyTexImage2D, isCallValid, context, targetPacked, level, internalformat,
x, y, width, height, border);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_CopyTexSubImage2D(GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLint x,
GLint y,
GLsizei width,
GLsizei height)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCopyTexSubImage2D,
"context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, x = %d, y = %d, "
"width = %d, height = %d",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, x,
y, width, height);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateCopyTexSubImage2D(context, angle::EntryPoint::GLCopyTexSubImage2D,
targetPacked, level, xoffset, yoffset, x, y, width, height));
if (isCallValid)
{
context->copyTexSubImage2D(targetPacked, level, xoffset, yoffset, x, y, width, height);
}
ANGLE_CAPTURE_GL(CopyTexSubImage2D, isCallValid, context, targetPacked, level, xoffset,
yoffset, x, y, width, height);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLuint GL_APIENTRY GL_CreateProgram()
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCreateProgram, "context = %d", CID(context));
GLuint returnValue;
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateCreateProgram(context, angle::EntryPoint::GLCreateProgram));
if (isCallValid)
{
returnValue = context->createProgram();
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
}
ANGLE_CAPTURE_GL(CreateProgram, isCallValid, context, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateProgram, GLuint>();
}
return returnValue;
}
GLuint GL_APIENTRY GL_CreateShader(GLenum type)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCreateShader, "context = %d, type = %s", CID(context),
GLenumToString(GLESEnum::ShaderType, type));
GLuint returnValue;
if (context)
{
ShaderType typePacked = PackParam<ShaderType>(type);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateCreateShader(context, angle::EntryPoint::GLCreateShader, typePacked));
if (isCallValid)
{
returnValue = context->createShader(typePacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
}
ANGLE_CAPTURE_GL(CreateShader, isCallValid, context, typePacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShader, GLuint>();
}
return returnValue;
}
void GL_APIENTRY GL_CullFace(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLCullFace, "context = %d, mode = %s", CID(context),
GLenumToString(GLESEnum::TriangleFace, mode));
if (context)
{
CullFaceMode modePacked = PackParam<CullFaceMode>(mode);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateCullFace(context, angle::EntryPoint::GLCullFace, modePacked));
if (isCallValid)
{
context->cullFace(modePacked);
}
ANGLE_CAPTURE_GL(CullFace, isCallValid, context, modePacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteBuffers(GLsizei n, const GLuint *buffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteBuffers, "context = %d, n = %d, buffers = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)buffers);
if (context)
{
const BufferID *buffersPacked = PackParam<const BufferID *>(buffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDeleteBuffers(context, angle::EntryPoint::GLDeleteBuffers, n, buffersPacked));
if (isCallValid)
{
context->deleteBuffers(n, buffersPacked);
}
ANGLE_CAPTURE_GL(DeleteBuffers, isCallValid, context, n, buffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteFramebuffers, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)framebuffers);
if (context)
{
const FramebufferID *framebuffersPacked = PackParam<const FramebufferID *>(framebuffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDeleteFramebuffers(context, angle::EntryPoint::GLDeleteFramebuffers, n,
framebuffersPacked));
if (isCallValid)
{
context->deleteFramebuffers(n, framebuffersPacked);
}
ANGLE_CAPTURE_GL(DeleteFramebuffers, isCallValid, context, n, framebuffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteProgram(GLuint program)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteProgram, "context = %d, program = %u", CID(context), program);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDeleteProgram(context, angle::EntryPoint::GLDeleteProgram, programPacked));
if (isCallValid)
{
context->deleteProgram(programPacked);
}
ANGLE_CAPTURE_GL(DeleteProgram, isCallValid, context, programPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteRenderbuffers, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)renderbuffers);
if (context)
{
const RenderbufferID *renderbuffersPacked =
PackParam<const RenderbufferID *>(renderbuffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDeleteRenderbuffers(context, angle::EntryPoint::GLDeleteRenderbuffers, n,
renderbuffersPacked));
if (isCallValid)
{
context->deleteRenderbuffers(n, renderbuffersPacked);
}
ANGLE_CAPTURE_GL(DeleteRenderbuffers, isCallValid, context, n, renderbuffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteShader(GLuint shader)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteShader, "context = %d, shader = %u", CID(context), shader);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDeleteShader(context, angle::EntryPoint::GLDeleteShader, shaderPacked));
if (isCallValid)
{
context->deleteShader(shaderPacked);
}
ANGLE_CAPTURE_GL(DeleteShader, isCallValid, context, shaderPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DeleteTextures(GLsizei n, const GLuint *textures)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDeleteTextures, "context = %d, n = %d, textures = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)textures);
if (context)
{
const TextureID *texturesPacked = PackParam<const TextureID *>(textures);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDeleteTextures(context, angle::EntryPoint::GLDeleteTextures, n,
texturesPacked));
if (isCallValid)
{
context->deleteTextures(n, texturesPacked);
}
ANGLE_CAPTURE_GL(DeleteTextures, isCallValid, context, n, texturesPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DepthFunc(GLenum func)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDepthFunc, "context = %d, func = %s", CID(context),
GLenumToString(GLESEnum::DepthFunction, func));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDepthFunc(context, angle::EntryPoint::GLDepthFunc, func));
if (isCallValid)
{
context->depthFunc(func);
}
ANGLE_CAPTURE_GL(DepthFunc, isCallValid, context, func);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DepthMask(GLboolean flag)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDepthMask, "context = %d, flag = %s", CID(context), GLbooleanToString(flag));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDepthMask(context, angle::EntryPoint::GLDepthMask, flag));
if (isCallValid)
{
context->depthMask(flag);
}
ANGLE_CAPTURE_GL(DepthMask, isCallValid, context, flag);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DepthRangef(GLfloat n, GLfloat f)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDepthRangef, "context = %d, n = %f, f = %f", CID(context), n, f);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDepthRangef(context, angle::EntryPoint::GLDepthRangef, n, f));
if (isCallValid)
{
context->depthRangef(n, f);
}
ANGLE_CAPTURE_GL(DepthRangef, isCallValid, context, n, f);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDetachShader, "context = %d, program = %u, shader = %u", CID(context), program,
shader);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDetachShader(context, angle::EntryPoint::GLDetachShader,
programPacked, shaderPacked));
if (isCallValid)
{
context->detachShader(programPacked, shaderPacked);
}
ANGLE_CAPTURE_GL(DetachShader, isCallValid, context, programPacked, shaderPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Disable(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDisable, "context = %d, cap = %s", CID(context),
GLenumToString(GLESEnum::EnableCap, cap));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDisable(context, angle::EntryPoint::GLDisable, cap));
if (isCallValid)
{
context->disable(cap);
}
ANGLE_CAPTURE_GL(Disable, isCallValid, context, cap);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DisableVertexAttribArray(GLuint index)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDisableVertexAttribArray, "context = %d, index = %u", CID(context), index);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDisableVertexAttribArray(
context, angle::EntryPoint::GLDisableVertexAttribArray, index));
if (isCallValid)
{
context->disableVertexAttribArray(index);
}
ANGLE_CAPTURE_GL(DisableVertexAttribArray, isCallValid, context, index);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DrawArrays(GLenum mode, GLint first, GLsizei count)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDrawArrays, "context = %d, mode = %s, first = %d, count = %d", CID(context),
GLenumToString(GLESEnum::PrimitiveType, mode), first, count);
if (context)
{
PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDrawArrays(context, angle::EntryPoint::GLDrawArrays, modePacked,
first, count));
if (isCallValid)
{
context->drawArrays(modePacked, first, count);
}
ANGLE_CAPTURE_GL(DrawArrays, isCallValid, context, modePacked, first, count);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_DrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLDrawElements,
"context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count,
GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices);
if (context)
{
PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode);
DrawElementsType typePacked = PackParam<DrawElementsType>(type);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateDrawElements(context, angle::EntryPoint::GLDrawElements,
modePacked, count, typePacked, indices));
if (isCallValid)
{
context->drawElements(modePacked, count, typePacked, indices);
}
ANGLE_CAPTURE_GL(DrawElements, isCallValid, context, modePacked, count, typePacked,
indices);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Enable(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLEnable, "context = %d, cap = %s", CID(context),
GLenumToString(GLESEnum::EnableCap, cap));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateEnable(context, angle::EntryPoint::GLEnable, cap));
if (isCallValid)
{
context->enable(cap);
}
ANGLE_CAPTURE_GL(Enable, isCallValid, context, cap);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_EnableVertexAttribArray(GLuint index)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLEnableVertexAttribArray, "context = %d, index = %u", CID(context), index);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateEnableVertexAttribArray(
context, angle::EntryPoint::GLEnableVertexAttribArray, index));
if (isCallValid)
{
context->enableVertexAttribArray(index);
}
ANGLE_CAPTURE_GL(EnableVertexAttribArray, isCallValid, context, index);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Finish()
{
Context *context = GetValidGlobalContext();
EVENT(context, GLFinish, "context = %d", CID(context));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateFinish(context, angle::EntryPoint::GLFinish));
if (isCallValid)
{
context->finish();
}
ANGLE_CAPTURE_GL(Finish, isCallValid, context);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Flush()
{
Context *context = GetValidGlobalContext();
EVENT(context, GLFlush, "context = %d", CID(context));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateFlush(context, angle::EntryPoint::GLFlush));
if (isCallValid)
{
context->flush();
}
ANGLE_CAPTURE_GL(Flush, isCallValid, context);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_FramebufferRenderbuffer(GLenum target,
GLenum attachment,
GLenum renderbuffertarget,
GLuint renderbuffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLFramebufferRenderbuffer,
"context = %d, target = %s, attachment = %s, renderbuffertarget = %s, renderbuffer = %u",
CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
GLenumToString(GLESEnum::FramebufferAttachment, attachment),
GLenumToString(GLESEnum::RenderbufferTarget, renderbuffertarget), renderbuffer);
if (context)
{
RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateFramebufferRenderbuffer(
context, angle::EntryPoint::GLFramebufferRenderbuffer, target,
attachment, renderbuffertarget, renderbufferPacked));
if (isCallValid)
{
context->framebufferRenderbuffer(target, attachment, renderbuffertarget,
renderbufferPacked);
}
ANGLE_CAPTURE_GL(FramebufferRenderbuffer, isCallValid, context, target, attachment,
renderbuffertarget, renderbufferPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_FramebufferTexture2D(GLenum target,
GLenum attachment,
GLenum textarget,
GLuint texture,
GLint level)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLFramebufferTexture2D,
"context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d",
CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
GLenumToString(GLESEnum::FramebufferAttachment, attachment),
GLenumToString(GLESEnum::TextureTarget, textarget), texture, level);
if (context)
{
TextureTarget textargetPacked = PackParam<TextureTarget>(textarget);
TextureID texturePacked = PackParam<TextureID>(texture);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateFramebufferTexture2D(
context, angle::EntryPoint::GLFramebufferTexture2D, target,
attachment, textargetPacked, texturePacked, level));
if (isCallValid)
{
context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked,
level);
}
ANGLE_CAPTURE_GL(FramebufferTexture2D, isCallValid, context, target, attachment,
textargetPacked, texturePacked, level);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_FrontFace(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLFrontFace, "context = %d, mode = %s", CID(context),
GLenumToString(GLESEnum::FrontFaceDirection, mode));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateFrontFace(context, angle::EntryPoint::GLFrontFace, mode));
if (isCallValid)
{
context->frontFace(mode);
}
ANGLE_CAPTURE_GL(FrontFace, isCallValid, context, mode);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GenBuffers(GLsizei n, GLuint *buffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGenBuffers, "context = %d, n = %d, buffers = 0x%016" PRIxPTR "", CID(context),
n, (uintptr_t)buffers);
if (context)
{
BufferID *buffersPacked = PackParam<BufferID *>(buffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGenBuffers(context, angle::EntryPoint::GLGenBuffers, n, buffersPacked));
if (isCallValid)
{
context->genBuffers(n, buffersPacked);
}
ANGLE_CAPTURE_GL(GenBuffers, isCallValid, context, n, buffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GenFramebuffers(GLsizei n, GLuint *framebuffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGenFramebuffers, "context = %d, n = %d, framebuffers = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)framebuffers);
if (context)
{
FramebufferID *framebuffersPacked = PackParam<FramebufferID *>(framebuffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGenFramebuffers(context, angle::EntryPoint::GLGenFramebuffers,
n, framebuffersPacked));
if (isCallValid)
{
context->genFramebuffers(n, framebuffersPacked);
}
ANGLE_CAPTURE_GL(GenFramebuffers, isCallValid, context, n, framebuffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GenRenderbuffers(GLsizei n, GLuint *renderbuffers)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGenRenderbuffers, "context = %d, n = %d, renderbuffers = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)renderbuffers);
if (context)
{
RenderbufferID *renderbuffersPacked = PackParam<RenderbufferID *>(renderbuffers);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGenRenderbuffers(context, angle::EntryPoint::GLGenRenderbuffers,
n, renderbuffersPacked));
if (isCallValid)
{
context->genRenderbuffers(n, renderbuffersPacked);
}
ANGLE_CAPTURE_GL(GenRenderbuffers, isCallValid, context, n, renderbuffersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GenTextures(GLsizei n, GLuint *textures)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGenTextures, "context = %d, n = %d, textures = 0x%016" PRIxPTR "",
CID(context), n, (uintptr_t)textures);
if (context)
{
TextureID *texturesPacked = PackParam<TextureID *>(textures);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGenTextures(context, angle::EntryPoint::GLGenTextures, n, texturesPacked));
if (isCallValid)
{
context->genTextures(n, texturesPacked);
}
ANGLE_CAPTURE_GL(GenTextures, isCallValid, context, n, texturesPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GenerateMipmap(GLenum target)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGenerateMipmap, "context = %d, target = %s", CID(context),
GLenumToString(GLESEnum::TextureTarget, target));
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGenerateMipmap(context, angle::EntryPoint::GLGenerateMipmap, targetPacked));
if (isCallValid)
{
context->generateMipmap(targetPacked);
}
ANGLE_CAPTURE_GL(GenerateMipmap, isCallValid, context, targetPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetActiveAttrib(GLuint program,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint *size,
GLenum *type,
GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetActiveAttrib,
"context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
(uintptr_t)type, (uintptr_t)name);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetActiveAttrib(context, angle::EntryPoint::GLGetActiveAttrib, programPacked,
index, bufSize, length, size, type, name));
if (isCallValid)
{
context->getActiveAttrib(programPacked, index, bufSize, length, size, type, name);
}
ANGLE_CAPTURE_GL(GetActiveAttrib, isCallValid, context, programPacked, index, bufSize,
length, size, type, name);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetActiveUniform(GLuint program,
GLuint index,
GLsizei bufSize,
GLsizei *length,
GLint *size,
GLenum *type,
GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetActiveUniform,
"context = %d, program = %u, index = %u, bufSize = %d, length = 0x%016" PRIxPTR
", size = 0x%016" PRIxPTR ", type = 0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "",
CID(context), program, index, bufSize, (uintptr_t)length, (uintptr_t)size,
(uintptr_t)type, (uintptr_t)name);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetActiveUniform(context, angle::EntryPoint::GLGetActiveUniform, programPacked,
index, bufSize, length, size, type, name));
if (isCallValid)
{
context->getActiveUniform(programPacked, index, bufSize, length, size, type, name);
}
ANGLE_CAPTURE_GL(GetActiveUniform, isCallValid, context, programPacked, index, bufSize,
length, size, type, name);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetAttachedShaders(GLuint program,
GLsizei maxCount,
GLsizei *count,
GLuint *shaders)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetAttachedShaders,
"context = %d, program = %u, maxCount = %d, count = 0x%016" PRIxPTR
", shaders = 0x%016" PRIxPTR "",
CID(context), program, maxCount, (uintptr_t)count, (uintptr_t)shaders);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
ShaderProgramID *shadersPacked = PackParam<ShaderProgramID *>(shaders);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetAttachedShaders(context, angle::EntryPoint::GLGetAttachedShaders,
programPacked, maxCount, count, shadersPacked));
if (isCallValid)
{
context->getAttachedShaders(programPacked, maxCount, count, shadersPacked);
}
ANGLE_CAPTURE_GL(GetAttachedShaders, isCallValid, context, programPacked, maxCount, count,
shadersPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLint GL_APIENTRY GL_GetAttribLocation(GLuint program, const GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetAttribLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
CID(context), program, (uintptr_t)name);
GLint returnValue;
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetAttribLocation(context, angle::EntryPoint::GLGetAttribLocation,
programPacked, name));
if (isCallValid)
{
returnValue = context->getAttribLocation(programPacked, name);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
}
ANGLE_CAPTURE_GL(GetAttribLocation, isCallValid, context, programPacked, name, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetAttribLocation, GLint>();
}
return returnValue;
}
void GL_APIENTRY GL_GetBooleanv(GLenum pname, GLboolean *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetBooleanv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetBooleanv(context, angle::EntryPoint::GLGetBooleanv, pname, data));
if (isCallValid)
{
context->getBooleanv(pname, data);
}
ANGLE_CAPTURE_GL(GetBooleanv, isCallValid, context, pname, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetBufferParameteriv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::BufferTargetARB, target),
GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
if (context)
{
BufferBinding targetPacked = PackParam<BufferBinding>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetBufferParameteriv(context, angle::EntryPoint::GLGetBufferParameteriv,
targetPacked, pname, params));
if (isCallValid)
{
context->getBufferParameteriv(targetPacked, pname, params);
}
ANGLE_CAPTURE_GL(GetBufferParameteriv, isCallValid, context, targetPacked, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLenum GL_APIENTRY GL_GetError()
{
Context *context = GetGlobalContext();
EVENT(context, GLGetError, "context = %d", CID(context));
GLenum returnValue;
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateGetError(context, angle::EntryPoint::GLGetError));
if (isCallValid)
{
returnValue = context->getError();
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetError, GLenum>();
}
ANGLE_CAPTURE_GL(GetError, isCallValid, context, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetError, GLenum>();
}
return returnValue;
}
void GL_APIENTRY GL_GetFloatv(GLenum pname, GLfloat *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetFloatv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetFloatv(context, angle::EntryPoint::GLGetFloatv, pname, data));
if (isCallValid)
{
context->getFloatv(pname, data);
}
ANGLE_CAPTURE_GL(GetFloatv, isCallValid, context, pname, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetFramebufferAttachmentParameteriv(GLenum target,
GLenum attachment,
GLenum pname,
GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetFramebufferAttachmentParameteriv,
"context = %d, target = %s, attachment = %s, pname = %s, params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::FramebufferTarget, target),
GLenumToString(GLESEnum::FramebufferAttachment, attachment),
GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetFramebufferAttachmentParameteriv(
context, angle::EntryPoint::GLGetFramebufferAttachmentParameteriv,
target, attachment, pname, params));
if (isCallValid)
{
context->getFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameteriv, isCallValid, context, target,
attachment, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetIntegerv(GLenum pname, GLint *data)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetIntegerv, "context = %d, pname = %s, data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)data);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetIntegerv(context, angle::EntryPoint::GLGetIntegerv, pname, data));
if (isCallValid)
{
context->getIntegerv(pname, data);
}
ANGLE_CAPTURE_GL(GetIntegerv, isCallValid, context, pname, data);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetProgramInfoLog(GLuint program,
GLsizei bufSize,
GLsizei *length,
GLchar *infoLog)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetProgramInfoLog,
"context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR
", infoLog = 0x%016" PRIxPTR "",
CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetProgramInfoLog(context, angle::EntryPoint::GLGetProgramInfoLog,
programPacked, bufSize, length, infoLog));
if (isCallValid)
{
context->getProgramInfoLog(programPacked, bufSize, length, infoLog);
}
ANGLE_CAPTURE_GL(GetProgramInfoLog, isCallValid, context, programPacked, bufSize, length,
infoLog);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params)
{
Context *context = GetGlobalContext();
EVENT(context, GLGetProgramiv,
"context = %d, program = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
program, GLenumToString(GLESEnum::ProgramPropertyARB, pname), (uintptr_t)params);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetProgramiv(context, angle::EntryPoint::GLGetProgramiv,
programPacked, pname, params));
if (isCallValid)
{
context->getProgramiv(programPacked, pname, params);
}
ANGLE_CAPTURE_GL(GetProgramiv, isCallValid, context, programPacked, pname, params);
}
else
{}
}
void GL_APIENTRY GL_GetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetRenderbufferParameteriv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::RenderbufferTarget, target),
GLenumToString(GLESEnum::RenderbufferParameterName, pname), (uintptr_t)params);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetRenderbufferParameteriv(
context, angle::EntryPoint::GLGetRenderbufferParameteriv, target, pname, params));
if (isCallValid)
{
context->getRenderbufferParameteriv(target, pname, params);
}
ANGLE_CAPTURE_GL(GetRenderbufferParameteriv, isCallValid, context, target, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetShaderInfoLog(GLuint shader,
GLsizei bufSize,
GLsizei *length,
GLchar *infoLog)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetShaderInfoLog,
"context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
", infoLog = 0x%016" PRIxPTR "",
CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)infoLog);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetShaderInfoLog(context, angle::EntryPoint::GLGetShaderInfoLog,
shaderPacked, bufSize, length, infoLog));
if (isCallValid)
{
context->getShaderInfoLog(shaderPacked, bufSize, length, infoLog);
}
ANGLE_CAPTURE_GL(GetShaderInfoLog, isCallValid, context, shaderPacked, bufSize, length,
infoLog);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetShaderPrecisionFormat(GLenum shadertype,
GLenum precisiontype,
GLint *range,
GLint *precision)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetShaderPrecisionFormat,
"context = %d, shadertype = %s, precisiontype = %s, range = 0x%016" PRIxPTR
", precision = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::ShaderType, shadertype),
GLenumToString(GLESEnum::PrecisionType, precisiontype), (uintptr_t)range,
(uintptr_t)precision);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetShaderPrecisionFormat(
context, angle::EntryPoint::GLGetShaderPrecisionFormat, shadertype,
precisiontype, range, precision));
if (isCallValid)
{
context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}
ANGLE_CAPTURE_GL(GetShaderPrecisionFormat, isCallValid, context, shadertype, precisiontype,
range, precision);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetShaderSource,
"context = %d, shader = %u, bufSize = %d, length = 0x%016" PRIxPTR
", source = 0x%016" PRIxPTR "",
CID(context), shader, bufSize, (uintptr_t)length, (uintptr_t)source);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetShaderSource(context, angle::EntryPoint::GLGetShaderSource,
shaderPacked, bufSize, length, source));
if (isCallValid)
{
context->getShaderSource(shaderPacked, bufSize, length, source);
}
ANGLE_CAPTURE_GL(GetShaderSource, isCallValid, context, shaderPacked, bufSize, length,
source);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params)
{
Context *context = GetGlobalContext();
EVENT(context, GLGetShaderiv,
"context = %d, shader = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), shader,
GLenumToString(GLESEnum::ShaderParameterName, pname), (uintptr_t)params);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetShaderiv(context, angle::EntryPoint::GLGetShaderiv,
shaderPacked, pname, params));
if (isCallValid)
{
context->getShaderiv(shaderPacked, pname, params);
}
ANGLE_CAPTURE_GL(GetShaderiv, isCallValid, context, shaderPacked, pname, params);
}
else
{}
}
const GLubyte *GL_APIENTRY GL_GetString(GLenum name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetString, "context = %d, name = %s", CID(context),
GLenumToString(GLESEnum::StringName, name));
const GLubyte *returnValue;
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetString(context, angle::EntryPoint::GLGetString, name));
if (isCallValid)
{
returnValue = context->getString(name);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetString, const GLubyte *>();
}
ANGLE_CAPTURE_GL(GetString, isCallValid, context, name, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetString, const GLubyte *>();
}
return returnValue;
}
void GL_APIENTRY GL_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetTexParameterfv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetTexParameterfv(context, angle::EntryPoint::GLGetTexParameterfv,
targetPacked, pname, params));
if (isCallValid)
{
context->getTexParameterfv(targetPacked, pname, params);
}
ANGLE_CAPTURE_GL(GetTexParameterfv, isCallValid, context, targetPacked, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetTexParameteriv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetTexParameteriv(context, angle::EntryPoint::GLGetTexParameteriv,
targetPacked, pname, params));
if (isCallValid)
{
context->getTexParameteriv(targetPacked, pname, params);
}
ANGLE_CAPTURE_GL(GetTexParameteriv, isCallValid, context, targetPacked, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLint GL_APIENTRY GL_GetUniformLocation(GLuint program, const GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetUniformLocation, "context = %d, program = %u, name = 0x%016" PRIxPTR "",
CID(context), program, (uintptr_t)name);
GLint returnValue;
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetUniformLocation(context, angle::EntryPoint::GLGetUniformLocation,
programPacked, name));
if (isCallValid)
{
returnValue = context->getUniformLocation(programPacked, name);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
}
ANGLE_CAPTURE_GL(GetUniformLocation, isCallValid, context, programPacked, name,
returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformLocation, GLint>();
}
return returnValue;
}
void GL_APIENTRY GL_GetUniformfv(GLuint program, GLint location, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetUniformfv,
"context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
program, location, (uintptr_t)params);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetUniformfv(context, angle::EntryPoint::GLGetUniformfv,
programPacked, locationPacked, params));
if (isCallValid)
{
context->getUniformfv(programPacked, locationPacked, params);
}
ANGLE_CAPTURE_GL(GetUniformfv, isCallValid, context, programPacked, locationPacked, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetUniformiv(GLuint program, GLint location, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetUniformiv,
"context = %d, program = %u, location = %d, params = 0x%016" PRIxPTR "", CID(context),
program, location, (uintptr_t)params);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetUniformiv(context, angle::EntryPoint::GLGetUniformiv,
programPacked, locationPacked, params));
if (isCallValid)
{
context->getUniformiv(programPacked, locationPacked, params);
}
ANGLE_CAPTURE_GL(GetUniformiv, isCallValid, context, programPacked, locationPacked, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetVertexAttribPointerv,
"context = %d, index = %u, pname = %s, pointer = 0x%016" PRIxPTR "", CID(context), index,
GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)pointer);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetVertexAttribPointerv(context, angle::EntryPoint::GLGetVertexAttribPointerv,
index, pname, pointer));
if (isCallValid)
{
context->getVertexAttribPointerv(index, pname, pointer);
}
ANGLE_CAPTURE_GL(GetVertexAttribPointerv, isCallValid, context, index, pname, pointer);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetVertexAttribfv,
"context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetVertexAttribfv(context, angle::EntryPoint::GLGetVertexAttribfv, index,
pname, params));
if (isCallValid)
{
context->getVertexAttribfv(index, pname, params);
}
ANGLE_CAPTURE_GL(GetVertexAttribfv, isCallValid, context, index, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLGetVertexAttribiv,
"context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index,
GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetVertexAttribiv(context, angle::EntryPoint::GLGetVertexAttribiv, index,
pname, params));
if (isCallValid)
{
context->getVertexAttribiv(index, pname, params);
}
ANGLE_CAPTURE_GL(GetVertexAttribiv, isCallValid, context, index, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Hint(GLenum target, GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLHint, "context = %d, target = %s, mode = %s", CID(context),
GLenumToString(GLESEnum::HintTarget, target), GLenumToString(GLESEnum::HintMode, mode));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateHint(context, angle::EntryPoint::GLHint, target, mode));
if (isCallValid)
{
context->hint(target, mode);
}
ANGLE_CAPTURE_GL(Hint, isCallValid, context, target, mode);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
GLboolean GL_APIENTRY GL_IsBuffer(GLuint buffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsBuffer, "context = %d, buffer = %u", CID(context), buffer);
GLboolean returnValue;
if (context)
{
BufferID bufferPacked = PackParam<BufferID>(buffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateIsBuffer(context, angle::EntryPoint::GLIsBuffer, bufferPacked));
if (isCallValid)
{
returnValue = context->isBuffer(bufferPacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsBuffer, GLboolean>();
}
ANGLE_CAPTURE_GL(IsBuffer, isCallValid, context, bufferPacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsBuffer, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsEnabled(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsEnabled, "context = %d, cap = %s", CID(context),
GLenumToString(GLESEnum::EnableCap, cap));
GLboolean returnValue;
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateIsEnabled(context, angle::EntryPoint::GLIsEnabled, cap));
if (isCallValid)
{
returnValue = context->isEnabled(cap);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabled, GLboolean>();
}
ANGLE_CAPTURE_GL(IsEnabled, isCallValid, context, cap, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabled, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsFramebuffer(GLuint framebuffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsFramebuffer, "context = %d, framebuffer = %u", CID(context), framebuffer);
GLboolean returnValue;
if (context)
{
FramebufferID framebufferPacked = PackParam<FramebufferID>(framebuffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateIsFramebuffer(context, angle::EntryPoint::GLIsFramebuffer, framebufferPacked));
if (isCallValid)
{
returnValue = context->isFramebuffer(framebufferPacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebuffer, GLboolean>();
}
ANGLE_CAPTURE_GL(IsFramebuffer, isCallValid, context, framebufferPacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebuffer, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsProgram(GLuint program)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsProgram, "context = %d, program = %u", CID(context), program);
GLboolean returnValue;
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateIsProgram(context, angle::EntryPoint::GLIsProgram, programPacked));
if (isCallValid)
{
returnValue = context->isProgram(programPacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
}
ANGLE_CAPTURE_GL(IsProgram, isCallValid, context, programPacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgram, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsRenderbuffer(GLuint renderbuffer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsRenderbuffer, "context = %d, renderbuffer = %u", CID(context), renderbuffer);
GLboolean returnValue;
if (context)
{
RenderbufferID renderbufferPacked = PackParam<RenderbufferID>(renderbuffer);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateIsRenderbuffer(context, angle::EntryPoint::GLIsRenderbuffer,
renderbufferPacked));
if (isCallValid)
{
returnValue = context->isRenderbuffer(renderbufferPacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbuffer, GLboolean>();
}
ANGLE_CAPTURE_GL(IsRenderbuffer, isCallValid, context, renderbufferPacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbuffer, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsShader(GLuint shader)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsShader, "context = %d, shader = %u", CID(context), shader);
GLboolean returnValue;
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateIsShader(context, angle::EntryPoint::GLIsShader, shaderPacked));
if (isCallValid)
{
returnValue = context->isShader(shaderPacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
}
ANGLE_CAPTURE_GL(IsShader, isCallValid, context, shaderPacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsShader, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY GL_IsTexture(GLuint texture)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLIsTexture, "context = %d, texture = %u", CID(context), texture);
GLboolean returnValue;
if (context)
{
TextureID texturePacked = PackParam<TextureID>(texture);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateIsTexture(context, angle::EntryPoint::GLIsTexture, texturePacked));
if (isCallValid)
{
returnValue = context->isTexture(texturePacked);
}
else
{
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTexture, GLboolean>();
}
ANGLE_CAPTURE_GL(IsTexture, isCallValid, context, texturePacked, returnValue);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTexture, GLboolean>();
}
return returnValue;
}
void GL_APIENTRY GL_LineWidth(GLfloat width)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLLineWidth, "context = %d, width = %f", CID(context), width);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateLineWidth(context, angle::EntryPoint::GLLineWidth, width));
if (isCallValid)
{
context->lineWidth(width);
}
ANGLE_CAPTURE_GL(LineWidth, isCallValid, context, width);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_LinkProgram(GLuint program)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLLinkProgram, "context = %d, program = %u", CID(context), program);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateLinkProgram(context, angle::EntryPoint::GLLinkProgram, programPacked));
if (isCallValid)
{
context->linkProgram(programPacked);
}
ANGLE_CAPTURE_GL(LinkProgram, isCallValid, context, programPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_PixelStorei(GLenum pname, GLint param)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLPixelStorei, "context = %d, pname = %s, param = %d", CID(context),
GLenumToString(GLESEnum::PixelStoreParameter, pname), param);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidatePixelStorei(context, angle::EntryPoint::GLPixelStorei, pname, param));
if (isCallValid)
{
context->pixelStorei(pname, param);
}
ANGLE_CAPTURE_GL(PixelStorei, isCallValid, context, pname, param);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_PolygonOffset(GLfloat factor, GLfloat units)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLPolygonOffset, "context = %d, factor = %f, units = %f", CID(context), factor,
units);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidatePolygonOffset(context, angle::EntryPoint::GLPolygonOffset, factor, units));
if (isCallValid)
{
context->polygonOffset(factor, units);
}
ANGLE_CAPTURE_GL(PolygonOffset, isCallValid, context, factor, units);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ReadPixels(GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
void *pixels)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLReadPixels,
"context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, pixels = "
"0x%016" PRIxPTR "",
CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format),
GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateReadPixels(context, angle::EntryPoint::GLReadPixels, x, y,
width, height, format, type, pixels));
if (isCallValid)
{
context->readPixels(x, y, width, height, format, type, pixels);
}
ANGLE_CAPTURE_GL(ReadPixels, isCallValid, context, x, y, width, height, format, type,
pixels);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ReleaseShaderCompiler()
{
Context *context = GetValidGlobalContext();
EVENT(context, GLReleaseShaderCompiler, "context = %d", CID(context));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateReleaseShaderCompiler(context, angle::EntryPoint::GLReleaseShaderCompiler));
if (isCallValid)
{
context->releaseShaderCompiler();
}
ANGLE_CAPTURE_GL(ReleaseShaderCompiler, isCallValid, context);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_RenderbufferStorage(GLenum target,
GLenum internalformat,
GLsizei width,
GLsizei height)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLRenderbufferStorage,
"context = %d, target = %s, internalformat = %s, width = %d, height = %d", CID(context),
GLenumToString(GLESEnum::RenderbufferTarget, target),
GLenumToString(GLESEnum::InternalFormat, internalformat), width, height);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateRenderbufferStorage(context, angle::EntryPoint::GLRenderbufferStorage, target,
internalformat, width, height));
if (isCallValid)
{
context->renderbufferStorage(target, internalformat, width, height);
}
ANGLE_CAPTURE_GL(RenderbufferStorage, isCallValid, context, target, internalformat, width,
height);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_SampleCoverage(GLfloat value, GLboolean invert)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLSampleCoverage, "context = %d, value = %f, invert = %s", CID(context), value,
GLbooleanToString(invert));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateSampleCoverage(context, angle::EntryPoint::GLSampleCoverage, value, invert));
if (isCallValid)
{
context->sampleCoverage(value, invert);
}
ANGLE_CAPTURE_GL(SampleCoverage, isCallValid, context, value, invert);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLScissor, "context = %d, x = %d, y = %d, width = %d, height = %d", CID(context),
x, y, width, height);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateScissor(context, angle::EntryPoint::GLScissor, x, y, width, height));
if (isCallValid)
{
context->scissor(x, y, width, height);
}
ANGLE_CAPTURE_GL(Scissor, isCallValid, context, x, y, width, height);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ShaderBinary(GLsizei count,
const GLuint *shaders,
GLenum binaryFormat,
const void *binary,
GLsizei length)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLShaderBinary,
"context = %d, count = %d, shaders = 0x%016" PRIxPTR
", binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d",
CID(context), count, (uintptr_t)shaders,
GLenumToString(GLESEnum::ShaderBinaryFormat, binaryFormat), (uintptr_t)binary, length);
if (context)
{
const ShaderProgramID *shadersPacked = PackParam<const ShaderProgramID *>(shaders);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateShaderBinary(context, angle::EntryPoint::GLShaderBinary, count,
shadersPacked, binaryFormat, binary, length));
if (isCallValid)
{
context->shaderBinary(count, shadersPacked, binaryFormat, binary, length);
}
ANGLE_CAPTURE_GL(ShaderBinary, isCallValid, context, count, shadersPacked, binaryFormat,
binary, length);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ShaderSource(GLuint shader,
GLsizei count,
const GLchar *const *string,
const GLint *length)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLShaderSource,
"context = %d, shader = %u, count = %d, string = 0x%016" PRIxPTR
", length = 0x%016" PRIxPTR "",
CID(context), shader, count, (uintptr_t)string, (uintptr_t)length);
if (context)
{
ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateShaderSource(context, angle::EntryPoint::GLShaderSource,
shaderPacked, count, string, length));
if (isCallValid)
{
context->shaderSource(shaderPacked, count, string, length);
}
ANGLE_CAPTURE_GL(ShaderSource, isCallValid, context, shaderPacked, count, string, length);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilFunc(GLenum func, GLint ref, GLuint mask)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilFunc, "context = %d, func = %s, ref = %d, mask = %u", CID(context),
GLenumToString(GLESEnum::StencilFunction, func), ref, mask);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateStencilFunc(context, angle::EntryPoint::GLStencilFunc, func, ref, mask));
if (isCallValid)
{
context->stencilFunc(func, ref, mask);
}
ANGLE_CAPTURE_GL(StencilFunc, isCallValid, context, func, ref, mask);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilFuncSeparate, "context = %d, face = %s, func = %s, ref = %d, mask = %u",
CID(context), GLenumToString(GLESEnum::TriangleFace, face),
GLenumToString(GLESEnum::StencilFunction, func), ref, mask);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateStencilFuncSeparate(context, angle::EntryPoint::GLStencilFuncSeparate, face,
func, ref, mask));
if (isCallValid)
{
context->stencilFuncSeparate(face, func, ref, mask);
}
ANGLE_CAPTURE_GL(StencilFuncSeparate, isCallValid, context, face, func, ref, mask);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilMask(GLuint mask)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilMask, "context = %d, mask = %u", CID(context), mask);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateStencilMask(context, angle::EntryPoint::GLStencilMask, mask));
if (isCallValid)
{
context->stencilMask(mask);
}
ANGLE_CAPTURE_GL(StencilMask, isCallValid, context, mask);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilMaskSeparate, "context = %d, face = %s, mask = %u", CID(context),
GLenumToString(GLESEnum::TriangleFace, face), mask);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateStencilMaskSeparate(
context, angle::EntryPoint::GLStencilMaskSeparate, face, mask));
if (isCallValid)
{
context->stencilMaskSeparate(face, mask);
}
ANGLE_CAPTURE_GL(StencilMaskSeparate, isCallValid, context, face, mask);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilOp, "context = %d, fail = %s, zfail = %s, zpass = %s", CID(context),
GLenumToString(GLESEnum::StencilOp, fail), GLenumToString(GLESEnum::StencilOp, zfail),
GLenumToString(GLESEnum::StencilOp, zpass));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateStencilOp(context, angle::EntryPoint::GLStencilOp, fail, zfail, zpass));
if (isCallValid)
{
context->stencilOp(fail, zfail, zpass);
}
ANGLE_CAPTURE_GL(StencilOp, isCallValid, context, fail, zfail, zpass);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_StencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLStencilOpSeparate,
"context = %d, face = %s, sfail = %s, dpfail = %s, dppass = %s", CID(context),
GLenumToString(GLESEnum::TriangleFace, face), GLenumToString(GLESEnum::StencilOp, sfail),
GLenumToString(GLESEnum::StencilOp, dpfail), GLenumToString(GLESEnum::StencilOp, dppass));
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateStencilOpSeparate(context, angle::EntryPoint::GLStencilOpSeparate, face, sfail,
dpfail, dppass));
if (isCallValid)
{
context->stencilOpSeparate(face, sfail, dpfail, dppass);
}
ANGLE_CAPTURE_GL(StencilOpSeparate, isCallValid, context, face, sfail, dpfail, dppass);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexImage2D(GLenum target,
GLint level,
GLint internalformat,
GLsizei width,
GLsizei height,
GLint border,
GLenum format,
GLenum type,
const void *pixels)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexImage2D,
"context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, "
"border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat,
width, height, border, GLenumToString(GLESEnum::PixelFormat, format),
GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateTexImage2D(context, angle::EntryPoint::GLTexImage2D, targetPacked, level,
internalformat, width, height, border, format, type, pixels));
if (isCallValid)
{
context->texImage2D(targetPacked, level, internalformat, width, height, border, format,
type, pixels);
}
ANGLE_CAPTURE_GL(TexImage2D, isCallValid, context, targetPacked, level, internalformat,
width, height, border, format, type, pixels);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexParameterf(GLenum target, GLenum pname, GLfloat param)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexParameterf, "context = %d, target = %s, pname = %s, param = %f",
CID(context), GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::TextureParameterName, pname), param);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateTexParameterf(context, angle::EntryPoint::GLTexParameterf,
targetPacked, pname, param));
if (isCallValid)
{
context->texParameterf(targetPacked, pname, param);
}
ANGLE_CAPTURE_GL(TexParameterf, isCallValid, context, targetPacked, pname, param);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexParameterfv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateTexParameterfv(context, angle::EntryPoint::GLTexParameterfv,
targetPacked, pname, params));
if (isCallValid)
{
context->texParameterfv(targetPacked, pname, params);
}
ANGLE_CAPTURE_GL(TexParameterfv, isCallValid, context, targetPacked, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexParameteri(GLenum target, GLenum pname, GLint param)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexParameteri, "context = %d, target = %s, pname = %s, param = %d",
CID(context), GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::TextureParameterName, pname), param);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateTexParameteri(context, angle::EntryPoint::GLTexParameteri,
targetPacked, pname, param));
if (isCallValid)
{
context->texParameteri(targetPacked, pname, param);
}
ANGLE_CAPTURE_GL(TexParameteri, isCallValid, context, targetPacked, pname, param);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexParameteriv(GLenum target, GLenum pname, const GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexParameteriv,
"context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLESEnum::TextureTarget, target),
GLenumToString(GLESEnum::TextureParameterName, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = PackParam<TextureType>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateTexParameteriv(context, angle::EntryPoint::GLTexParameteriv,
targetPacked, pname, params));
if (isCallValid)
{
context->texParameteriv(targetPacked, pname, params);
}
ANGLE_CAPTURE_GL(TexParameteriv, isCallValid, context, targetPacked, pname, params);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_TexSubImage2D(GLenum target,
GLint level,
GLint xoffset,
GLint yoffset,
GLsizei width,
GLsizei height,
GLenum format,
GLenum type,
const void *pixels)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLTexSubImage2D,
"context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = "
"%d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset,
width, height, GLenumToString(GLESEnum::PixelFormat, format),
GLenumToString(GLESEnum::PixelType, type), (uintptr_t)pixels);
if (context)
{
TextureTarget targetPacked = PackParam<TextureTarget>(target);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateTexSubImage2D(context, angle::EntryPoint::GLTexSubImage2D, targetPacked, level,
xoffset, yoffset, width, height, format, type, pixels));
if (isCallValid)
{
context->texSubImage2D(targetPacked, level, xoffset, yoffset, width, height, format,
type, pixels);
}
ANGLE_CAPTURE_GL(TexSubImage2D, isCallValid, context, targetPacked, level, xoffset, yoffset,
width, height, format, type, pixels);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform1f(GLint location, GLfloat v0)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform1f, "context = %d, location = %d, v0 = %f", CID(context), location, v0);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateUniform1f(context, angle::EntryPoint::GLUniform1f, locationPacked, v0));
if (isCallValid)
{
context->uniform1f(locationPacked, v0);
}
ANGLE_CAPTURE_GL(Uniform1f, isCallValid, context, locationPacked, v0);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform1fv(GLint location, GLsizei count, const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform1fv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform1fv(context, angle::EntryPoint::GLUniform1fv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform1fv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform1fv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform1i(GLint location, GLint v0)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform1i, "context = %d, location = %d, v0 = %d", CID(context), location, v0);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateUniform1i(context, angle::EntryPoint::GLUniform1i, locationPacked, v0));
if (isCallValid)
{
context->uniform1i(locationPacked, v0);
}
ANGLE_CAPTURE_GL(Uniform1i, isCallValid, context, locationPacked, v0);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform1iv(GLint location, GLsizei count, const GLint *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform1iv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform1iv(context, angle::EntryPoint::GLUniform1iv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform1iv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform1iv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform2f(GLint location, GLfloat v0, GLfloat v1)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform2f, "context = %d, location = %d, v0 = %f, v1 = %f", CID(context),
location, v0, v1);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateUniform2f(context, angle::EntryPoint::GLUniform2f, locationPacked, v0, v1));
if (isCallValid)
{
context->uniform2f(locationPacked, v0, v1);
}
ANGLE_CAPTURE_GL(Uniform2f, isCallValid, context, locationPacked, v0, v1);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform2fv(GLint location, GLsizei count, const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform2fv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform2fv(context, angle::EntryPoint::GLUniform2fv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform2fv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform2fv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform2i(GLint location, GLint v0, GLint v1)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform2i, "context = %d, location = %d, v0 = %d, v1 = %d", CID(context),
location, v0, v1);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateUniform2i(context, angle::EntryPoint::GLUniform2i, locationPacked, v0, v1));
if (isCallValid)
{
context->uniform2i(locationPacked, v0, v1);
}
ANGLE_CAPTURE_GL(Uniform2i, isCallValid, context, locationPacked, v0, v1);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform2iv(GLint location, GLsizei count, const GLint *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform2iv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform2iv(context, angle::EntryPoint::GLUniform2iv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform2iv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform2iv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform3f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f",
CID(context), location, v0, v1, v2);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform3f(context, angle::EntryPoint::GLUniform3f,
locationPacked, v0, v1, v2));
if (isCallValid)
{
context->uniform3f(locationPacked, v0, v1, v2);
}
ANGLE_CAPTURE_GL(Uniform3f, isCallValid, context, locationPacked, v0, v1, v2);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform3fv(GLint location, GLsizei count, const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform3fv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform3fv(context, angle::EntryPoint::GLUniform3fv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform3fv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform3fv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform3i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d",
CID(context), location, v0, v1, v2);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform3i(context, angle::EntryPoint::GLUniform3i,
locationPacked, v0, v1, v2));
if (isCallValid)
{
context->uniform3i(locationPacked, v0, v1, v2);
}
ANGLE_CAPTURE_GL(Uniform3i, isCallValid, context, locationPacked, v0, v1, v2);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform3iv(GLint location, GLsizei count, const GLint *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform3iv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform3iv(context, angle::EntryPoint::GLUniform3iv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform3iv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform3iv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform4f, "context = %d, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f",
CID(context), location, v0, v1, v2, v3);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform4f(context, angle::EntryPoint::GLUniform4f,
locationPacked, v0, v1, v2, v3));
if (isCallValid)
{
context->uniform4f(locationPacked, v0, v1, v2, v3);
}
ANGLE_CAPTURE_GL(Uniform4f, isCallValid, context, locationPacked, v0, v1, v2, v3);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform4fv(GLint location, GLsizei count, const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform4fv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform4fv(context, angle::EntryPoint::GLUniform4fv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform4fv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform4fv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform4i, "context = %d, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d",
CID(context), location, v0, v1, v2, v3);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform4i(context, angle::EntryPoint::GLUniform4i,
locationPacked, v0, v1, v2, v3));
if (isCallValid)
{
context->uniform4i(locationPacked, v0, v1, v2, v3);
}
ANGLE_CAPTURE_GL(Uniform4i, isCallValid, context, locationPacked, v0, v1, v2, v3);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Uniform4iv(GLint location, GLsizei count, const GLint *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniform4iv,
"context = %d, location = %d, count = %d, value = 0x%016" PRIxPTR "", CID(context),
location, count, (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniform4iv(context, angle::EntryPoint::GLUniform4iv,
locationPacked, count, value));
if (isCallValid)
{
context->uniform4iv(locationPacked, count, value);
}
ANGLE_CAPTURE_GL(Uniform4iv, isCallValid, context, locationPacked, count, value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_UniformMatrix2fv(GLint location,
GLsizei count,
GLboolean transpose,
const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniformMatrix2fv,
"context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix2fv(context, angle::EntryPoint::GLUniformMatrix2fv,
locationPacked, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix2fv(locationPacked, count, transpose, value);
}
ANGLE_CAPTURE_GL(UniformMatrix2fv, isCallValid, context, locationPacked, count, transpose,
value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_UniformMatrix3fv(GLint location,
GLsizei count,
GLboolean transpose,
const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniformMatrix3fv,
"context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix3fv(context, angle::EntryPoint::GLUniformMatrix3fv,
locationPacked, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix3fv(locationPacked, count, transpose, value);
}
ANGLE_CAPTURE_GL(UniformMatrix3fv, isCallValid, context, locationPacked, count, transpose,
value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_UniformMatrix4fv(GLint location,
GLsizei count,
GLboolean transpose,
const GLfloat *value)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUniformMatrix4fv,
"context = %d, location = %d, count = %d, transpose = %s, value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
UniformLocation locationPacked = PackParam<UniformLocation>(location);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix4fv(context, angle::EntryPoint::GLUniformMatrix4fv,
locationPacked, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix4fv(locationPacked, count, transpose, value);
}
ANGLE_CAPTURE_GL(UniformMatrix4fv, isCallValid, context, locationPacked, count, transpose,
value);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_UseProgram(GLuint program)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLUseProgram, "context = %d, program = %u", CID(context), program);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateUseProgram(context, angle::EntryPoint::GLUseProgram, programPacked));
if (isCallValid)
{
context->useProgram(programPacked);
}
ANGLE_CAPTURE_GL(UseProgram, isCallValid, context, programPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_ValidateProgram(GLuint program)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLValidateProgram, "context = %d, program = %u", CID(context), program);
if (context)
{
ShaderProgramID programPacked = PackParam<ShaderProgramID>(program);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateValidateProgram(context, angle::EntryPoint::GLValidateProgram, programPacked));
if (isCallValid)
{
context->validateProgram(programPacked);
}
ANGLE_CAPTURE_GL(ValidateProgram, isCallValid, context, programPacked);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib1f, "context = %d, index = %u, x = %f", CID(context), index, x);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib1f(context, angle::EntryPoint::GLVertexAttrib1f, index, x));
if (isCallValid)
{
context->vertexAttrib1f(index, x);
}
ANGLE_CAPTURE_GL(VertexAttrib1f, isCallValid, context, index, x);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib1fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
CID(context), index, (uintptr_t)v);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib1fv(context, angle::EntryPoint::GLVertexAttrib1fv, index, v));
if (isCallValid)
{
context->vertexAttrib1fv(index, v);
}
ANGLE_CAPTURE_GL(VertexAttrib1fv, isCallValid, context, index, v);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib2f, "context = %d, index = %u, x = %f, y = %f", CID(context),
index, x, y);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib2f(context, angle::EntryPoint::GLVertexAttrib2f, index, x, y));
if (isCallValid)
{
context->vertexAttrib2f(index, x, y);
}
ANGLE_CAPTURE_GL(VertexAttrib2f, isCallValid, context, index, x, y);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib2fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
CID(context), index, (uintptr_t)v);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib2fv(context, angle::EntryPoint::GLVertexAttrib2fv, index, v));
if (isCallValid)
{
context->vertexAttrib2fv(index, v);
}
ANGLE_CAPTURE_GL(VertexAttrib2fv, isCallValid, context, index, v);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib3f, "context = %d, index = %u, x = %f, y = %f, z = %f",
CID(context), index, x, y, z);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib3f(context, angle::EntryPoint::GLVertexAttrib3f, index, x, y, z));
if (isCallValid)
{
context->vertexAttrib3f(index, x, y, z);
}
ANGLE_CAPTURE_GL(VertexAttrib3f, isCallValid, context, index, x, y, z);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib3fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
CID(context), index, (uintptr_t)v);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib3fv(context, angle::EntryPoint::GLVertexAttrib3fv, index, v));
if (isCallValid)
{
context->vertexAttrib3fv(index, v);
}
ANGLE_CAPTURE_GL(VertexAttrib3fv, isCallValid, context, index, v);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib4f, "context = %d, index = %u, x = %f, y = %f, z = %f, w = %f",
CID(context), index, x, y, z, w);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid = (context->skipValidation() ||
ValidateVertexAttrib4f(context, angle::EntryPoint::GLVertexAttrib4f,
index, x, y, z, w));
if (isCallValid)
{
context->vertexAttrib4f(index, x, y, z, w);
}
ANGLE_CAPTURE_GL(VertexAttrib4f, isCallValid, context, index, x, y, z, w);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttrib4fv, "context = %d, index = %u, v = 0x%016" PRIxPTR "",
CID(context), index, (uintptr_t)v);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttrib4fv(context, angle::EntryPoint::GLVertexAttrib4fv, index, v));
if (isCallValid)
{
context->vertexAttrib4fv(index, v);
}
ANGLE_CAPTURE_GL(VertexAttrib4fv, isCallValid, context, index, v);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_VertexAttribPointer(GLuint index,
GLint size,
GLenum type,
GLboolean normalized,
GLsizei stride,
const void *pointer)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLVertexAttribPointer,
"context = %d, index = %u, size = %d, type = %s, normalized = %s, stride = %d, pointer = "
"0x%016" PRIxPTR "",
CID(context), index, size, GLenumToString(GLESEnum::VertexAttribPointerType, type),
GLbooleanToString(normalized), stride, (uintptr_t)pointer);
if (context)
{
VertexAttribType typePacked = PackParam<VertexAttribType>(type);
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateVertexAttribPointer(context, angle::EntryPoint::GLVertexAttribPointer, index,
size, typePacked, normalized, stride, pointer));
if (isCallValid)
{
context->vertexAttribPointer(index, size, typePacked, normalized, stride, pointer);
}
ANGLE_CAPTURE_GL(VertexAttribPointer, isCallValid, context, index, size, typePacked,
normalized, stride, pointer);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
void GL_APIENTRY GL_Viewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
Context *context = GetValidGlobalContext();
EVENT(context, GLViewport, "context = %d, x = %d, y = %d, width = %d, height = %d",
CID(context), x, y, width, height);
if (context)
{
SCOPED_SHARE_CONTEXT_LOCK(context);
bool isCallValid =
(context->skipValidation() ||
ValidateViewport(context, angle::EntryPoint::GLViewport, x, y, width, height));
if (isCallValid)
{
context->viewport(x, y, width, height);
}
ANGLE_CAPTURE_GL(Viewport, isCallValid, context, x, y, width, height);
}
else
{
GenerateContextLostErrorOnCurrentGlobalContext();
}
}
} // extern "C"