| // 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_gles_3_1_autogen.cpp: |
| // Defines the GLES 3.1 entry points. |
| |
| #include "libGLESv2/entry_points_gles_3_1_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/Context.inl.h" |
| #include "libANGLE/capture_gles_3_1_autogen.h" |
| #include "libANGLE/entry_points_utils.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationES31.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 BindImageTexture(GLuint unit, |
| GLuint texture, |
| GLint level, |
| GLboolean layered, |
| GLint layer, |
| GLenum access, |
| GLenum format) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glBindImageTexture", |
| "context = %d, GLuint unit = %u, GLuint texture = %u, GLint level = %d, GLboolean " |
| "layered = %s, GLint layer = %d, GLenum access = %s, GLenum format = %s", |
| CID(context), unit, texture, level, GLbooleanToString(layered), layer, |
| GLenumToString(GLenumGroup::BufferAccessARB, access), |
| GLenumToString(GLenumGroup::InternalFormat, format)); |
| |
| if (context) |
| { |
| TextureID texturePacked = FromGL<TextureID>(texture); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateBindImageTexture(context, unit, texturePacked, level, layered, |
| layer, access, format)); |
| if (isCallValid) |
| { |
| context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format); |
| } |
| ANGLE_CAPTURE(BindImageTexture, isCallValid, context, unit, texturePacked, level, layered, |
| layer, access, format); |
| } |
| } |
| |
| 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 BindVertexBuffer(GLuint bindingindex, |
| GLuint buffer, |
| GLintptr offset, |
| GLsizei stride) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glBindVertexBuffer", |
| "context = %d, GLuint bindingindex = %u, GLuint buffer = %u, GLintptr offset = %llu, " |
| "GLsizei stride = %d", |
| CID(context), bindingindex, buffer, static_cast<unsigned long long>(offset), stride); |
| |
| if (context) |
| { |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateBindVertexBuffer(context, bindingindex, bufferPacked, offset, stride)); |
| if (isCallValid) |
| { |
| context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride); |
| } |
| ANGLE_CAPTURE(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset, |
| stride); |
| } |
| } |
| |
| 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 DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDispatchCompute", |
| "context = %d, GLuint num_groups_x = %u, GLuint num_groups_y = %u, GLuint num_groups_z = " |
| "%u", |
| CID(context), num_groups_x, num_groups_y, num_groups_z); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z)); |
| if (isCallValid) |
| { |
| context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z); |
| } |
| ANGLE_CAPTURE(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y, |
| num_groups_z); |
| } |
| } |
| |
| void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glDispatchComputeIndirect", "context = %d, GLintptr indirect = %llu", CID(context), |
| static_cast<unsigned long long>(indirect)); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect)); |
| if (isCallValid) |
| { |
| context->dispatchComputeIndirect(indirect); |
| } |
| ANGLE_CAPTURE(DispatchComputeIndirect, isCallValid, context, indirect); |
| } |
| } |
| |
| 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 FramebufferParameteri(GLenum target, GLenum pname, GLint param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glFramebufferParameteri", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLint param = %d", CID(context), |
| GLenumToString(GLenumGroup::FramebufferTarget, target), |
| GLenumToString(GLenumGroup::FramebufferParameterName, pname), param); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateFramebufferParameteri(context, target, pname, param)); |
| if (isCallValid) |
| { |
| context->framebufferParameteri(target, pname, param); |
| } |
| ANGLE_CAPTURE(FramebufferParameteri, isCallValid, context, target, pname, param); |
| } |
| } |
| |
| 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 GetBooleani_v(GLenum target, GLuint index, GLboolean *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT( |
| "glGetBooleani_v", |
| "context = %d, GLenum target = %s, GLuint index = %u, GLboolean *data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::BufferTargetARB, target), index, (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetBooleani_v(context, target, index, data)); |
| if (isCallValid) |
| { |
| context->getBooleani_v(target, index, data); |
| } |
| ANGLE_CAPTURE(GetBooleani_v, isCallValid, context, target, index, data); |
| } |
| } |
| |
| void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetFramebufferParameteriv", |
| "context = %d, GLenum target = %s, GLenum pname = %s, GLint *params = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), |
| GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetFramebufferParameteriv(context, target, pname, params)); |
| if (isCallValid) |
| { |
| context->getFramebufferParameteriv(target, pname, params); |
| } |
| ANGLE_CAPTURE(GetFramebufferParameteriv, isCallValid, context, target, pname, params); |
| } |
| } |
| |
| void GL_APIENTRY GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetMultisamplefv", |
| "context = %d, GLenum pname = %s, GLuint index = %u, GLfloat *val = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, pname), index, (uintptr_t)val); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetMultisamplefv(context, pname, index, val)); |
| if (isCallValid) |
| { |
| context->getMultisamplefv(pname, index, val); |
| } |
| ANGLE_CAPTURE(GetMultisamplefv, isCallValid, context, pname, index, val); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramInterfaceiv(GLuint program, |
| GLenum programInterface, |
| GLenum pname, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramInterfaceiv", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, GLenum pname = %s, " |
| "GLint *params = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetProgramInterfaceiv(context, programPacked, programInterface, |
| pname, params)); |
| if (isCallValid) |
| { |
| context->getProgramInterfaceiv(programPacked, programInterface, pname, params); |
| } |
| ANGLE_CAPTURE(GetProgramInterfaceiv, isCallValid, context, programPacked, programInterface, |
| pname, params); |
| } |
| } |
| |
| 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); |
| } |
| } |
| |
| GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program, |
| GLenum programInterface, |
| const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramResourceIndex", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = " |
| "0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| (uintptr_t)name); |
| |
| GLuint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceIndex(context, programPacked, programInterface, name)); |
| if (isCallValid) |
| { |
| returnValue = context->getProgramResourceIndex(programPacked, programInterface, name); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>(); |
| } |
| ANGLE_CAPTURE(GetProgramResourceIndex, isCallValid, context, programPacked, |
| programInterface, name, returnValue); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>(); |
| } |
| return returnValue; |
| } |
| |
| GLint GL_APIENTRY GetProgramResourceLocation(GLuint program, |
| GLenum programInterface, |
| const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramResourceLocation", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, const GLchar *name = " |
| "0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| (uintptr_t)name); |
| |
| GLint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceLocation(context, programPacked, programInterface, name)); |
| if (isCallValid) |
| { |
| returnValue = |
| context->getProgramResourceLocation(programPacked, programInterface, name); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>(); |
| } |
| ANGLE_CAPTURE(GetProgramResourceLocation, isCallValid, context, programPacked, |
| programInterface, name, returnValue); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY GetProgramResourceName(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramResourceName", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, " |
| "GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR ", GLchar *name = 0x%016" PRIxPTR |
| "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| 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() || |
| ValidateGetProgramResourceName(context, programPacked, programInterface, |
| index, bufSize, length, name)); |
| if (isCallValid) |
| { |
| context->getProgramResourceName(programPacked, programInterface, index, bufSize, length, |
| name); |
| } |
| ANGLE_CAPTURE(GetProgramResourceName, isCallValid, context, programPacked, programInterface, |
| index, bufSize, length, name); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramResourceiv(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei propCount, |
| const GLenum *props, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetProgramResourceiv", |
| "context = %d, GLuint program = %u, GLenum programInterface = %s, GLuint index = %u, " |
| "GLsizei propCount = %d, const GLenum *props = 0x%016" PRIxPTR |
| ", GLsizei bufSize = %d, GLsizei *length = 0x%016" PRIxPTR |
| ", GLint *params = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceiv(context, programPacked, programInterface, index, |
| propCount, props, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getProgramResourceiv(programPacked, programInterface, index, propCount, props, |
| bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetProgramResourceiv, isCallValid, context, programPacked, programInterface, |
| index, propCount, props, bufSize, length, params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexLevelParameterfv", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLfloat *params " |
| "= 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, |
| GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetTexLevelParameterfv(context, targetPacked, level, pname, params)); |
| if (isCallValid) |
| { |
| context->getTexLevelParameterfv(targetPacked, level, pname, params); |
| } |
| ANGLE_CAPTURE(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname, |
| params); |
| } |
| } |
| |
| void GL_APIENTRY GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glGetTexLevelParameteriv", |
| "context = %d, GLenum target = %s, GLint level = %d, GLenum pname = %s, GLint *params = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), level, |
| GLenumToString(GLenumGroup::GetTextureParameter, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| TextureTarget targetPacked = FromGL<TextureTarget>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetTexLevelParameteriv(context, targetPacked, level, pname, params)); |
| if (isCallValid) |
| { |
| context->getTexLevelParameteriv(targetPacked, level, pname, params); |
| } |
| ANGLE_CAPTURE(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname, |
| params); |
| } |
| } |
| |
| 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 MemoryBarrier(GLbitfield barriers) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMemoryBarrier", "context = %d, GLbitfield barriers = %s", CID(context), |
| GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str()); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || ValidateMemoryBarrier(context, barriers)); |
| if (isCallValid) |
| { |
| context->memoryBarrier(barriers); |
| } |
| ANGLE_CAPTURE(MemoryBarrier, isCallValid, context, barriers); |
| } |
| } |
| |
| void GL_APIENTRY MemoryBarrierByRegion(GLbitfield barriers) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glMemoryBarrierByRegion", "context = %d, GLbitfield barriers = %s", CID(context), |
| GLbitfieldToString(GLenumGroup::MemoryBarrierMask, barriers).c_str()); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateMemoryBarrierByRegion(context, barriers)); |
| if (isCallValid) |
| { |
| context->memoryBarrierByRegion(barriers); |
| } |
| ANGLE_CAPTURE(MemoryBarrierByRegion, isCallValid, context, barriers); |
| } |
| } |
| |
| 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 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 |
| 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 |
| 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 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 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 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 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 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 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 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 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 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 SampleMaski(GLuint maskNumber, GLbitfield mask) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glSampleMaski", "context = %d, GLuint maskNumber = %u, GLbitfield mask = %s", |
| CID(context), maskNumber, GLbitfieldToString(GLenumGroup::DefaultGroup, mask).c_str()); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateSampleMaski(context, maskNumber, mask)); |
| if (isCallValid) |
| { |
| context->sampleMaski(maskNumber, mask); |
| } |
| ANGLE_CAPTURE(SampleMaski, isCallValid, context, maskNumber, mask); |
| } |
| } |
| |
| void GL_APIENTRY TexStorage2DMultisample(GLenum target, |
| GLsizei samples, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLboolean fixedsamplelocations) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glTexStorage2DMultisample", |
| "context = %d, GLenum target = %s, GLsizei samples = %d, GLenum internalformat = %s, " |
| "GLsizei width = %d, GLsizei height = %d, GLboolean fixedsamplelocations = %s", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, |
| GLbooleanToString(fixedsamplelocations)); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width, |
| height, fixedsamplelocations)); |
| if (isCallValid) |
| { |
| context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height, |
| fixedsamplelocations); |
| } |
| ANGLE_CAPTURE(TexStorage2DMultisample, isCallValid, context, targetPacked, samples, |
| internalformat, width, height, fixedsamplelocations); |
| } |
| } |
| |
| 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 VertexAttribBinding(GLuint attribindex, GLuint bindingindex) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribBinding", |
| "context = %d, GLuint attribindex = %u, GLuint bindingindex = %u", CID(context), |
| attribindex, bindingindex); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexAttribBinding(context, attribindex, bindingindex)); |
| if (isCallValid) |
| { |
| context->vertexAttribBinding(attribindex, bindingindex); |
| } |
| ANGLE_CAPTURE(VertexAttribBinding, isCallValid, context, attribindex, bindingindex); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribFormat(GLuint attribindex, |
| GLint size, |
| GLenum type, |
| GLboolean normalized, |
| GLuint relativeoffset) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribFormat", |
| "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLboolean " |
| "normalized = %s, GLuint relativeoffset = %u", |
| CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), |
| GLbooleanToString(normalized), relativeoffset); |
| |
| if (context) |
| { |
| VertexAttribType typePacked = FromGL<VertexAttribType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexAttribFormat(context, attribindex, size, typePacked, |
| normalized, relativeoffset)); |
| if (isCallValid) |
| { |
| context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset); |
| } |
| ANGLE_CAPTURE(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked, |
| normalized, relativeoffset); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribIFormat(GLuint attribindex, |
| GLint size, |
| GLenum type, |
| GLuint relativeoffset) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexAttribIFormat", |
| "context = %d, GLuint attribindex = %u, GLint size = %d, GLenum type = %s, GLuint " |
| "relativeoffset = %u", |
| CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), |
| relativeoffset); |
| |
| if (context) |
| { |
| VertexAttribType typePacked = FromGL<VertexAttribType>(type); |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset)); |
| if (isCallValid) |
| { |
| context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset); |
| } |
| ANGLE_CAPTURE(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked, |
| relativeoffset); |
| } |
| } |
| |
| void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT("glVertexBindingDivisor", "context = %d, GLuint bindingindex = %u, GLuint divisor = %u", |
| CID(context), bindingindex, divisor); |
| |
| if (context) |
| { |
| std::unique_lock<std::mutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexBindingDivisor(context, bindingindex, divisor)); |
| if (isCallValid) |
| { |
| context->vertexBindingDivisor(bindingindex, divisor); |
| } |
| ANGLE_CAPTURE(VertexBindingDivisor, isCallValid, context, bindingindex, divisor); |
| } |
| } |
| } // namespace gl |
