| // 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_1_autogen.cpp: |
| // Defines the GL 4.1 entry points. |
| |
| #include "libGL/entry_points_gl_4_1_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/validationGL41_autogen.h" |
| #include "libGLESv2/global_state.h" |
| |
| namespace gl |
| { |
| void GL_APIENTRY ActiveShaderProgram(GLuint pipeline, GLuint program) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glActiveShaderProgram", "context = %d, GLuint pipeline = %u, GLuint program = %u", |
| CID(context), pipeline, program); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateActiveShaderProgram(context, pipelinePacked, programPacked)); |
| if (isCallValid) |
| { |
| context->activeShaderProgram(pipelinePacked, programPacked); |
| } |
| ANGLE_CAPTURE(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked); |
| } |
| } |
| |
| void GL_APIENTRY BindProgramPipeline(GLuint pipeline) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glBindProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateBindProgramPipeline(context, pipelinePacked)); |
| if (isCallValid) |
| { |
| context->bindProgramPipeline(pipelinePacked); |
| } |
| ANGLE_CAPTURE(BindProgramPipeline, isCallValid, context, pipelinePacked); |
| } |
| } |
| |
| void GL_APIENTRY ClearDepthf(GLfloat d) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glClearDepthf", "context = %d, GLfloat d = %f", CID(context), d); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || ValidateClearDepthf(context, d)); |
| if (isCallValid) |
| { |
| context->clearDepthf(d); |
| } |
| ANGLE_CAPTURE(ClearDepthf, isCallValid, context, d); |
| } |
| } |
| |
| GLuint GL_APIENTRY CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glCreateShaderProgramv", |
| "context = %d, GLenum type = %s, GLsizei count = %d, const GLchar *const*strings = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::ShaderType, type), count, (uintptr_t)strings); |
| |
| GLuint returnValue; |
| if (context) |
| { |
| ShaderType typePacked = FromGL<ShaderType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateCreateShaderProgramv(context, typePacked, count, strings)); |
| if (isCallValid) |
| { |
| returnValue = context->createShaderProgramv(typePacked, count, strings); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>(); |
| } |
| ANGLE_CAPTURE(CreateShaderProgramv, isCallValid, context, typePacked, count, strings, |
| returnValue); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::CreateShaderProgramv, GLuint>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY DeleteProgramPipelines(GLsizei n, const GLuint *pipelines) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDeleteProgramPipelines", |
| "context = %d, GLsizei n = %d, const GLuint *pipelines = 0x%016" PRIxPTR "", CID(context), |
| n, (uintptr_t)pipelines); |
| |
| if (context) |
| { |
| const ProgramPipelineID *pipelinesPacked = FromGL<const ProgramPipelineID *>(pipelines); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateDeleteProgramPipelines(context, n, pipelinesPacked)); |
| if (isCallValid) |
| { |
| context->deleteProgramPipelines(n, pipelinesPacked); |
| } |
| ANGLE_CAPTURE(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked); |
| } |
| } |
| |
| void GL_APIENTRY DepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDepthRangeArrayv", |
| "context = %d, GLuint first = %u, GLsizei count = %d, const GLdouble *v = 0x%016" PRIxPTR |
| "", |
| CID(context), first, count, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDepthRangeArrayv(context, first, count, v)); |
| if (isCallValid) |
| { |
| context->depthRangeArrayv(first, count, v); |
| } |
| ANGLE_CAPTURE(DepthRangeArrayv, isCallValid, context, first, count, v); |
| } |
| } |
| |
| void GL_APIENTRY DepthRangeIndexed(GLuint index, GLdouble n, GLdouble f) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDepthRangeIndexed", |
| "context = %d, GLuint index = %u, GLdouble n = %f, GLdouble f = %f", CID(context), index, |
| n, f); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDepthRangeIndexed(context, index, n, f)); |
| if (isCallValid) |
| { |
| context->depthRangeIndexed(index, n, f); |
| } |
| ANGLE_CAPTURE(DepthRangeIndexed, isCallValid, context, index, n, f); |
| } |
| } |
| |
| void GL_APIENTRY DepthRangef(GLfloat n, GLfloat f) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDepthRangef", "context = %d, GLfloat n = %f, GLfloat f = %f", CID(context), n, f); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || ValidateDepthRangef(context, n, f)); |
| if (isCallValid) |
| { |
| context->depthRangef(n, f); |
| } |
| ANGLE_CAPTURE(DepthRangef, isCallValid, context, n, f); |
| } |
| } |
| |
| void GL_APIENTRY GenProgramPipelines(GLsizei n, GLuint *pipelines) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGenProgramPipelines", |
| "context = %d, GLsizei n = %d, GLuint *pipelines = 0x%016" PRIxPTR "", CID(context), n, |
| (uintptr_t)pipelines); |
| |
| if (context) |
| { |
| ProgramPipelineID *pipelinesPacked = FromGL<ProgramPipelineID *>(pipelines); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGenProgramPipelines(context, n, pipelinesPacked)); |
| if (isCallValid) |
| { |
| context->genProgramPipelines(n, pipelinesPacked); |
| } |
| ANGLE_CAPTURE(GenProgramPipelines, isCallValid, context, n, pipelinesPacked); |
| } |
| } |
| |
| void GL_APIENTRY GetDoublei_v(GLenum target, GLuint index, GLdouble *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetDoublei_v", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLdouble *data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetDoublei_v(context, target, index, data)); |
| if (isCallValid) |
| { |
| context->getDoublei_v(target, index, data); |
| } |
| ANGLE_CAPTURE(GetDoublei_v, isCallValid, context, target, index, data); |
| } |
| } |
| |
| void GL_APIENTRY GetFloati_v(GLenum target, GLuint index, GLfloat *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetFloati_v", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLfloat *data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TypeEnum, target), index, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetFloati_v(context, target, index, data)); |
| if (isCallValid) |
| { |
| context->getFloati_v(target, index, data); |
| } |
| ANGLE_CAPTURE(GetFloati_v, isCallValid, context, target, index, data); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramBinary(GLuint program, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLenum *binaryFormat, |
| void *binary) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glGetProgramBinary", |
| "context = %d, GLuint program = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR |
| ", GLenum *binaryFormat = 0x%016" PRIxPTR ", void *binary = 0x%016" PRIxPTR "", |
| CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, |
| (uintptr_t)binary); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetProgramBinary(context, programPacked, bufSize, |
| length, binaryFormat, binary)); |
| if (isCallValid) |
| { |
| context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary); |
| } |
| ANGLE_CAPTURE(GetProgramBinary, isCallValid, context, programPacked, bufSize, length, |
| binaryFormat, binary); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramPipelineInfoLog(GLuint pipeline, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *infoLog) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glGetProgramPipelineInfoLog", |
| "context = %d, GLuint pipeline = %u, GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR |
| ", GLchar *infoLog = 0x%016" PRIxPTR "", |
| CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramPipelineInfoLog(context, pipelinePacked, bufSize, length, infoLog)); |
| if (isCallValid) |
| { |
| context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog); |
| } |
| ANGLE_CAPTURE(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize, |
| length, infoLog); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramPipelineiv", |
| "context = %d, GLuint pipeline = %u, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR |
| "", |
| CID(context), pipeline, GLenumToString(GLenumGroup::PipelineParameterName, pname), |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetProgramPipelineiv(context, pipelinePacked, pname, params)); |
| if (isCallValid) |
| { |
| context->getProgramPipelineiv(pipelinePacked, pname, params); |
| } |
| ANGLE_CAPTURE(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params); |
| } |
| } |
| |
| void GL_APIENTRY GetShaderPrecisionFormat(GLenum shadertype, |
| GLenum precisiontype, |
| GLint *range, |
| GLint *precision) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetShaderPrecisionFormat", |
| "context = %d, GLenum shadertype = %s, GLenum precisiontype = %s, GLint *range = " |
| "0x%016" PRIxPTR ", GLint *precision = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::ShaderType, shadertype), |
| GLenumToString(GLenumGroup::PrecisionType, precisiontype), (uintptr_t)range, |
| (uintptr_t)precision); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetShaderPrecisionFormat(context, shadertype, precisiontype, |
| range, precision)); |
| if (isCallValid) |
| { |
| context->getShaderPrecisionFormat(shadertype, precisiontype, range, precision); |
| } |
| ANGLE_CAPTURE(GetShaderPrecisionFormat, isCallValid, context, shadertype, precisiontype, |
| range, precision); |
| } |
| } |
| |
| void GL_APIENTRY GetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetVertexAttribLdv", |
| "context = %d, GLuint index = %u, GLenum pname = %s, GLdouble *params = 0x%016" PRIxPTR |
| "", |
| CID(context), index, GLenumToString(GLenumGroup::VertexAttribEnum, pname), |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetVertexAttribLdv(context, index, pname, params)); |
| if (isCallValid) |
| { |
| context->getVertexAttribLdv(index, pname, params); |
| } |
| ANGLE_CAPTURE(GetVertexAttribLdv, isCallValid, context, index, pname, params); |
| } |
| } |
| |
| GLboolean GL_APIENTRY IsProgramPipeline(GLuint pipeline) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glIsProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), pipeline); |
| |
| GLboolean returnValue; |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateIsProgramPipeline(context, pipelinePacked)); |
| if (isCallValid) |
| { |
| returnValue = context->isProgramPipeline(pipelinePacked); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>(); |
| } |
| ANGLE_CAPTURE(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::IsProgramPipeline, GLboolean>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY ProgramBinary(GLuint program, |
| GLenum binaryFormat, |
| const void *binary, |
| GLsizei length) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramBinary", |
| "context = %d, GLuint program = %u, GLenum binaryFormat = %s, const void *binary = " |
| "0x%016" PRIxPTR ", GLsizei length = %d", |
| CID(context), program, GLenumToString(GLenumGroup::DefaultGroup, binaryFormat), |
| (uintptr_t)binary, length); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramBinary(context, programPacked, binaryFormat, binary, length)); |
| if (isCallValid) |
| { |
| context->programBinary(programPacked, binaryFormat, binary, length); |
| } |
| ANGLE_CAPTURE(ProgramBinary, isCallValid, context, programPacked, binaryFormat, binary, |
| length); |
| } |
| } |
| |
| void GL_APIENTRY ProgramParameteri(GLuint program, GLenum pname, GLint value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramParameteri", |
| "context = %d, GLuint program = %u, GLenum pname = %s, GLint value = %d", CID(context), |
| program, GLenumToString(GLenumGroup::ProgramParameterPName, pname), value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramParameteri(context, programPacked, pname, value)); |
| if (isCallValid) |
| { |
| context->programParameteri(programPacked, pname, value); |
| } |
| ANGLE_CAPTURE(ProgramParameteri, isCallValid, context, programPacked, pname, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1d(GLuint program, GLint location, GLdouble v0) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1d", |
| "context = %d, GLuint program = %u, GLint location = %d, GLdouble v0 = %f", CID(context), |
| program, location, v0); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform1d(context, programPacked, location, v0)); |
| if (isCallValid) |
| { |
| context->programUniform1d(programPacked, location, v0); |
| } |
| ANGLE_CAPTURE(ProgramUniform1d, isCallValid, context, programPacked, location, v0); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform1dv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform1dv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform1dv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1f(GLuint program, GLint location, GLfloat v0) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1f", |
| "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f", CID(context), |
| program, location, v0); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform1f(context, programPacked, location, v0)); |
| if (isCallValid) |
| { |
| context->programUniform1f(programPacked, location, v0); |
| } |
| ANGLE_CAPTURE(ProgramUniform1f, isCallValid, context, programPacked, location, v0); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform1fv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform1fv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform1fv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1i(GLuint program, GLint location, GLint v0) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1i", |
| "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d", CID(context), |
| program, location, v0); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform1i(context, programPacked, location, v0)); |
| if (isCallValid) |
| { |
| context->programUniform1i(programPacked, location, v0); |
| } |
| ANGLE_CAPTURE(ProgramUniform1i, isCallValid, context, programPacked, location, v0); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1iv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1iv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint " |
| "*value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform1iv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform1iv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform1iv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1ui(GLuint program, GLint location, GLuint v0) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1ui", |
| "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u", CID(context), |
| program, location, v0); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform1ui(context, programPacked, location, v0)); |
| if (isCallValid) |
| { |
| context->programUniform1ui(programPacked, location, v0); |
| } |
| ANGLE_CAPTURE(ProgramUniform1ui, isCallValid, context, programPacked, location, v0); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform1uiv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform1uiv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLuint *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform1uiv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform1uiv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform1uiv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2d", |
| "context = %d, GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = " |
| "%f", |
| CID(context), program, location, v0, v1); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform2d(context, programPacked, location, v0, v1)); |
| if (isCallValid) |
| { |
| context->programUniform2d(programPacked, location, v0, v1); |
| } |
| ANGLE_CAPTURE(ProgramUniform2d, isCallValid, context, programPacked, location, v0, v1); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform2dv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform2dv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform2dv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glProgramUniform2f", |
| "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = %f", |
| CID(context), program, location, v0, v1); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform2f(context, programPacked, location, v0, v1)); |
| if (isCallValid) |
| { |
| context->programUniform2f(programPacked, location, v0, v1); |
| } |
| ANGLE_CAPTURE(ProgramUniform2f, isCallValid, context, programPacked, location, v0, v1); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform2fv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform2fv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform2fv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2i", |
| "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d", |
| CID(context), program, location, v0, v1); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform2i(context, programPacked, location, v0, v1)); |
| if (isCallValid) |
| { |
| context->programUniform2i(programPacked, location, v0, v1); |
| } |
| ANGLE_CAPTURE(ProgramUniform2i, isCallValid, context, programPacked, location, v0, v1); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2iv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2iv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint " |
| "*value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform2iv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform2iv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform2iv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2ui", |
| "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u", |
| CID(context), program, location, v0, v1); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform2ui(context, programPacked, location, v0, v1)); |
| if (isCallValid) |
| { |
| context->programUniform2ui(programPacked, location, v0, v1); |
| } |
| ANGLE_CAPTURE(ProgramUniform2ui, isCallValid, context, programPacked, location, v0, v1); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform2uiv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform2uiv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLuint *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform2uiv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform2uiv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform2uiv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3d", |
| "context = %d, GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = " |
| "%f, GLdouble v2 = %f", |
| CID(context), program, location, v0, v1, v2); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform3d(context, programPacked, location, v0, v1, v2)); |
| if (isCallValid) |
| { |
| context->programUniform3d(programPacked, location, v0, v1, v2); |
| } |
| ANGLE_CAPTURE(ProgramUniform3d, isCallValid, context, programPacked, location, v0, v1, v2); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform3dv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform3dv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform3dv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3f", |
| "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = " |
| "%f, GLfloat v2 = %f", |
| CID(context), program, location, v0, v1, v2); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform3f(context, programPacked, location, v0, v1, v2)); |
| if (isCallValid) |
| { |
| context->programUniform3f(programPacked, location, v0, v1, v2); |
| } |
| ANGLE_CAPTURE(ProgramUniform3f, isCallValid, context, programPacked, location, v0, v1, v2); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform3fv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform3fv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform3fv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3i", |
| "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, " |
| "GLint v2 = %d", |
| CID(context), program, location, v0, v1, v2); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniform3i(context, programPacked, location, v0, v1, v2)); |
| if (isCallValid) |
| { |
| context->programUniform3i(programPacked, location, v0, v1, v2); |
| } |
| ANGLE_CAPTURE(ProgramUniform3i, isCallValid, context, programPacked, location, v0, v1, v2); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3iv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3iv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint " |
| "*value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform3iv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform3iv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform3iv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3ui", |
| "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, " |
| "GLuint v2 = %u", |
| CID(context), program, location, v0, v1, v2); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform3ui(context, programPacked, location, v0, v1, v2)); |
| if (isCallValid) |
| { |
| context->programUniform3ui(programPacked, location, v0, v1, v2); |
| } |
| ANGLE_CAPTURE(ProgramUniform3ui, isCallValid, context, programPacked, location, v0, v1, v2); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform3uiv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform3uiv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLuint *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform3uiv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform3uiv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform3uiv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4d", |
| "context = %d, GLuint program = %u, GLint location = %d, GLdouble v0 = %f, GLdouble v1 = " |
| "%f, GLdouble v2 = %f, GLdouble v3 = %f", |
| CID(context), program, location, v0, v1, v2, v3); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4d(context, programPacked, location, v0, v1, v2, v3)); |
| if (isCallValid) |
| { |
| context->programUniform4d(programPacked, location, v0, v1, v2, v3); |
| } |
| ANGLE_CAPTURE(ProgramUniform4d, isCallValid, context, programPacked, location, v0, v1, v2, |
| v3); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform4dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4dv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform4dv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform4dv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4f", |
| "context = %d, GLuint program = %u, GLint location = %d, GLfloat v0 = %f, GLfloat v1 = " |
| "%f, GLfloat v2 = %f, GLfloat v3 = %f", |
| CID(context), program, location, v0, v1, v2, v3); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4f(context, programPacked, location, v0, v1, v2, v3)); |
| if (isCallValid) |
| { |
| context->programUniform4f(programPacked, location, v0, v1, v2, v3); |
| } |
| ANGLE_CAPTURE(ProgramUniform4f, isCallValid, context, programPacked, location, v0, v1, v2, |
| v3); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform4fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4fv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform4fv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform4fv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4i", |
| "context = %d, GLuint program = %u, GLint location = %d, GLint v0 = %d, GLint v1 = %d, " |
| "GLint v2 = %d, GLint v3 = %d", |
| CID(context), program, location, v0, v1, v2, v3); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4i(context, programPacked, location, v0, v1, v2, v3)); |
| if (isCallValid) |
| { |
| context->programUniform4i(programPacked, location, v0, v1, v2, v3); |
| } |
| ANGLE_CAPTURE(ProgramUniform4i, isCallValid, context, programPacked, location, v0, v1, v2, |
| v3); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform4iv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4iv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const GLint " |
| "*value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4iv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform4iv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform4iv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY |
| ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4ui", |
| "context = %d, GLuint program = %u, GLint location = %d, GLuint v0 = %u, GLuint v1 = %u, " |
| "GLuint v2 = %u, GLuint v3 = %u", |
| CID(context), program, location, v0, v1, v2, v3); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4ui(context, programPacked, location, v0, v1, v2, v3)); |
| if (isCallValid) |
| { |
| context->programUniform4ui(programPacked, location, v0, v1, v2, v3); |
| } |
| ANGLE_CAPTURE(ProgramUniform4ui, isCallValid, context, programPacked, location, v0, v1, v2, |
| v3); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniform4uiv(GLuint program, |
| GLint location, |
| GLsizei count, |
| const GLuint *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniform4uiv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, const " |
| "GLuint *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateProgramUniform4uiv(context, programPacked, location, count, value)); |
| if (isCallValid) |
| { |
| context->programUniform4uiv(programPacked, location, count, value); |
| } |
| ANGLE_CAPTURE(ProgramUniform4uiv, isCallValid, context, programPacked, location, count, |
| value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2dv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2dv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2fv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2fv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2x3dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2x3dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2x3dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2x3dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2x3dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2x3fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2x3fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2x3fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2x3fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2x4dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2x4dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2x4dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2x4dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2x4dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix2x4fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix2x4fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix2x4fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix2x4fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3dv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3dv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3fv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3fv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3x2dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3x2dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3x2dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3x2dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3x2dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3x2fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3x2fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3x2fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3x2fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3x4dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3x4dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3x4dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3x4dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3x4dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix3x4fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix3x4fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix3x4fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix3x4fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4dv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4dv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4fv(context, programPacked, location, count, |
| transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4fv, isCallValid, context, programPacked, location, count, |
| transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4x2dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4x2dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4x2dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4x2dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4x2dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4x2fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4x2fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4x2fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4x2fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4x3dv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLdouble *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4x3dv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLdouble *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4x3dv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4x3dv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4x3dv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ProgramUniformMatrix4x3fv(GLuint program, |
| GLint location, |
| GLsizei count, |
| GLboolean transpose, |
| const GLfloat *value) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glProgramUniformMatrix4x3fv", |
| "context = %d, GLuint program = %u, GLint location = %d, GLsizei count = %d, GLboolean " |
| "transpose = %s, const GLfloat *value = 0x%016" PRIxPTR "", |
| CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateProgramUniformMatrix4x3fv(context, programPacked, location, |
| count, transpose, value)); |
| if (isCallValid) |
| { |
| context->programUniformMatrix4x3fv(programPacked, location, count, transpose, value); |
| } |
| ANGLE_CAPTURE(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, location, |
| count, transpose, value); |
| } |
| } |
| |
| void GL_APIENTRY ReleaseShaderCompiler() |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glReleaseShaderCompiler", "context = %d", CID(context)); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || ValidateReleaseShaderCompiler(context)); |
| if (isCallValid) |
| { |
| context->releaseShaderCompiler(); |
| } |
| ANGLE_CAPTURE(ReleaseShaderCompiler, isCallValid, context); |
| } |
| } |
| |
| void GL_APIENTRY ScissorArrayv(GLuint first, GLsizei count, const GLint *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glScissorArrayv", |
| "context = %d, GLuint first = %u, GLsizei count = %d, const GLint *v = 0x%016" PRIxPTR "", |
| CID(context), first, count, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateScissorArrayv(context, first, count, v)); |
| if (isCallValid) |
| { |
| context->scissorArrayv(first, count, v); |
| } |
| ANGLE_CAPTURE(ScissorArrayv, isCallValid, context, first, count, v); |
| } |
| } |
| |
| void GL_APIENTRY |
| ScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glScissorIndexed", |
| "context = %d, GLuint index = %u, GLint left = %d, GLint bottom = %d, GLsizei width = " |
| "%d, GLsizei height = %d", |
| CID(context), index, left, bottom, width, height); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateScissorIndexed(context, index, left, bottom, width, height)); |
| if (isCallValid) |
| { |
| context->scissorIndexed(index, left, bottom, width, height); |
| } |
| ANGLE_CAPTURE(ScissorIndexed, isCallValid, context, index, left, bottom, width, height); |
| } |
| } |
| |
| void GL_APIENTRY ScissorIndexedv(GLuint index, const GLint *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glScissorIndexedv", |
| "context = %d, GLuint index = %u, const GLint *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateScissorIndexedv(context, index, v)); |
| if (isCallValid) |
| { |
| context->scissorIndexedv(index, v); |
| } |
| ANGLE_CAPTURE(ScissorIndexedv, isCallValid, context, index, v); |
| } |
| } |
| |
| void GL_APIENTRY ShaderBinary(GLsizei count, |
| const GLuint *shaders, |
| GLenum binaryformat, |
| const void *binary, |
| GLsizei length) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glShaderBinary", |
| "context = %d, GLsizei count = %d, const GLuint *shaders = 0x%016" PRIxPTR |
| ", GLenum binaryformat = %s, const void *binary = 0x%016" PRIxPTR ", GLsizei length = %d", |
| CID(context), count, (uintptr_t)shaders, |
| GLenumToString(GLenumGroup::DefaultGroup, binaryformat), (uintptr_t)binary, length); |
| |
| if (context) |
| { |
| const ShaderProgramID *shadersPacked = FromGL<const ShaderProgramID *>(shaders); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateShaderBinary(context, count, shadersPacked, binaryformat, binary, length)); |
| if (isCallValid) |
| { |
| context->shaderBinary(count, shadersPacked, binaryformat, binary, length); |
| } |
| ANGLE_CAPTURE(ShaderBinary, isCallValid, context, count, shadersPacked, binaryformat, |
| binary, length); |
| } |
| } |
| |
| void GL_APIENTRY UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glUseProgramStages", |
| "context = %d, GLuint pipeline = %u, GLbitfield stages = %s, GLuint program = %u", |
| CID(context), pipeline, |
| GLbitfieldToString(GLenumGroup::UseProgramStageMask, stages).c_str(), program); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateUseProgramStages(context, pipelinePacked, stages, programPacked)); |
| if (isCallValid) |
| { |
| context->useProgramStages(pipelinePacked, stages, programPacked); |
| } |
| ANGLE_CAPTURE(UseProgramStages, isCallValid, context, pipelinePacked, stages, |
| programPacked); |
| } |
| } |
| |
| void GL_APIENTRY ValidateProgramPipeline(GLuint pipeline) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glValidateProgramPipeline", "context = %d, GLuint pipeline = %u", CID(context), |
| pipeline); |
| |
| if (context) |
| { |
| ProgramPipelineID pipelinePacked = FromGL<ProgramPipelineID>(pipeline); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateValidateProgramPipeline(context, pipelinePacked)); |
| if (isCallValid) |
| { |
| context->validateProgramPipeline(pipelinePacked); |
| } |
| ANGLE_CAPTURE(ValidateProgramPipeline, isCallValid, context, pipelinePacked); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL1d(GLuint index, GLdouble x) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL1d", "context = %d, GLuint index = %u, GLdouble x = %f", CID(context), |
| index, x); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL1d(context, index, x)); |
| if (isCallValid) |
| { |
| context->vertexAttribL1d(index, x); |
| } |
| ANGLE_CAPTURE(VertexAttribL1d, isCallValid, context, index, x); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL1dv(GLuint index, const GLdouble *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL1dv", |
| "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL1dv(context, index, v)); |
| if (isCallValid) |
| { |
| context->vertexAttribL1dv(index, v); |
| } |
| ANGLE_CAPTURE(VertexAttribL1dv, isCallValid, context, index, v); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL2d(GLuint index, GLdouble x, GLdouble y) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL2d", "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f", |
| CID(context), index, x, y); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL2d(context, index, x, y)); |
| if (isCallValid) |
| { |
| context->vertexAttribL2d(index, x, y); |
| } |
| ANGLE_CAPTURE(VertexAttribL2d, isCallValid, context, index, x, y); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL2dv(GLuint index, const GLdouble *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL2dv", |
| "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL2dv(context, index, v)); |
| if (isCallValid) |
| { |
| context->vertexAttribL2dv(index, v); |
| } |
| ANGLE_CAPTURE(VertexAttribL2dv, isCallValid, context, index, v); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL3d", |
| "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f", |
| CID(context), index, x, y, z); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL3d(context, index, x, y, z)); |
| if (isCallValid) |
| { |
| context->vertexAttribL3d(index, x, y, z); |
| } |
| ANGLE_CAPTURE(VertexAttribL3d, isCallValid, context, index, x, y, z); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL3dv(GLuint index, const GLdouble *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL3dv", |
| "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL3dv(context, index, v)); |
| if (isCallValid) |
| { |
| context->vertexAttribL3dv(index, v); |
| } |
| ANGLE_CAPTURE(VertexAttribL3dv, isCallValid, context, index, v); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL4d", |
| "context = %d, GLuint index = %u, GLdouble x = %f, GLdouble y = %f, GLdouble z = %f, " |
| "GLdouble w = %f", |
| CID(context), index, x, y, z, w); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL4d(context, index, x, y, z, w)); |
| if (isCallValid) |
| { |
| context->vertexAttribL4d(index, x, y, z, w); |
| } |
| ANGLE_CAPTURE(VertexAttribL4d, isCallValid, context, index, x, y, z, w); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribL4dv(GLuint index, const GLdouble *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribL4dv", |
| "context = %d, GLuint index = %u, const GLdouble *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateVertexAttribL4dv(context, index, v)); |
| if (isCallValid) |
| { |
| context->vertexAttribL4dv(index, v); |
| } |
| ANGLE_CAPTURE(VertexAttribL4dv, isCallValid, context, index, v); |
| } |
| } |
| |
| void GL_APIENTRY |
| VertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribLPointer", |
| "context = %d, GLuint index = %u, GLint size = %d, GLenum type = %s, GLsizei stride = " |
| "%d, const void *pointer = 0x%016" PRIxPTR "", |
| CID(context), index, size, GLenumToString(GLenumGroup::VertexAttribPointerType, type), |
| stride, (uintptr_t)pointer); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateVertexAttribLPointer(context, index, size, type, stride, pointer)); |
| if (isCallValid) |
| { |
| context->vertexAttribLPointer(index, size, type, stride, pointer); |
| } |
| ANGLE_CAPTURE(VertexAttribLPointer, isCallValid, context, index, size, type, stride, |
| pointer); |
| } |
| } |
| |
| void GL_APIENTRY ViewportArrayv(GLuint first, GLsizei count, const GLfloat *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glViewportArrayv", |
| "context = %d, GLuint first = %u, GLsizei count = %d, const GLfloat *v = 0x%016" PRIxPTR |
| "", |
| CID(context), first, count, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateViewportArrayv(context, first, count, v)); |
| if (isCallValid) |
| { |
| context->viewportArrayv(first, count, v); |
| } |
| ANGLE_CAPTURE(ViewportArrayv, isCallValid, context, first, count, v); |
| } |
| } |
| |
| void GL_APIENTRY ViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glViewportIndexedf", |
| "context = %d, GLuint index = %u, GLfloat x = %f, GLfloat y = %f, GLfloat w = %f, " |
| "GLfloat h = %f", |
| CID(context), index, x, y, w, h); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateViewportIndexedf(context, index, x, y, w, h)); |
| if (isCallValid) |
| { |
| context->viewportIndexedf(index, x, y, w, h); |
| } |
| ANGLE_CAPTURE(ViewportIndexedf, isCallValid, context, index, x, y, w, h); |
| } |
| } |
| |
| void GL_APIENTRY ViewportIndexedfv(GLuint index, const GLfloat *v) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glViewportIndexedfv", |
| "context = %d, GLuint index = %u, const GLfloat *v = 0x%016" PRIxPTR "", CID(context), |
| index, (uintptr_t)v); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateViewportIndexedfv(context, index, v)); |
| if (isCallValid) |
| { |
| context->viewportIndexedfv(index, v); |
| } |
| ANGLE_CAPTURE(ViewportIndexedfv, isCallValid, context, index, v); |
| } |
| } |
| } // namespace gl |
