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