blob: 5d62207336111588e97edea923ca7aa4f10ea8b1 [file] [log] [blame]
// GENERATED FILE - DO NOT EDIT.
// Generated by generate_entry_points.py using data from gl.xml.
//
// Copyright 2019 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// entry_points_gl_1_0_autogen.cpp:
// Defines the GL 1.0 entry points.
#include "libGL/entry_points_gl_1_0_autogen.h"
#include "libANGLE/Context.h"
#include "libANGLE/Context.inl.h"
#include "libANGLE/entry_points_utils.h"
#include "libANGLE/gl_enum_utils.h"
#include "libANGLE/validationEGL.h"
#include "libANGLE/validationES.h"
#include "libANGLE/validationES1.h"
#include "libANGLE/validationES2.h"
#include "libANGLE/validationES3.h"
#include "libANGLE/validationES31.h"
#include "libANGLE/validationES32.h"
#include "libANGLE/validationESEXT.h"
#include "libANGLE/validationGL1_autogen.h"
#include "libGLESv2/global_state.h"
namespace gl
{
void GL_APIENTRY Accum(GLenum op, GLfloat value)
{
Context *context = GetValidGlobalContext();
EVENT("glAccum", "context = %d, GLenum op = %s, GLfloat value = %f", CID(context),
GLenumToString(GLenumGroup::AccumOp, op), value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateAccum(context, op, value));
if (isCallValid)
{
context->accum(op, value);
}
ANGLE_CAPTURE(Accum, isCallValid, context, op, value);
}
}
void GL_APIENTRY AlphaFunc(GLenum func, GLfloat ref)
{
Context *context = GetValidGlobalContext();
EVENT("glAlphaFunc", "context = %d, GLenum func = %s, GLfloat ref = %f", CID(context),
GLenumToString(GLenumGroup::AlphaFunction, func), ref);
if (context)
{
AlphaTestFunc funcPacked = FromGL<AlphaTestFunc>(func);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateAlphaFunc(context, funcPacked, ref));
if (isCallValid)
{
context->alphaFunc(funcPacked, ref);
}
ANGLE_CAPTURE(AlphaFunc, isCallValid, context, funcPacked, ref);
}
}
void GL_APIENTRY Begin(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glBegin", "context = %d, GLenum mode = %s", CID(context),
GLenumToString(GLenumGroup::PrimitiveType, mode));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateBegin(context, mode));
if (isCallValid)
{
context->begin(mode);
}
ANGLE_CAPTURE(Begin, isCallValid, context, mode);
}
}
void GL_APIENTRY Bitmap(GLsizei width,
GLsizei height,
GLfloat xorig,
GLfloat yorig,
GLfloat xmove,
GLfloat ymove,
const GLubyte *bitmap)
{
Context *context = GetValidGlobalContext();
EVENT(
"glBitmap",
"context = %d, GLsizei width = %d, GLsizei height = %d, GLfloat xorig = %f, GLfloat yorig "
"= %f, GLfloat xmove = %f, GLfloat ymove = %f, const GLubyte *bitmap = 0x%016" PRIxPTR "",
CID(context), width, height, xorig, yorig, xmove, ymove, (uintptr_t)bitmap);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBitmap(context, width, height, xorig, yorig, xmove, ymove, bitmap));
if (isCallValid)
{
context->bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
}
ANGLE_CAPTURE(Bitmap, isCallValid, context, width, height, xorig, yorig, xmove, ymove,
bitmap);
}
}
void GL_APIENTRY BlendFunc(GLenum sfactor, GLenum dfactor)
{
Context *context = GetValidGlobalContext();
EVENT("glBlendFunc", "context = %d, GLenum sfactor = %s, GLenum dfactor = %s", CID(context),
GLenumToString(GLenumGroup::BlendingFactor, sfactor),
GLenumToString(GLenumGroup::BlendingFactor, dfactor));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateBlendFunc(context, sfactor, dfactor));
if (isCallValid)
{
context->blendFunc(sfactor, dfactor);
}
ANGLE_CAPTURE(BlendFunc, isCallValid, context, sfactor, dfactor);
}
}
void GL_APIENTRY CallList(GLuint list)
{
Context *context = GetValidGlobalContext();
EVENT("glCallList", "context = %d, GLuint list = %u", CID(context), list);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateCallList(context, list));
if (isCallValid)
{
context->callList(list);
}
ANGLE_CAPTURE(CallList, isCallValid, context, list);
}
}
void GL_APIENTRY CallLists(GLsizei n, GLenum type, const void *lists)
{
Context *context = GetValidGlobalContext();
EVENT("glCallLists",
"context = %d, GLsizei n = %d, GLenum type = %s, const void *lists = 0x%016" PRIxPTR "",
CID(context), n, GLenumToString(GLenumGroup::ListNameType, type), (uintptr_t)lists);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateCallLists(context, n, type, lists));
if (isCallValid)
{
context->callLists(n, type, lists);
}
ANGLE_CAPTURE(CallLists, isCallValid, context, n, type, lists);
}
}
void GL_APIENTRY Clear(GLbitfield mask)
{
Context *context = GetValidGlobalContext();
EVENT("glClear", "context = %d, GLbitfield mask = %s", CID(context),
GLbitfieldToString(GLenumGroup::ClearBufferMask, mask).c_str());
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateClear(context, mask));
if (isCallValid)
{
context->clear(mask);
}
ANGLE_CAPTURE(Clear, isCallValid, context, mask);
}
}
void GL_APIENTRY ClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
Context *context = GetValidGlobalContext();
EVENT(
"glClearAccum",
"context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateClearAccum(context, red, green, blue, alpha));
if (isCallValid)
{
context->clearAccum(red, green, blue, alpha);
}
ANGLE_CAPTURE(ClearAccum, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY ClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
Context *context = GetValidGlobalContext();
EVENT(
"glClearColor",
"context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateClearColor(context, red, green, blue, alpha));
if (isCallValid)
{
context->clearColor(red, green, blue, alpha);
}
ANGLE_CAPTURE(ClearColor, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY ClearDepth(GLdouble depth)
{
Context *context = GetValidGlobalContext();
EVENT("glClearDepth", "context = %d, GLdouble depth = %f", CID(context), depth);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateClearDepth(context, depth));
if (isCallValid)
{
context->clearDepth(depth);
}
ANGLE_CAPTURE(ClearDepth, isCallValid, context, depth);
}
}
void GL_APIENTRY ClearIndex(GLfloat c)
{
Context *context = GetValidGlobalContext();
EVENT("glClearIndex", "context = %d, GLfloat c = %f", CID(context), c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateClearIndex(context, c));
if (isCallValid)
{
context->clearIndex(c);
}
ANGLE_CAPTURE(ClearIndex, isCallValid, context, c);
}
}
void GL_APIENTRY ClearStencil(GLint s)
{
Context *context = GetValidGlobalContext();
EVENT("glClearStencil", "context = %d, GLint s = %d", CID(context), s);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateClearStencil(context, s));
if (isCallValid)
{
context->clearStencil(s);
}
ANGLE_CAPTURE(ClearStencil, isCallValid, context, s);
}
}
void GL_APIENTRY ClipPlane(GLenum plane, const GLdouble *equation)
{
Context *context = GetValidGlobalContext();
EVENT("glClipPlane",
"context = %d, GLenum plane = %s, const GLdouble *equation = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateClipPlane(context, plane, equation));
if (isCallValid)
{
context->clipPlane(plane, equation);
}
ANGLE_CAPTURE(ClipPlane, isCallValid, context, plane, equation);
}
}
void GL_APIENTRY Color3b(GLbyte red, GLbyte green, GLbyte blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3b", "context = %d, GLbyte red = %d, GLbyte green = %d, GLbyte blue = %d",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3b(context, red, green, blue));
if (isCallValid)
{
context->color3b(red, green, blue);
}
ANGLE_CAPTURE(Color3b, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3bv(const GLbyte *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3bv", "context = %d, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3bv(context, v));
if (isCallValid)
{
context->color3bv(v);
}
ANGLE_CAPTURE(Color3bv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3d(GLdouble red, GLdouble green, GLdouble blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3d", "context = %d, GLdouble red = %f, GLdouble green = %f, GLdouble blue = %f",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3d(context, red, green, blue));
if (isCallValid)
{
context->color3d(red, green, blue);
}
ANGLE_CAPTURE(Color3d, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3dv(const GLdouble *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3dv", "context = %d, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3dv(context, v));
if (isCallValid)
{
context->color3dv(v);
}
ANGLE_CAPTURE(Color3dv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3f(GLfloat red, GLfloat green, GLfloat blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3f", "context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3f(context, red, green, blue));
if (isCallValid)
{
context->color3f(red, green, blue);
}
ANGLE_CAPTURE(Color3f, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3fv(const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3fv", "context = %d, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3fv(context, v));
if (isCallValid)
{
context->color3fv(v);
}
ANGLE_CAPTURE(Color3fv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3i(GLint red, GLint green, GLint blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3i", "context = %d, GLint red = %d, GLint green = %d, GLint blue = %d",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3i(context, red, green, blue));
if (isCallValid)
{
context->color3i(red, green, blue);
}
ANGLE_CAPTURE(Color3i, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3iv(const GLint *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3iv", "context = %d, const GLint *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3iv(context, v));
if (isCallValid)
{
context->color3iv(v);
}
ANGLE_CAPTURE(Color3iv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3s(GLshort red, GLshort green, GLshort blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3s", "context = %d, GLshort red = %d, GLshort green = %d, GLshort blue = %d",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3s(context, red, green, blue));
if (isCallValid)
{
context->color3s(red, green, blue);
}
ANGLE_CAPTURE(Color3s, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3sv(const GLshort *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3sv", "context = %d, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3sv(context, v));
if (isCallValid)
{
context->color3sv(v);
}
ANGLE_CAPTURE(Color3sv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3ub(GLubyte red, GLubyte green, GLubyte blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3ub", "context = %d, GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3ub(context, red, green, blue));
if (isCallValid)
{
context->color3ub(red, green, blue);
}
ANGLE_CAPTURE(Color3ub, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3ubv(const GLubyte *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3ubv", "context = %d, const GLubyte *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3ubv(context, v));
if (isCallValid)
{
context->color3ubv(v);
}
ANGLE_CAPTURE(Color3ubv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3ui(GLuint red, GLuint green, GLuint blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3ui", "context = %d, GLuint red = %u, GLuint green = %u, GLuint blue = %u",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3ui(context, red, green, blue));
if (isCallValid)
{
context->color3ui(red, green, blue);
}
ANGLE_CAPTURE(Color3ui, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3uiv(const GLuint *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3uiv", "context = %d, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3uiv(context, v));
if (isCallValid)
{
context->color3uiv(v);
}
ANGLE_CAPTURE(Color3uiv, isCallValid, context, v);
}
}
void GL_APIENTRY Color3us(GLushort red, GLushort green, GLushort blue)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3us", "context = %d, GLushort red = %u, GLushort green = %u, GLushort blue = %u",
CID(context), red, green, blue);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor3us(context, red, green, blue));
if (isCallValid)
{
context->color3us(red, green, blue);
}
ANGLE_CAPTURE(Color3us, isCallValid, context, red, green, blue);
}
}
void GL_APIENTRY Color3usv(const GLushort *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor3usv", "context = %d, const GLushort *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor3usv(context, v));
if (isCallValid)
{
context->color3usv(v);
}
ANGLE_CAPTURE(Color3usv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4b",
"context = %d, GLbyte red = %d, GLbyte green = %d, GLbyte blue = %d, GLbyte alpha = %d",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4b(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4b(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4b, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4bv(const GLbyte *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4bv", "context = %d, const GLbyte *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4bv(context, v));
if (isCallValid)
{
context->color4bv(v);
}
ANGLE_CAPTURE(Color4bv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4d",
"context = %d, GLdouble red = %f, GLdouble green = %f, GLdouble blue = %f, GLdouble "
"alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4d(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4d(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4d, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4dv(const GLdouble *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4dv", "context = %d, const GLdouble *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4dv(context, v));
if (isCallValid)
{
context->color4dv(v);
}
ANGLE_CAPTURE(Color4dv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
Context *context = GetValidGlobalContext();
EVENT(
"glColor4f",
"context = %d, GLfloat red = %f, GLfloat green = %f, GLfloat blue = %f, GLfloat alpha = %f",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4f(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4f(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4f, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4fv(const GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4fv", "context = %d, const GLfloat *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4fv(context, v));
if (isCallValid)
{
context->color4fv(v);
}
ANGLE_CAPTURE(Color4fv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4i(GLint red, GLint green, GLint blue, GLint alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4i",
"context = %d, GLint red = %d, GLint green = %d, GLint blue = %d, GLint alpha = %d",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4i(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4i(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4i, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4iv(const GLint *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4iv", "context = %d, const GLint *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4iv(context, v));
if (isCallValid)
{
context->color4iv(v);
}
ANGLE_CAPTURE(Color4iv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
Context *context = GetValidGlobalContext();
EVENT(
"glColor4s",
"context = %d, GLshort red = %d, GLshort green = %d, GLshort blue = %d, GLshort alpha = %d",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4s(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4s(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4s, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4sv(const GLshort *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4sv", "context = %d, const GLshort *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4sv(context, v));
if (isCallValid)
{
context->color4sv(v);
}
ANGLE_CAPTURE(Color4sv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
Context *context = GetValidGlobalContext();
EVENT(
"glColor4ub",
"context = %d, GLubyte red = %d, GLubyte green = %d, GLubyte blue = %d, GLubyte alpha = %d",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4ub(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4ub(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4ub, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4ubv(const GLubyte *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4ubv", "context = %d, const GLubyte *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4ubv(context, v));
if (isCallValid)
{
context->color4ubv(v);
}
ANGLE_CAPTURE(Color4ubv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4ui",
"context = %d, GLuint red = %u, GLuint green = %u, GLuint blue = %u, GLuint alpha = %u",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4ui(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4ui(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4ui, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4uiv(const GLuint *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4uiv", "context = %d, const GLuint *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4uiv(context, v));
if (isCallValid)
{
context->color4uiv(v);
}
ANGLE_CAPTURE(Color4uiv, isCallValid, context, v);
}
}
void GL_APIENTRY Color4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4us",
"context = %d, GLushort red = %u, GLushort green = %u, GLushort blue = %u, GLushort "
"alpha = %u",
CID(context), red, green, blue, alpha);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColor4us(context, red, green, blue, alpha));
if (isCallValid)
{
context->color4us(red, green, blue, alpha);
}
ANGLE_CAPTURE(Color4us, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY Color4usv(const GLushort *v)
{
Context *context = GetValidGlobalContext();
EVENT("glColor4usv", "context = %d, const GLushort *v = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateColor4usv(context, v));
if (isCallValid)
{
context->color4usv(v);
}
ANGLE_CAPTURE(Color4usv, isCallValid, context, v);
}
}
void GL_APIENTRY ColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
Context *context = GetValidGlobalContext();
EVENT("glColorMask",
"context = %d, GLboolean red = %s, GLboolean green = %s, GLboolean blue = %s, GLboolean "
"alpha = %s",
CID(context), GLbooleanToString(red), GLbooleanToString(green), GLbooleanToString(blue),
GLbooleanToString(alpha));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColorMask(context, red, green, blue, alpha));
if (isCallValid)
{
context->colorMask(red, green, blue, alpha);
}
ANGLE_CAPTURE(ColorMask, isCallValid, context, red, green, blue, alpha);
}
}
void GL_APIENTRY ColorMaterial(GLenum face, GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glColorMaterial", "context = %d, GLenum face = %s, GLenum mode = %s", CID(context),
GLenumToString(GLenumGroup::MaterialFace, face),
GLenumToString(GLenumGroup::ColorMaterialParameter, mode));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateColorMaterial(context, face, mode));
if (isCallValid)
{
context->colorMaterial(face, mode);
}
ANGLE_CAPTURE(ColorMaterial, isCallValid, context, face, mode);
}
}
void GL_APIENTRY CopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
Context *context = GetValidGlobalContext();
EVENT("glCopyPixels",
"context = %d, GLint x = %d, GLint y = %d, GLsizei width = %d, GLsizei height = %d, "
"GLenum type = %s",
CID(context), x, y, width, height, GLenumToString(GLenumGroup::PixelCopyType, type));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateCopyPixels(context, x, y, width, height, type));
if (isCallValid)
{
context->copyPixels(x, y, width, height, type);
}
ANGLE_CAPTURE(CopyPixels, isCallValid, context, x, y, width, height, type);
}
}
void GL_APIENTRY CullFace(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glCullFace", "context = %d, GLenum mode = %s", CID(context),
GLenumToString(GLenumGroup::CullFaceMode, mode));
if (context)
{
CullFaceMode modePacked = FromGL<CullFaceMode>(mode);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateCullFace(context, modePacked));
if (isCallValid)
{
context->cullFace(modePacked);
}
ANGLE_CAPTURE(CullFace, isCallValid, context, modePacked);
}
}
void GL_APIENTRY DeleteLists(GLuint list, GLsizei range)
{
Context *context = GetValidGlobalContext();
EVENT("glDeleteLists", "context = %d, GLuint list = %u, GLsizei range = %d", CID(context), list,
range);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDeleteLists(context, list, range));
if (isCallValid)
{
context->deleteLists(list, range);
}
ANGLE_CAPTURE(DeleteLists, isCallValid, context, list, range);
}
}
void GL_APIENTRY DepthFunc(GLenum func)
{
Context *context = GetValidGlobalContext();
EVENT("glDepthFunc", "context = %d, GLenum func = %s", CID(context),
GLenumToString(GLenumGroup::DepthFunction, func));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDepthFunc(context, func));
if (isCallValid)
{
context->depthFunc(func);
}
ANGLE_CAPTURE(DepthFunc, isCallValid, context, func);
}
}
void GL_APIENTRY DepthMask(GLboolean flag)
{
Context *context = GetValidGlobalContext();
EVENT("glDepthMask", "context = %d, GLboolean flag = %s", CID(context),
GLbooleanToString(flag));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDepthMask(context, flag));
if (isCallValid)
{
context->depthMask(flag);
}
ANGLE_CAPTURE(DepthMask, isCallValid, context, flag);
}
}
void GL_APIENTRY DepthRange(GLdouble n, GLdouble f)
{
Context *context = GetValidGlobalContext();
EVENT("glDepthRange", "context = %d, GLdouble n = %f, GLdouble f = %f", CID(context), n, f);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDepthRange(context, n, f));
if (isCallValid)
{
context->depthRange(n, f);
}
ANGLE_CAPTURE(DepthRange, isCallValid, context, n, f);
}
}
void GL_APIENTRY Disable(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT("glDisable", "context = %d, GLenum cap = %s", CID(context),
GLenumToString(GLenumGroup::EnableCap, cap));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDisable(context, cap));
if (isCallValid)
{
context->disable(cap);
}
ANGLE_CAPTURE(Disable, isCallValid, context, cap);
}
}
void GL_APIENTRY DrawBuffer(GLenum buf)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawBuffer", "context = %d, GLenum buf = %s", CID(context),
GLenumToString(GLenumGroup::DrawBufferMode, buf));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateDrawBuffer(context, buf));
if (isCallValid)
{
context->drawBuffer(buf);
}
ANGLE_CAPTURE(DrawBuffer, isCallValid, context, buf);
}
}
void GL_APIENTRY
DrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawPixels",
"context = %d, GLsizei width = %d, GLsizei height = %d, GLenum format = %s, GLenum type "
"= %s, const void *pixels = 0x%016" PRIxPTR "",
CID(context), width, height, GLenumToString(GLenumGroup::PixelFormat, format),
GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateDrawPixels(context, width, height, format, type, pixels));
if (isCallValid)
{
context->drawPixels(width, height, format, type, pixels);
}
ANGLE_CAPTURE(DrawPixels, isCallValid, context, width, height, format, type, pixels);
}
}
void GL_APIENTRY EdgeFlag(GLboolean flag)
{
Context *context = GetValidGlobalContext();
EVENT("glEdgeFlag", "context = %d, GLboolean flag = %s", CID(context), GLbooleanToString(flag));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEdgeFlag(context, flag));
if (isCallValid)
{
context->edgeFlag(flag);
}
ANGLE_CAPTURE(EdgeFlag, isCallValid, context, flag);
}
}
void GL_APIENTRY EdgeFlagv(const GLboolean *flag)
{
Context *context = GetValidGlobalContext();
EVENT("glEdgeFlagv", "context = %d, const GLboolean *flag = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)flag);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEdgeFlagv(context, flag));
if (isCallValid)
{
context->edgeFlagv(flag);
}
ANGLE_CAPTURE(EdgeFlagv, isCallValid, context, flag);
}
}
void GL_APIENTRY Enable(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT("glEnable", "context = %d, GLenum cap = %s", CID(context),
GLenumToString(GLenumGroup::EnableCap, cap));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEnable(context, cap));
if (isCallValid)
{
context->enable(cap);
}
ANGLE_CAPTURE(Enable, isCallValid, context, cap);
}
}
void GL_APIENTRY End()
{
Context *context = GetValidGlobalContext();
EVENT("glEnd", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEnd(context));
if (isCallValid)
{
context->end();
}
ANGLE_CAPTURE(End, isCallValid, context);
}
}
void GL_APIENTRY EndList()
{
Context *context = GetValidGlobalContext();
EVENT("glEndList", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEndList(context));
if (isCallValid)
{
context->endList();
}
ANGLE_CAPTURE(EndList, isCallValid, context);
}
}
void GL_APIENTRY EvalCoord1d(GLdouble u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord1d", "context = %d, GLdouble u = %f", CID(context), u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord1d(context, u));
if (isCallValid)
{
context->evalCoord1d(u);
}
ANGLE_CAPTURE(EvalCoord1d, isCallValid, context, u);
}
}
void GL_APIENTRY EvalCoord1dv(const GLdouble *u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord1dv", "context = %d, const GLdouble *u = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord1dv(context, u));
if (isCallValid)
{
context->evalCoord1dv(u);
}
ANGLE_CAPTURE(EvalCoord1dv, isCallValid, context, u);
}
}
void GL_APIENTRY EvalCoord1f(GLfloat u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord1f", "context = %d, GLfloat u = %f", CID(context), u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord1f(context, u));
if (isCallValid)
{
context->evalCoord1f(u);
}
ANGLE_CAPTURE(EvalCoord1f, isCallValid, context, u);
}
}
void GL_APIENTRY EvalCoord1fv(const GLfloat *u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord1fv", "context = %d, const GLfloat *u = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord1fv(context, u));
if (isCallValid)
{
context->evalCoord1fv(u);
}
ANGLE_CAPTURE(EvalCoord1fv, isCallValid, context, u);
}
}
void GL_APIENTRY EvalCoord2d(GLdouble u, GLdouble v)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord2d", "context = %d, GLdouble u = %f, GLdouble v = %f", CID(context), u, v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord2d(context, u, v));
if (isCallValid)
{
context->evalCoord2d(u, v);
}
ANGLE_CAPTURE(EvalCoord2d, isCallValid, context, u, v);
}
}
void GL_APIENTRY EvalCoord2dv(const GLdouble *u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord2dv", "context = %d, const GLdouble *u = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord2dv(context, u));
if (isCallValid)
{
context->evalCoord2dv(u);
}
ANGLE_CAPTURE(EvalCoord2dv, isCallValid, context, u);
}
}
void GL_APIENTRY EvalCoord2f(GLfloat u, GLfloat v)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord2f", "context = %d, GLfloat u = %f, GLfloat v = %f", CID(context), u, v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord2f(context, u, v));
if (isCallValid)
{
context->evalCoord2f(u, v);
}
ANGLE_CAPTURE(EvalCoord2f, isCallValid, context, u, v);
}
}
void GL_APIENTRY EvalCoord2fv(const GLfloat *u)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalCoord2fv", "context = %d, const GLfloat *u = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)u);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalCoord2fv(context, u));
if (isCallValid)
{
context->evalCoord2fv(u);
}
ANGLE_CAPTURE(EvalCoord2fv, isCallValid, context, u);
}
}
void GL_APIENTRY EvalMesh1(GLenum mode, GLint i1, GLint i2)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalMesh1", "context = %d, GLenum mode = %s, GLint i1 = %d, GLint i2 = %d",
CID(context), GLenumToString(GLenumGroup::MeshMode1, mode), i1, i2);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalMesh1(context, mode, i1, i2));
if (isCallValid)
{
context->evalMesh1(mode, i1, i2);
}
ANGLE_CAPTURE(EvalMesh1, isCallValid, context, mode, i1, i2);
}
}
void GL_APIENTRY EvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalMesh2",
"context = %d, GLenum mode = %s, GLint i1 = %d, GLint i2 = %d, GLint j1 = %d, GLint j2 = "
"%d",
CID(context), GLenumToString(GLenumGroup::MeshMode2, mode), i1, i2, j1, j2);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateEvalMesh2(context, mode, i1, i2, j1, j2));
if (isCallValid)
{
context->evalMesh2(mode, i1, i2, j1, j2);
}
ANGLE_CAPTURE(EvalMesh2, isCallValid, context, mode, i1, i2, j1, j2);
}
}
void GL_APIENTRY EvalPoint1(GLint i)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalPoint1", "context = %d, GLint i = %d", CID(context), i);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalPoint1(context, i));
if (isCallValid)
{
context->evalPoint1(i);
}
ANGLE_CAPTURE(EvalPoint1, isCallValid, context, i);
}
}
void GL_APIENTRY EvalPoint2(GLint i, GLint j)
{
Context *context = GetValidGlobalContext();
EVENT("glEvalPoint2", "context = %d, GLint i = %d, GLint j = %d", CID(context), i, j);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateEvalPoint2(context, i, j));
if (isCallValid)
{
context->evalPoint2(i, j);
}
ANGLE_CAPTURE(EvalPoint2, isCallValid, context, i, j);
}
}
void GL_APIENTRY FeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
Context *context = GetValidGlobalContext();
EVENT("glFeedbackBuffer",
"context = %d, GLsizei size = %d, GLenum type = %s, GLfloat *buffer = 0x%016" PRIxPTR "",
CID(context), size, GLenumToString(GLenumGroup::FeedbackType, type), (uintptr_t)buffer);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateFeedbackBuffer(context, size, type, buffer));
if (isCallValid)
{
context->feedbackBuffer(size, type, buffer);
}
ANGLE_CAPTURE(FeedbackBuffer, isCallValid, context, size, type, buffer);
}
}
void GL_APIENTRY Finish()
{
Context *context = GetValidGlobalContext();
EVENT("glFinish", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFinish(context));
if (isCallValid)
{
context->finish();
}
ANGLE_CAPTURE(Finish, isCallValid, context);
}
}
void GL_APIENTRY Flush()
{
Context *context = GetValidGlobalContext();
EVENT("glFlush", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFlush(context));
if (isCallValid)
{
context->flush();
}
ANGLE_CAPTURE(Flush, isCallValid, context);
}
}
void GL_APIENTRY Fogf(GLenum pname, GLfloat param)
{
Context *context = GetValidGlobalContext();
EVENT("glFogf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
GLenumToString(GLenumGroup::FogParameter, pname), param);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFogf(context, pname, param));
if (isCallValid)
{
context->fogf(pname, param);
}
ANGLE_CAPTURE(Fogf, isCallValid, context, pname, param);
}
}
void GL_APIENTRY Fogfv(GLenum pname, const GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glFogfv", "context = %d, GLenum pname = %s, const GLfloat *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFogfv(context, pname, params));
if (isCallValid)
{
context->fogfv(pname, params);
}
ANGLE_CAPTURE(Fogfv, isCallValid, context, pname, params);
}
}
void GL_APIENTRY Fogi(GLenum pname, GLint param)
{
Context *context = GetValidGlobalContext();
EVENT("glFogi", "context = %d, GLenum pname = %s, GLint param = %d", CID(context),
GLenumToString(GLenumGroup::FogParameter, pname), param);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFogi(context, pname, param));
if (isCallValid)
{
context->fogi(pname, param);
}
ANGLE_CAPTURE(Fogi, isCallValid, context, pname, param);
}
}
void GL_APIENTRY Fogiv(GLenum pname, const GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glFogiv", "context = %d, GLenum pname = %s, const GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::FogParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFogiv(context, pname, params));
if (isCallValid)
{
context->fogiv(pname, params);
}
ANGLE_CAPTURE(Fogiv, isCallValid, context, pname, params);
}
}
void GL_APIENTRY FrontFace(GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glFrontFace", "context = %d, GLenum mode = %s", CID(context),
GLenumToString(GLenumGroup::FrontFaceDirection, mode));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateFrontFace(context, mode));
if (isCallValid)
{
context->frontFace(mode);
}
ANGLE_CAPTURE(FrontFace, isCallValid, context, mode);
}
}
void GL_APIENTRY
Frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
Context *context = GetValidGlobalContext();
EVENT("glFrustum",
"context = %d, GLdouble left = %f, GLdouble right = %f, GLdouble bottom = %f, GLdouble "
"top = %f, GLdouble zNear = %f, GLdouble zFar = %f",
CID(context), left, right, bottom, top, zNear, zFar);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateFrustum(context, left, right, bottom, top, zNear, zFar));
if (isCallValid)
{
context->frustum(left, right, bottom, top, zNear, zFar);
}
ANGLE_CAPTURE(Frustum, isCallValid, context, left, right, bottom, top, zNear, zFar);
}
}
GLuint GL_APIENTRY GenLists(GLsizei range)
{
Context *context = GetValidGlobalContext();
EVENT("glGenLists", "context = %d, GLsizei range = %d", CID(context), range);
GLuint returnValue;
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGenLists(context, range));
if (isCallValid)
{
returnValue = context->genLists(range);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GenLists, GLuint>();
}
ANGLE_CAPTURE(GenLists, isCallValid, context, range, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GenLists, GLuint>();
}
return returnValue;
}
void GL_APIENTRY GetBooleanv(GLenum pname, GLboolean *data)
{
Context *context = GetValidGlobalContext();
EVENT("glGetBooleanv", "context = %d, GLenum pname = %s, GLboolean *data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetBooleanv(context, pname, data));
if (isCallValid)
{
context->getBooleanv(pname, data);
}
ANGLE_CAPTURE(GetBooleanv, isCallValid, context, pname, data);
}
}
void GL_APIENTRY GetClipPlane(GLenum plane, GLdouble *equation)
{
Context *context = GetValidGlobalContext();
EVENT("glGetClipPlane",
"context = %d, GLenum plane = %s, GLdouble *equation = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLenumGroup::ClipPlaneName, plane), (uintptr_t)equation);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetClipPlane(context, plane, equation));
if (isCallValid)
{
context->getClipPlane(plane, equation);
}
ANGLE_CAPTURE(GetClipPlane, isCallValid, context, plane, equation);
}
}
void GL_APIENTRY GetDoublev(GLenum pname, GLdouble *data)
{
Context *context = GetValidGlobalContext();
EVENT("glGetDoublev", "context = %d, GLenum pname = %s, GLdouble *data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetDoublev(context, pname, data));
if (isCallValid)
{
context->getDoublev(pname, data);
}
ANGLE_CAPTURE(GetDoublev, isCallValid, context, pname, data);
}
}
GLenum GL_APIENTRY GetError()
{
Context *context = GetGlobalContext();
EVENT("glGetError", "context = %d", CID(context));
GLenum returnValue;
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetError(context));
if (isCallValid)
{
returnValue = context->getError();
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
}
ANGLE_CAPTURE(GetError, isCallValid, context, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetError, GLenum>();
}
return returnValue;
}
void GL_APIENTRY GetFloatv(GLenum pname, GLfloat *data)
{
Context *context = GetValidGlobalContext();
EVENT("glGetFloatv", "context = %d, GLenum pname = %s, GLfloat *data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetFloatv(context, pname, data));
if (isCallValid)
{
context->getFloatv(pname, data);
}
ANGLE_CAPTURE(GetFloatv, isCallValid, context, pname, data);
}
}
void GL_APIENTRY GetIntegerv(GLenum pname, GLint *data)
{
Context *context = GetValidGlobalContext();
EVENT("glGetIntegerv", "context = %d, GLenum pname = %s, GLint *data = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::GetPName, pname), (uintptr_t)data);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetIntegerv(context, pname, data));
if (isCallValid)
{
context->getIntegerv(pname, data);
}
ANGLE_CAPTURE(GetIntegerv, isCallValid, context, pname, data);
}
}
void GL_APIENTRY GetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetLightfv",
"context = %d, GLenum light = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::LightName, light),
GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
if (context)
{
LightParameter pnamePacked = FromGL<LightParameter>(pname);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetLightfv(context, light, pnamePacked, params));
if (isCallValid)
{
context->getLightfv(light, pnamePacked, params);
}
ANGLE_CAPTURE(GetLightfv, isCallValid, context, light, pnamePacked, params);
}
}
void GL_APIENTRY GetLightiv(GLenum light, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetLightiv",
"context = %d, GLenum light = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::LightName, light),
GLenumToString(GLenumGroup::LightParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetLightiv(context, light, pname, params));
if (isCallValid)
{
context->getLightiv(light, pname, params);
}
ANGLE_CAPTURE(GetLightiv, isCallValid, context, light, pname, params);
}
}
void GL_APIENTRY GetMapdv(GLenum target, GLenum query, GLdouble *v)
{
Context *context = GetValidGlobalContext();
EVENT("glGetMapdv",
"context = %d, GLenum target = %s, GLenum query = %s, GLdouble *v = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::MapTarget, target),
GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetMapdv(context, target, query, v));
if (isCallValid)
{
context->getMapdv(target, query, v);
}
ANGLE_CAPTURE(GetMapdv, isCallValid, context, target, query, v);
}
}
void GL_APIENTRY GetMapfv(GLenum target, GLenum query, GLfloat *v)
{
Context *context = GetValidGlobalContext();
EVENT("glGetMapfv",
"context = %d, GLenum target = %s, GLenum query = %s, GLfloat *v = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::MapTarget, target),
GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetMapfv(context, target, query, v));
if (isCallValid)
{
context->getMapfv(target, query, v);
}
ANGLE_CAPTURE(GetMapfv, isCallValid, context, target, query, v);
}
}
void GL_APIENTRY GetMapiv(GLenum target, GLenum query, GLint *v)
{
Context *context = GetValidGlobalContext();
EVENT("glGetMapiv",
"context = %d, GLenum target = %s, GLenum query = %s, GLint *v = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::MapTarget, target),
GLenumToString(GLenumGroup::GetMapQuery, query), (uintptr_t)v);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetMapiv(context, target, query, v));
if (isCallValid)
{
context->getMapiv(target, query, v);
}
ANGLE_CAPTURE(GetMapiv, isCallValid, context, target, query, v);
}
}
void GL_APIENTRY GetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetMaterialfv",
"context = %d, GLenum face = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
if (context)
{
MaterialParameter pnamePacked = FromGL<MaterialParameter>(pname);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetMaterialfv(context, face, pnamePacked, params));
if (isCallValid)
{
context->getMaterialfv(face, pnamePacked, params);
}
ANGLE_CAPTURE(GetMaterialfv, isCallValid, context, face, pnamePacked, params);
}
}
void GL_APIENTRY GetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetMaterialiv",
"context = %d, GLenum face = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::MaterialFace, face),
GLenumToString(GLenumGroup::MaterialParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetMaterialiv(context, face, pname, params));
if (isCallValid)
{
context->getMaterialiv(face, pname, params);
}
ANGLE_CAPTURE(GetMaterialiv, isCallValid, context, face, pname, params);
}
}
void GL_APIENTRY GetPixelMapfv(GLenum map, GLfloat *values)
{
Context *context = GetValidGlobalContext();
EVENT("glGetPixelMapfv", "context = %d, GLenum map = %s, GLfloat *values = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetPixelMapfv(context, map, values));
if (isCallValid)
{
context->getPixelMapfv(map, values);
}
ANGLE_CAPTURE(GetPixelMapfv, isCallValid, context, map, values);
}
}
void GL_APIENTRY GetPixelMapuiv(GLenum map, GLuint *values)
{
Context *context = GetValidGlobalContext();
EVENT("glGetPixelMapuiv", "context = %d, GLenum map = %s, GLuint *values = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetPixelMapuiv(context, map, values));
if (isCallValid)
{
context->getPixelMapuiv(map, values);
}
ANGLE_CAPTURE(GetPixelMapuiv, isCallValid, context, map, values);
}
}
void GL_APIENTRY GetPixelMapusv(GLenum map, GLushort *values)
{
Context *context = GetValidGlobalContext();
EVENT("glGetPixelMapusv", "context = %d, GLenum map = %s, GLushort *values = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::PixelMap, map), (uintptr_t)values);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetPixelMapusv(context, map, values));
if (isCallValid)
{
context->getPixelMapusv(map, values);
}
ANGLE_CAPTURE(GetPixelMapusv, isCallValid, context, map, values);
}
}
void GL_APIENTRY GetPolygonStipple(GLubyte *mask)
{
Context *context = GetValidGlobalContext();
EVENT("glGetPolygonStipple", "context = %d, GLubyte *mask = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)mask);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetPolygonStipple(context, mask));
if (isCallValid)
{
context->getPolygonStipple(mask);
}
ANGLE_CAPTURE(GetPolygonStipple, isCallValid, context, mask);
}
}
const GLubyte *GL_APIENTRY GetString(GLenum name)
{
Context *context = GetValidGlobalContext();
EVENT("glGetString", "context = %d, GLenum name = %s", CID(context),
GLenumToString(GLenumGroup::StringName, name));
const GLubyte *returnValue;
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateGetString(context, name));
if (isCallValid)
{
returnValue = context->getString(name);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
}
ANGLE_CAPTURE(GetString, isCallValid, context, name, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetString, const GLubyte *>();
}
return returnValue;
}
void GL_APIENTRY GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexEnvfv",
"context = %d, GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
"",
CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
if (context)
{
TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetTexEnvfv(context, targetPacked, pnamePacked, params));
if (isCallValid)
{
context->getTexEnvfv(targetPacked, pnamePacked, params);
}
ANGLE_CAPTURE(GetTexEnvfv, isCallValid, context, targetPacked, pnamePacked, params);
}
}
void GL_APIENTRY GetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexEnviv",
"context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureEnvTarget, target),
GLenumToString(GLenumGroup::TextureEnvParameter, pname), (uintptr_t)params);
if (context)
{
TextureEnvTarget targetPacked = FromGL<TextureEnvTarget>(target);
TextureEnvParameter pnamePacked = FromGL<TextureEnvParameter>(pname);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetTexEnviv(context, targetPacked, pnamePacked, params));
if (isCallValid)
{
context->getTexEnviv(targetPacked, pnamePacked, params);
}
ANGLE_CAPTURE(GetTexEnviv, isCallValid, context, targetPacked, pnamePacked, params);
}
}
void GL_APIENTRY GetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexGendv",
"context = %d, GLenum coord = %s, GLenum pname = %s, GLdouble *params = 0x%016" PRIxPTR
"",
CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetTexGendv(context, coord, pname, params));
if (isCallValid)
{
context->getTexGendv(coord, pname, params);
}
ANGLE_CAPTURE(GetTexGendv, isCallValid, context, coord, pname, params);
}
}
void GL_APIENTRY GetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexGenfv",
"context = %d, GLenum coord = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetTexGenfv(context, coord, pname, params));
if (isCallValid)
{
context->getTexGenfv(coord, pname, params);
}
ANGLE_CAPTURE(GetTexGenfv, isCallValid, context, coord, pname, params);
}
}
void GL_APIENTRY GetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexGeniv",
"context = %d, GLenum coord = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureCoordName, coord),
GLenumToString(GLenumGroup::TextureGenParameter, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGetTexGeniv(context, coord, pname, params));
if (isCallValid)
{
context->getTexGeniv(coord, pname, params);
}
ANGLE_CAPTURE(GetTexGeniv, isCallValid, context, coord, pname, params);
}
}
void GL_APIENTRY GetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexImage",
"context = %d, GLenum target = %s, GLint level = %d, GLenum format = %s, GLenum type = "
"%s, void *pixels = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
GLenumToString(GLenumGroup::PixelFormat, format),
GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)pixels);
if (context)
{
TextureTarget targetPacked = FromGL<TextureTarget>(target);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetTexImage(context, targetPacked, level, format, type, pixels));
if (isCallValid)
{
context->getTexImage(targetPacked, level, format, type, pixels);
}
ANGLE_CAPTURE(GetTexImage, isCallValid, context, targetPacked, level, format, type, pixels);
}
}
void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexLevelParameterfv",
"context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat *params "
"= 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureTarget targetPacked = FromGL<TextureTarget>(target);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params));
if (isCallValid)
{
context->getTexLevelParameterfv(targetPacked, level, pname, params);
}
ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname,
params);
}
}
void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexLevelParameteriv",
"context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint *params = "
"0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level,
GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureTarget targetPacked = FromGL<TextureTarget>(target);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params));
if (isCallValid)
{
context->getTexLevelParameteriv(targetPacked, level, pname, params);
}
ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname,
params);
}
}
void GL_APIENTRY GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexParameterfv",
"context = %d, GLenum target = %s, GLenum pname = %s, GLfloat *params = 0x%016" PRIxPTR
"",
CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = FromGL<TextureType>(target);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetTexParameterfv(context, targetPacked, pname, params));
if (isCallValid)
{
context->getTexParameterfv(targetPacked, pname, params);
}
ANGLE_CAPTURE(GetTexParameterfv, isCallValid, context, targetPacked, pname, params);
}
}
void GL_APIENTRY GetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetTexParameteriv",
"context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::TextureTarget, target),
GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params);
if (context)
{
TextureType targetPacked = FromGL<TextureType>(target);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetTexParameteriv(context, targetPacked, pname, params));
if (isCallValid)
{
context->getTexParameteriv(targetPacked, pname, params);
}
ANGLE_CAPTURE(GetTexParameteriv, isCallValid, context, targetPacked, pname, params);
}
}
void GL_APIENTRY Hint(GLenum target, GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glHint", "context = %d, GLenum target = %s, GLenum mode = %s", CID(context),
GLenumToString(GLenumGroup::HintTarget, target),
GLenumToString(GLenumGroup::HintMode, mode));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateHint(context, target, mode));
if (isCallValid)
{
context->hint(target, mode);
}
ANGLE_CAPTURE(Hint, isCallValid, context, target, mode);
}
}
void GL_APIENTRY IndexMask(GLuint mask)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexMask", "context = %d, GLuint mask = %u", CID(context), mask);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexMask(context, mask));
if (isCallValid)
{
context->indexMask(mask);
}
ANGLE_CAPTURE(IndexMask, isCallValid, context, mask);
}
}
void GL_APIENTRY Indexd(GLdouble c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexd", "context = %d, GLdouble c = %f", CID(context), c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexd(context, c));
if (isCallValid)
{
context->indexd(c);
}
ANGLE_CAPTURE(Indexd, isCallValid, context, c);
}
}
void GL_APIENTRY Indexdv(const GLdouble *c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexdv", "context = %d, const GLdouble *c = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexdv(context, c));
if (isCallValid)
{
context->indexdv(c);
}
ANGLE_CAPTURE(Indexdv, isCallValid, context, c);
}
}
void GL_APIENTRY Indexf(GLfloat c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexf", "context = %d, GLfloat c = %f", CID(context), c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexf(context, c));
if (isCallValid)
{
context->indexf(c);
}
ANGLE_CAPTURE(Indexf, isCallValid, context, c);
}
}
void GL_APIENTRY Indexfv(const GLfloat *c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexfv", "context = %d, const GLfloat *c = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexfv(context, c));
if (isCallValid)
{
context->indexfv(c);
}
ANGLE_CAPTURE(Indexfv, isCallValid, context, c);
}
}
void GL_APIENTRY Indexi(GLint c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexi", "context = %d, GLint c = %d", CID(context), c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexi(context, c));
if (isCallValid)
{
context->indexi(c);
}
ANGLE_CAPTURE(Indexi, isCallValid, context, c);
}
}
void GL_APIENTRY Indexiv(const GLint *c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexiv", "context = %d, const GLint *c = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexiv(context, c));
if (isCallValid)
{
context->indexiv(c);
}
ANGLE_CAPTURE(Indexiv, isCallValid, context, c);
}
}
void GL_APIENTRY Indexs(GLshort c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexs", "context = %d, GLshort c = %d", CID(context), c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexs(context, c));
if (isCallValid)
{
context->indexs(c);
}
ANGLE_CAPTURE(Indexs, isCallValid, context, c);
}
}
void GL_APIENTRY Indexsv(const GLshort *c)
{
Context *context = GetValidGlobalContext();
EVENT("glIndexsv", "context = %d, const GLshort *c = 0x%016" PRIxPTR "", CID(context),
(uintptr_t)c);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIndexsv(context, c));
if (isCallValid)
{
context->indexsv(c);
}
ANGLE_CAPTURE(Indexsv, isCallValid, context, c);
}
}
void GL_APIENTRY InitNames()
{
Context *context = GetValidGlobalContext();
EVENT("glInitNames", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateInitNames(context));
if (isCallValid)
{
context->initNames();
}
ANGLE_CAPTURE(InitNames, isCallValid, context);
}
}
GLboolean GL_APIENTRY IsEnabled(GLenum cap)
{
Context *context = GetValidGlobalContext();
EVENT("glIsEnabled", "context = %d, GLenum cap = %s", CID(context),
GLenumToString(GLenumGroup::EnableCap, cap));
GLboolean returnValue;
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIsEnabled(context, cap));
if (isCallValid)
{
returnValue = context->isEnabled(cap);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
}
ANGLE_CAPTURE(IsEnabled, isCallValid, context, cap, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsEnabled, GLboolean>();
}
return returnValue;
}
GLboolean GL_APIENTRY IsList(GLuint list)
{
Context *context = GetValidGlobalContext();
EVENT("glIsList", "context = %d, GLuint list = %u", CID(context), list);
GLboolean returnValue;
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateIsList(context, list));
if (isCallValid)
{
returnValue = context->isList(list);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsList, GLboolean>();
}
ANGLE_CAPTURE(IsList, isCallValid, context, list, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsList, GLboolean>();
}
return returnValue;
}
void GL_APIENTRY LightModelf(GLenum pname, GLfloat param)
{
Context *context = GetValidGlobalContext();
EVENT("glLightModelf", "context = %d, GLenum pname = %s, GLfloat param = %f", CID(context),
GLenumToString(GLenumGroup::LightModelParameter, pname