blob: c96b8b16f762ed9c9b5ecf0dece3421dd7c0d154 [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_4_0_autogen.cpp:
// Defines the GL 4.0 entry points.
#include "libGL/entry_points_gl_4_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/validationGL4_autogen.h"
#include "libGLESv2/global_state.h"
namespace gl
{
void GL_APIENTRY BeginQueryIndexed(GLenum target, GLuint index, GLuint id)
{
Context *context = GetValidGlobalContext();
EVENT("glBeginQueryIndexed",
"context = %d, GLenum target = %s, GLuint index = %u, GLuint id = %u", CID(context),
GLenumToString(GLenumGroup::QueryTarget, target), index, id);
if (context)
{
QueryID idPacked = FromGL<QueryID>(id);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateBeginQueryIndexed(context, target, index, idPacked));
if (isCallValid)
{
context->beginQueryIndexed(target, index, idPacked);
}
ANGLE_CAPTURE(BeginQueryIndexed, isCallValid, context, target, index, idPacked);
}
}
void GL_APIENTRY BindTransformFeedback(GLenum target, GLuint id)
{
Context *context = GetValidGlobalContext();
EVENT("glBindTransformFeedback", "context = %d, GLenum target = %s, GLuint id = %u",
CID(context), GLenumToString(GLenumGroup::BindTransformFeedbackTarget, target), id);
if (context)
{
TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateBindTransformFeedback(context, target, idPacked));
if (isCallValid)
{
context->bindTransformFeedback(target, idPacked);
}
ANGLE_CAPTURE(BindTransformFeedback, isCallValid, context, target, idPacked);
}
}
void GL_APIENTRY BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
Context *context = GetValidGlobalContext();
EVENT("glBlendEquationSeparatei",
"context = %d, GLuint buf = %u, GLenum modeRGB = %s, GLenum modeAlpha = %s", CID(context),
buf, GLenumToString(GLenumGroup::BlendEquationModeEXT, modeRGB),
GLenumToString(GLenumGroup::BlendEquationModeEXT, modeAlpha));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateBlendEquationSeparatei(context, buf, modeRGB, modeAlpha));
if (isCallValid)
{
context->blendEquationSeparatei(buf, modeRGB, modeAlpha);
}
ANGLE_CAPTURE(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha);
}
}
void GL_APIENTRY BlendEquationi(GLuint buf, GLenum mode)
{
Context *context = GetValidGlobalContext();
EVENT("glBlendEquationi", "context = %d, GLuint buf = %u, GLenum mode = %s", CID(context), buf,
GLenumToString(GLenumGroup::BlendEquationModeEXT, mode));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateBlendEquationi(context, buf, mode));
if (isCallValid)
{
context->blendEquationi(buf, mode);
}
ANGLE_CAPTURE(BlendEquationi, isCallValid, context, buf, mode);
}
}
void GL_APIENTRY
BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
Context *context = GetValidGlobalContext();
EVENT("glBlendFuncSeparatei",
"context = %d, GLuint buf = %u, GLenum srcRGB = %s, GLenum dstRGB = %s, GLenum srcAlpha "
"= %s, GLenum dstAlpha = %s",
CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, srcRGB),
GLenumToString(GLenumGroup::BlendingFactor, dstRGB),
GLenumToString(GLenumGroup::BlendingFactor, srcAlpha),
GLenumToString(GLenumGroup::BlendingFactor, dstAlpha));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateBlendFuncSeparatei(context, buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
if (isCallValid)
{
context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}
ANGLE_CAPTURE(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha,
dstAlpha);
}
}
void GL_APIENTRY BlendFunci(GLuint buf, GLenum src, GLenum dst)
{
Context *context = GetValidGlobalContext();
EVENT("glBlendFunci", "context = %d, GLuint buf = %u, GLenum src = %s, GLenum dst = %s",
CID(context), buf, GLenumToString(GLenumGroup::BlendingFactor, src),
GLenumToString(GLenumGroup::BlendingFactor, dst));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateBlendFunci(context, buf, src, dst));
if (isCallValid)
{
context->blendFunci(buf, src, dst);
}
ANGLE_CAPTURE(BlendFunci, isCallValid, context, buf, src, dst);
}
}
void GL_APIENTRY DeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
{
Context *context = GetValidGlobalContext();
EVENT("glDeleteTransformFeedbacks",
"context = %d, GLsizei n = %d, const GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
(uintptr_t)ids);
if (context)
{
const TransformFeedbackID *idsPacked = FromGL<const TransformFeedbackID *>(ids);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateDeleteTransformFeedbacks(context, n, idsPacked));
if (isCallValid)
{
context->deleteTransformFeedbacks(n, idsPacked);
}
ANGLE_CAPTURE(DeleteTransformFeedbacks, isCallValid, context, n, idsPacked);
}
}
void GL_APIENTRY DrawArraysIndirect(GLenum mode, const void *indirect)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawArraysIndirect",
"context = %d, GLenum mode = %s, const void *indirect = 0x%016" PRIxPTR "", CID(context),
GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect);
if (context)
{
PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateDrawArraysIndirect(context, modePacked, indirect));
if (isCallValid)
{
context->drawArraysIndirect(modePacked, indirect);
}
ANGLE_CAPTURE(DrawArraysIndirect, isCallValid, context, modePacked, indirect);
}
}
void GL_APIENTRY DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawElementsIndirect",
"context = %d, GLenum mode = %s, GLenum type = %s, const void *indirect = 0x%016" PRIxPTR
"",
CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode),
GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect);
if (context)
{
PrimitiveMode modePacked = FromGL<PrimitiveMode>(mode);
DrawElementsType typePacked = FromGL<DrawElementsType>(type);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateDrawElementsIndirect(context, modePacked, typePacked, indirect));
if (isCallValid)
{
context->drawElementsIndirect(modePacked, typePacked, indirect);
}
ANGLE_CAPTURE(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, indirect);
}
}
void GL_APIENTRY DrawTransformFeedback(GLenum mode, GLuint id)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawTransformFeedback", "context = %d, GLenum mode = %s, GLuint id = %u", CID(context),
GLenumToString(GLenumGroup::PrimitiveType, mode), id);
if (context)
{
TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateDrawTransformFeedback(context, mode, idPacked));
if (isCallValid)
{
context->drawTransformFeedback(mode, idPacked);
}
ANGLE_CAPTURE(DrawTransformFeedback, isCallValid, context, mode, idPacked);
}
}
void GL_APIENTRY DrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
{
Context *context = GetValidGlobalContext();
EVENT("glDrawTransformFeedbackStream",
"context = %d, GLenum mode = %s, GLuint id = %u, GLuint stream = %u", CID(context),
GLenumToString(GLenumGroup::PrimitiveType, mode), id, stream);
if (context)
{
TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateDrawTransformFeedbackStream(context, mode, idPacked, stream));
if (isCallValid)
{
context->drawTransformFeedbackStream(mode, idPacked, stream);
}
ANGLE_CAPTURE(DrawTransformFeedbackStream, isCallValid, context, mode, idPacked, stream);
}
}
void GL_APIENTRY EndQueryIndexed(GLenum target, GLuint index)
{
Context *context = GetValidGlobalContext();
EVENT("glEndQueryIndexed", "context = %d, GLenum target = %s, GLuint index = %u", CID(context),
GLenumToString(GLenumGroup::QueryTarget, target), index);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateEndQueryIndexed(context, target, index));
if (isCallValid)
{
context->endQueryIndexed(target, index);
}
ANGLE_CAPTURE(EndQueryIndexed, isCallValid, context, target, index);
}
}
void GL_APIENTRY GenTransformFeedbacks(GLsizei n, GLuint *ids)
{
Context *context = GetValidGlobalContext();
EVENT("glGenTransformFeedbacks",
"context = %d, GLsizei n = %d, GLuint *ids = 0x%016" PRIxPTR "", CID(context), n,
(uintptr_t)ids);
if (context)
{
TransformFeedbackID *idsPacked = FromGL<TransformFeedbackID *>(ids);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateGenTransformFeedbacks(context, n, idsPacked));
if (isCallValid)
{
context->genTransformFeedbacks(n, idsPacked);
}
ANGLE_CAPTURE(GenTransformFeedbacks, isCallValid, context, n, idsPacked);
}
}
void GL_APIENTRY GetActiveSubroutineName(GLuint program,
GLenum shadertype,
GLuint index,
GLsizei bufsize,
GLsizei *length,
GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT("glGetActiveSubroutineName",
"context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei "
"bufsize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
bufsize, (uintptr_t)length, (uintptr_t)name);
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetActiveSubroutineName(context, programPacked, shadertype,
index, bufsize, length, name));
if (isCallValid)
{
context->getActiveSubroutineName(programPacked, shadertype, index, bufsize, length,
name);
}
ANGLE_CAPTURE(GetActiveSubroutineName, isCallValid, context, programPacked, shadertype,
index, bufsize, length, name);
}
}
void GL_APIENTRY GetActiveSubroutineUniformName(GLuint program,
GLenum shadertype,
GLuint index,
GLsizei bufsize,
GLsizei *length,
GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT("glGetActiveSubroutineUniformName",
"context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLsizei "
"bufsize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
bufsize, (uintptr_t)length, (uintptr_t)name);
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetActiveSubroutineUniformName(
context, programPacked, shadertype, index, bufsize, length, name));
if (isCallValid)
{
context->getActiveSubroutineUniformName(programPacked, shadertype, index, bufsize,
length, name);
}
ANGLE_CAPTURE(GetActiveSubroutineUniformName, isCallValid, context, programPacked,
shadertype, index, bufsize, length, name);
}
}
void GL_APIENTRY GetActiveSubroutineUniformiv(GLuint program,
GLenum shadertype,
GLuint index,
GLenum pname,
GLint *values)
{
Context *context = GetValidGlobalContext();
EVENT("glGetActiveSubroutineUniformiv",
"context = %d, GLuint program = %u, GLenum shadertype = %s, GLuint index = %u, GLenum "
"pname = %s, GLint *values = 0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype), index,
GLenumToString(GLenumGroup::SubroutineParameterName, pname), (uintptr_t)values);
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetActiveSubroutineUniformiv(context, programPacked, shadertype,
index, pname, values));
if (isCallValid)
{
context->getActiveSubroutineUniformiv(programPacked, shadertype, index, pname, values);
}
ANGLE_CAPTURE(GetActiveSubroutineUniformiv, isCallValid, context, programPacked, shadertype,
index, pname, values);
}
}
void GL_APIENTRY GetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
{
Context *context = GetValidGlobalContext();
EVENT("glGetProgramStageiv",
"context = %d, GLuint program = %u, GLenum shadertype = %s, GLenum pname = %s, GLint "
"*values = 0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
GLenumToString(GLenumGroup::ProgramStagePName, pname), (uintptr_t)values);
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetProgramStageiv(context, programPacked, shadertype, pname, values));
if (isCallValid)
{
context->getProgramStageiv(programPacked, shadertype, pname, values);
}
ANGLE_CAPTURE(GetProgramStageiv, isCallValid, context, programPacked, shadertype, pname,
values);
}
}
void GL_APIENTRY GetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
{
Context *context = GetValidGlobalContext();
EVENT("glGetQueryIndexediv",
"context = %d, GLenum target = %s, GLuint index = %u, GLenum pname = %s, GLint *params = "
"0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), index,
GLenumToString(GLenumGroup::QueryParameterName, pname), (uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetQueryIndexediv(context, target, index, pname, params));
if (isCallValid)
{
context->getQueryIndexediv(target, index, pname, params);
}
ANGLE_CAPTURE(GetQueryIndexediv, isCallValid, context, target, index, pname, params);
}
}
GLuint GL_APIENTRY GetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT("glGetSubroutineIndex",
"context = %d, GLuint program = %u, GLenum shadertype = %s, const GLchar *name = "
"0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
(uintptr_t)name);
GLuint returnValue;
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetSubroutineIndex(context, programPacked, shadertype, name));
if (isCallValid)
{
returnValue = context->getSubroutineIndex(programPacked, shadertype, name);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
}
ANGLE_CAPTURE(GetSubroutineIndex, isCallValid, context, programPacked, shadertype, name,
returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineIndex, GLuint>();
}
return returnValue;
}
GLint GL_APIENTRY GetSubroutineUniformLocation(GLuint program,
GLenum shadertype,
const GLchar *name)
{
Context *context = GetValidGlobalContext();
EVENT("glGetSubroutineUniformLocation",
"context = %d, GLuint program = %u, GLenum shadertype = %s, const GLchar *name = "
"0x%016" PRIxPTR "",
CID(context), program, GLenumToString(GLenumGroup::ShaderType, shadertype),
(uintptr_t)name);
GLint returnValue;
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() ||
ValidateGetSubroutineUniformLocation(context, programPacked, shadertype, name));
if (isCallValid)
{
returnValue = context->getSubroutineUniformLocation(programPacked, shadertype, name);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
}
ANGLE_CAPTURE(GetSubroutineUniformLocation, isCallValid, context, programPacked, shadertype,
name, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::GetSubroutineUniformLocation, GLint>();
}
return returnValue;
}
void GL_APIENTRY GetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
{
Context *context = GetValidGlobalContext();
EVENT(
"glGetUniformSubroutineuiv",
"context = %d, GLenum shadertype = %s, GLint location = %d, GLuint *params = 0x%016" PRIxPTR
"",
CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), location,
(uintptr_t)params);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetUniformSubroutineuiv(context, shadertype, location, params));
if (isCallValid)
{
context->getUniformSubroutineuiv(shadertype, location, params);
}
ANGLE_CAPTURE(GetUniformSubroutineuiv, isCallValid, context, shadertype, location, params);
}
}
void GL_APIENTRY GetUniformdv(GLuint program, GLint location, GLdouble *params)
{
Context *context = GetValidGlobalContext();
EVENT(
"glGetUniformdv",
"context = %d, GLuint program = %u, GLint location = %d, GLdouble *params = 0x%016" PRIxPTR
"",
CID(context), program, location, (uintptr_t)params);
if (context)
{
ShaderProgramID programPacked = FromGL<ShaderProgramID>(program);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateGetUniformdv(context, programPacked, location, params));
if (isCallValid)
{
context->getUniformdv(programPacked, location, params);
}
ANGLE_CAPTURE(GetUniformdv, isCallValid, context, programPacked, location, params);
}
}
GLboolean GL_APIENTRY IsTransformFeedback(GLuint id)
{
Context *context = GetValidGlobalContext();
EVENT("glIsTransformFeedback", "context = %d, GLuint id = %u", CID(context), id);
GLboolean returnValue;
if (context)
{
TransformFeedbackID idPacked = FromGL<TransformFeedbackID>(id);
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateIsTransformFeedback(context, idPacked));
if (isCallValid)
{
returnValue = context->isTransformFeedback(idPacked);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
}
ANGLE_CAPTURE(IsTransformFeedback, isCallValid, context, idPacked, returnValue);
}
else
{
returnValue = GetDefaultReturnValue<EntryPoint::IsTransformFeedback, GLboolean>();
}
return returnValue;
}
void GL_APIENTRY MinSampleShading(GLfloat value)
{
Context *context = GetValidGlobalContext();
EVENT("glMinSampleShading", "context = %d, GLfloat value = %f", CID(context), value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateMinSampleShading(context, value));
if (isCallValid)
{
context->minSampleShading(value);
}
ANGLE_CAPTURE(MinSampleShading, isCallValid, context, value);
}
}
void GL_APIENTRY PatchParameterfv(GLenum pname, const GLfloat *values)
{
Context *context = GetValidGlobalContext();
EVENT("glPatchParameterfv",
"context = %d, GLenum pname = %s, const GLfloat *values = 0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::PatchParameterName, pname), (uintptr_t)values);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidatePatchParameterfv(context, pname, values));
if (isCallValid)
{
context->patchParameterfv(pname, values);
}
ANGLE_CAPTURE(PatchParameterfv, isCallValid, context, pname, values);
}
}
void GL_APIENTRY PatchParameteri(GLenum pname, GLint value)
{
Context *context = GetValidGlobalContext();
EVENT("glPatchParameteri", "context = %d, GLenum pname = %s, GLint value = %d", CID(context),
GLenumToString(GLenumGroup::PatchParameterName, pname), value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidatePatchParameteri(context, pname, value));
if (isCallValid)
{
context->patchParameteri(pname, value);
}
ANGLE_CAPTURE(PatchParameteri, isCallValid, context, pname, value);
}
}
void GL_APIENTRY PauseTransformFeedback()
{
Context *context = GetValidGlobalContext();
EVENT("glPauseTransformFeedback", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidatePauseTransformFeedback(context));
if (isCallValid)
{
context->pauseTransformFeedback();
}
ANGLE_CAPTURE(PauseTransformFeedback, isCallValid, context);
}
}
void GL_APIENTRY ResumeTransformFeedback()
{
Context *context = GetValidGlobalContext();
EVENT("glResumeTransformFeedback", "context = %d", CID(context));
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateResumeTransformFeedback(context));
if (isCallValid)
{
context->resumeTransformFeedback();
}
ANGLE_CAPTURE(ResumeTransformFeedback, isCallValid, context);
}
}
void GL_APIENTRY Uniform1d(GLint location, GLdouble x)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform1d", "context = %d, GLint location = %d, GLdouble x = %f", CID(context),
location, x);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() || ValidateUniform1d(context, location, x));
if (isCallValid)
{
context->uniform1d(location, x);
}
ANGLE_CAPTURE(Uniform1d, isCallValid, context, location, x);
}
}
void GL_APIENTRY Uniform1dv(GLint location, GLsizei count, const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform1dv",
"context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
"0x%016" PRIxPTR "",
CID(context), location, count, (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform1dv(context, location, count, value));
if (isCallValid)
{
context->uniform1dv(location, count, value);
}
ANGLE_CAPTURE(Uniform1dv, isCallValid, context, location, count, value);
}
}
void GL_APIENTRY Uniform2d(GLint location, GLdouble x, GLdouble y)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform2d", "context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f",
CID(context), location, x, y);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform2d(context, location, x, y));
if (isCallValid)
{
context->uniform2d(location, x, y);
}
ANGLE_CAPTURE(Uniform2d, isCallValid, context, location, x, y);
}
}
void GL_APIENTRY Uniform2dv(GLint location, GLsizei count, const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform2dv",
"context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
"0x%016" PRIxPTR "",
CID(context), location, count, (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform2dv(context, location, count, value));
if (isCallValid)
{
context->uniform2dv(location, count, value);
}
ANGLE_CAPTURE(Uniform2dv, isCallValid, context, location, count, value);
}
}
void GL_APIENTRY Uniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform3d",
"context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f",
CID(context), location, x, y, z);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform3d(context, location, x, y, z));
if (isCallValid)
{
context->uniform3d(location, x, y, z);
}
ANGLE_CAPTURE(Uniform3d, isCallValid, context, location, x, y, z);
}
}
void GL_APIENTRY Uniform3dv(GLint location, GLsizei count, const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform3dv",
"context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
"0x%016" PRIxPTR "",
CID(context), location, count, (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform3dv(context, location, count, value));
if (isCallValid)
{
context->uniform3dv(location, count, value);
}
ANGLE_CAPTURE(Uniform3dv, isCallValid, context, location, count, value);
}
}
void GL_APIENTRY Uniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform4d",
"context = %d, GLint location = %d, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, "
"GLdouble w = %f",
CID(context), location, x, y, z, w);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform4d(context, location, x, y, z, w));
if (isCallValid)
{
context->uniform4d(location, x, y, z, w);
}
ANGLE_CAPTURE(Uniform4d, isCallValid, context, location, x, y, z, w);
}
}
void GL_APIENTRY Uniform4dv(GLint location, GLsizei count, const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniform4dv",
"context = %d, GLint location = %d, GLsizei count = %d, const GLdouble *value = "
"0x%016" PRIxPTR "",
CID(context), location, count, (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid =
(context->skipValidation() || ValidateUniform4dv(context, location, count, value));
if (isCallValid)
{
context->uniform4dv(location, count, value);
}
ANGLE_CAPTURE(Uniform4dv, isCallValid, context, location, count, value);
}
}
void GL_APIENTRY UniformMatrix2dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix2dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix2dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix2dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix2dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix2x3dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix2x3dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix2x3dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix2x3dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix2x3dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix2x4dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix2x4dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix2x4dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix2x4dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix2x4dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix3dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix3dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix3dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix3dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix3dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix3x2dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix3x2dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix3x2dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix3x2dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix3x2dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix3x4dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix3x4dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix3x4dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix3x4dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix3x4dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix4dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix4dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix4dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix4dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix4dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix4x2dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix4x2dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix4x2dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix4x2dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix4x2dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformMatrix4x3dv(GLint location,
GLsizei count,
GLboolean transpose,
const GLdouble *value)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformMatrix4x3dv",
"context = %d, GLint location = %d, GLsizei count = %d, GLboolean transpose = %s, const "
"GLdouble *value = 0x%016" PRIxPTR "",
CID(context), location, count, GLbooleanToString(transpose), (uintptr_t)value);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformMatrix4x3dv(context, location, count, transpose, value));
if (isCallValid)
{
context->uniformMatrix4x3dv(location, count, transpose, value);
}
ANGLE_CAPTURE(UniformMatrix4x3dv, isCallValid, context, location, count, transpose, value);
}
}
void GL_APIENTRY UniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
{
Context *context = GetValidGlobalContext();
EVENT("glUniformSubroutinesuiv",
"context = %d, GLenum shadertype = %s, GLsizei count = %d, const GLuint *indices = "
"0x%016" PRIxPTR "",
CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), count,
(uintptr_t)indices);
if (context)
{
std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context);
bool isCallValid = (context->skipValidation() ||
ValidateUniformSubroutinesuiv(context, shadertype, count, indices));
if (isCallValid)
{
context->uniformSubroutinesuiv(shadertype, count, indices);
}
ANGLE_CAPTURE(UniformSubroutinesuiv, isCallValid, context, shadertype, count, indices);
}
}
} // namespace gl