| // 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_gl_4_3_autogen.cpp: |
| // Defines the GL 4.3 entry points. |
| |
| #include "libGL/entry_points_gl_4_3_autogen.h" |
| |
| #include "libANGLE/Context.h" |
| #include "libANGLE/Context.inl.h" |
| #include "libANGLE/entry_points_utils.h" |
| #include "libANGLE/gl_enum_utils.h" |
| #include "libANGLE/validationEGL.h" |
| #include "libANGLE/validationES.h" |
| #include "libANGLE/validationES1.h" |
| #include "libANGLE/validationES2.h" |
| #include "libANGLE/validationES3.h" |
| #include "libANGLE/validationES31.h" |
| #include "libANGLE/validationES32.h" |
| #include "libANGLE/validationESEXT.h" |
| #include "libANGLE/validationGL43_autogen.h" |
| #include "libGLESv2/global_state.h" |
| |
| namespace gl |
| { |
| void GL_APIENTRY BindVertexBuffer(GLuint bindingindex, |
| GLuint buffer, |
| GLintptr offset, |
| GLsizei stride) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::BindVertexBuffer, "glBindVertexBuffer", |
| "context = %d, bindingindex = %u, buffer = %u, offset = %llu, stride = %d", CID(context), |
| bindingindex, buffer, static_cast<unsigned long long>(offset), stride); |
| |
| if (context) |
| { |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateBindVertexBuffer(context, bindingindex, bufferPacked, offset, stride)); |
| if (isCallValid) |
| { |
| context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride); |
| } |
| ANGLE_CAPTURE(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset, |
| stride); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY |
| ClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::ClearBufferData, "glClearBufferData", |
| "context = %d, target = %s, internalformat = %s, format = %s, type = %s, data = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::BufferStorageTarget, target), |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), |
| GLenumToString(GLenumGroup::PixelFormat, format), |
| GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateClearBufferData(context, target, internalformat, format, type, data)); |
| if (isCallValid) |
| { |
| context->clearBufferData(target, internalformat, format, type, data); |
| } |
| ANGLE_CAPTURE(ClearBufferData, isCallValid, context, target, internalformat, format, type, |
| data); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY ClearBufferSubData(GLenum target, |
| GLenum internalformat, |
| GLintptr offset, |
| GLsizeiptr size, |
| GLenum format, |
| GLenum type, |
| const void *data) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::ClearBufferSubData, "glClearBufferSubData", |
| "context = %d, target = %s, internalformat = %s, offset = %llu, size = %llu, format = " |
| "%s, type = %s, data = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), |
| static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size), |
| GLenumToString(GLenumGroup::PixelFormat, format), |
| GLenumToString(GLenumGroup::PixelType, type), (uintptr_t)data); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateClearBufferSubData(context, target, internalformat, offset, |
| size, format, type, data)); |
| if (isCallValid) |
| { |
| context->clearBufferSubData(target, internalformat, offset, size, format, type, data); |
| } |
| ANGLE_CAPTURE(ClearBufferSubData, isCallValid, context, target, internalformat, offset, |
| size, format, type, data); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY CopyImageSubData(GLuint srcName, |
| GLenum srcTarget, |
| GLint srcLevel, |
| GLint srcX, |
| GLint srcY, |
| GLint srcZ, |
| GLuint dstName, |
| GLenum dstTarget, |
| GLint dstLevel, |
| GLint dstX, |
| GLint dstY, |
| GLint dstZ, |
| GLsizei srcWidth, |
| GLsizei srcHeight, |
| GLsizei srcDepth) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::CopyImageSubData, "glCopyImageSubData", |
| "context = %d, srcName = %u, srcTarget = %s, srcLevel = %d, srcX = %d, srcY = %d, srcZ = " |
| "%d, dstName = %u, dstTarget = %s, dstLevel = %d, dstX = %d, dstY = %d, dstZ = %d, " |
| "srcWidth = %d, srcHeight = %d, srcDepth = %d", |
| CID(context), srcName, GLenumToString(GLenumGroup::CopyBufferSubDataTarget, srcTarget), |
| srcLevel, srcX, srcY, srcZ, dstName, |
| GLenumToString(GLenumGroup::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, |
| dstZ, srcWidth, srcHeight, srcDepth); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateCopyImageSubData(context, srcName, srcTarget, srcLevel, srcX, |
| srcY, srcZ, dstName, dstTarget, dstLevel, dstX, |
| dstY, dstZ, srcWidth, srcHeight, srcDepth)); |
| if (isCallValid) |
| { |
| context->copyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, |
| dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, |
| srcDepth); |
| } |
| ANGLE_CAPTURE(CopyImageSubData, isCallValid, context, srcName, srcTarget, srcLevel, srcX, |
| srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, |
| srcHeight, srcDepth); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DebugMessageCallback(GLDEBUGPROC callback, const void *userParam) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DebugMessageCallback, "glDebugMessageCallback", |
| "context = %d, callback = 0x%016" PRIxPTR ", userParam = 0x%016" PRIxPTR "", CID(context), |
| (uintptr_t)callback, (uintptr_t)userParam); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateDebugMessageCallback(context, callback, userParam)); |
| if (isCallValid) |
| { |
| context->debugMessageCallback(callback, userParam); |
| } |
| ANGLE_CAPTURE(DebugMessageCallback, isCallValid, context, callback, userParam); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DebugMessageControl(GLenum source, |
| GLenum type, |
| GLenum severity, |
| GLsizei count, |
| const GLuint *ids, |
| GLboolean enabled) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DebugMessageControl, "glDebugMessageControl", |
| "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR |
| ", enabled = %s", |
| CID(context), GLenumToString(GLenumGroup::DebugSource, source), |
| GLenumToString(GLenumGroup::DebugType, type), |
| GLenumToString(GLenumGroup::DebugSeverity, severity), count, (uintptr_t)ids, |
| GLbooleanToString(enabled)); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDebugMessageControl(context, source, type, severity, count, ids, enabled)); |
| if (isCallValid) |
| { |
| context->debugMessageControl(source, type, severity, count, ids, enabled); |
| } |
| ANGLE_CAPTURE(DebugMessageControl, isCallValid, context, source, type, severity, count, ids, |
| enabled); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DebugMessageInsert(GLenum source, |
| GLenum type, |
| GLuint id, |
| GLenum severity, |
| GLsizei length, |
| const GLchar *buf) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DebugMessageInsert, "glDebugMessageInsert", |
| "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DebugSource, source), |
| GLenumToString(GLenumGroup::DebugType, type), id, |
| GLenumToString(GLenumGroup::DebugSeverity, severity), length, (uintptr_t)buf); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDebugMessageInsert(context, source, type, id, severity, length, buf)); |
| if (isCallValid) |
| { |
| context->debugMessageInsert(source, type, id, severity, length, buf); |
| } |
| ANGLE_CAPTURE(DebugMessageInsert, isCallValid, context, source, type, id, severity, length, |
| buf); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DispatchCompute, "glDispatchCompute", |
| "context = %d, num_groups_x = %u, num_groups_y = %u, num_groups_z = %u", CID(context), |
| num_groups_x, num_groups_y, num_groups_z); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateDispatchCompute(context, num_groups_x, num_groups_y, num_groups_z)); |
| if (isCallValid) |
| { |
| context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z); |
| } |
| ANGLE_CAPTURE(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y, |
| num_groups_z); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY DispatchComputeIndirect(GLintptr indirect) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::DispatchComputeIndirect, "glDispatchComputeIndirect", |
| "context = %d, indirect = %llu", CID(context), static_cast<unsigned long long>(indirect)); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateDispatchComputeIndirect(context, indirect)); |
| if (isCallValid) |
| { |
| context->dispatchComputeIndirect(indirect); |
| } |
| ANGLE_CAPTURE(DispatchComputeIndirect, isCallValid, context, indirect); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY FramebufferParameteri(GLenum target, GLenum pname, GLint param) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::FramebufferParameteri, "glFramebufferParameteri", |
| "context = %d, target = %s, pname = %s, param = %d", CID(context), |
| GLenumToString(GLenumGroup::FramebufferTarget, target), |
| GLenumToString(GLenumGroup::FramebufferParameterName, pname), param); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateFramebufferParameteri(context, target, pname, param)); |
| if (isCallValid) |
| { |
| context->framebufferParameteri(target, pname, param); |
| } |
| ANGLE_CAPTURE(FramebufferParameteri, isCallValid, context, target, pname, param); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| GLuint GL_APIENTRY GetDebugMessageLog(GLuint count, |
| GLsizei bufSize, |
| GLenum *sources, |
| GLenum *types, |
| GLuint *ids, |
| GLenum *severities, |
| GLsizei *lengths, |
| GLchar *messageLog) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetDebugMessageLog, "glGetDebugMessageLog", |
| "context = %d, count = %u, bufSize = %d, sources = 0x%016" PRIxPTR |
| ", types = 0x%016" PRIxPTR ", ids = 0x%016" PRIxPTR ", severities = 0x%016" PRIxPTR |
| ", lengths = 0x%016" PRIxPTR ", messageLog = 0x%016" PRIxPTR "", |
| CID(context), count, bufSize, (uintptr_t)sources, (uintptr_t)types, (uintptr_t)ids, |
| (uintptr_t)severities, (uintptr_t)lengths, (uintptr_t)messageLog); |
| |
| GLuint returnValue; |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetDebugMessageLog(context, count, bufSize, sources, types, ids, |
| severities, lengths, messageLog)); |
| if (isCallValid) |
| { |
| returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids, |
| severities, lengths, messageLog); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>(); |
| } |
| ANGLE_CAPTURE(GetDebugMessageLog, isCallValid, context, count, bufSize, sources, types, ids, |
| severities, lengths, messageLog, returnValue); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| returnValue = GetDefaultReturnValue<EntryPoint::GetDebugMessageLog, GLuint>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetFramebufferParameteriv, "glGetFramebufferParameteriv", |
| "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), |
| GLenumToString(GLenumGroup::FramebufferTarget, target), |
| GLenumToString(GLenumGroup::FramebufferAttachmentParameterName, pname), |
| (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetFramebufferParameteriv(context, target, pname, params)); |
| if (isCallValid) |
| { |
| context->getFramebufferParameteriv(target, pname, params); |
| } |
| ANGLE_CAPTURE(GetFramebufferParameteriv, isCallValid, context, target, pname, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetInternalformati64v(GLenum target, |
| GLenum internalformat, |
| GLenum pname, |
| GLsizei bufSize, |
| GLint64 *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetInternalformati64v, "glGetInternalformati64v", |
| "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, params = " |
| "0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), |
| GLenumToString(GLenumGroup::InternalFormatPName, pname), bufSize, (uintptr_t)params); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetInternalformati64v(context, target, internalformat, pname, |
| bufSize, params)); |
| if (isCallValid) |
| { |
| context->getInternalformati64v(target, internalformat, pname, bufSize, params); |
| } |
| ANGLE_CAPTURE(GetInternalformati64v, isCallValid, context, target, internalformat, pname, |
| bufSize, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY |
| GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetObjectLabel, "glGetObjectLabel", |
| "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR |
| ", label = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, identifier), name, bufSize, |
| (uintptr_t)length, (uintptr_t)label); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetObjectLabel(context, identifier, name, bufSize, length, label)); |
| if (isCallValid) |
| { |
| context->getObjectLabel(identifier, name, bufSize, length, label); |
| } |
| ANGLE_CAPTURE(GetObjectLabel, isCallValid, context, identifier, name, bufSize, length, |
| label); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetObjectPtrLabel, "glGetObjectPtrLabel", |
| "context = %d, ptr = 0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR |
| ", label = 0x%016" PRIxPTR "", |
| CID(context), (uintptr_t)ptr, bufSize, (uintptr_t)length, (uintptr_t)label); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetObjectPtrLabel(context, ptr, bufSize, length, label)); |
| if (isCallValid) |
| { |
| context->getObjectPtrLabel(ptr, bufSize, length, label); |
| } |
| ANGLE_CAPTURE(GetObjectPtrLabel, isCallValid, context, ptr, bufSize, length, label); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramInterfaceiv(GLuint program, |
| GLenum programInterface, |
| GLenum pname, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramInterfaceiv, "glGetProgramInterfaceiv", |
| "context = %d, program = %u, programInterface = %s, pname = %s, params = 0x%016" PRIxPTR |
| "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| GLenumToString(GLenumGroup::ProgramInterfacePName, pname), (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetProgramInterfaceiv(context, programPacked, programInterface, |
| pname, params)); |
| if (isCallValid) |
| { |
| context->getProgramInterfaceiv(programPacked, programInterface, pname, params); |
| } |
| ANGLE_CAPTURE(GetProgramInterfaceiv, isCallValid, context, programPacked, programInterface, |
| pname, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| GLuint GL_APIENTRY GetProgramResourceIndex(GLuint program, |
| GLenum programInterface, |
| const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramResourceIndex, "glGetProgramResourceIndex", |
| "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| (uintptr_t)name); |
| |
| GLuint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceIndex(context, programPacked, programInterface, name)); |
| if (isCallValid) |
| { |
| returnValue = context->getProgramResourceIndex(programPacked, programInterface, name); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>(); |
| } |
| ANGLE_CAPTURE(GetProgramResourceIndex, isCallValid, context, programPacked, |
| programInterface, name, returnValue); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceIndex, GLuint>(); |
| } |
| return returnValue; |
| } |
| |
| GLint GL_APIENTRY GetProgramResourceLocation(GLuint program, |
| GLenum programInterface, |
| const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramResourceLocation, "glGetProgramResourceLocation", |
| "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| (uintptr_t)name); |
| |
| GLint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceLocation(context, programPacked, programInterface, name)); |
| if (isCallValid) |
| { |
| returnValue = |
| context->getProgramResourceLocation(programPacked, programInterface, name); |
| } |
| else |
| { |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>(); |
| } |
| ANGLE_CAPTURE(GetProgramResourceLocation, isCallValid, context, programPacked, |
| programInterface, name, returnValue); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocation, GLint>(); |
| } |
| return returnValue; |
| } |
| |
| GLint GL_APIENTRY GetProgramResourceLocationIndex(GLuint program, |
| GLenum programInterface, |
| const GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramResourceLocationIndex, |
| "glGetProgramResourceLocationIndex", |
| "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| (uintptr_t)name); |
| |
| GLint returnValue; |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateGetProgramResourceLocationIndex( |
| context, programPacked, programInterface, name)); |
| if (isCallValid) |
| { |
| returnValue = |
| context->getProgramResourceLocationIndex(programPacked, programInterface, name); |
| } |
| else |
| { |
| returnValue = |
| GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndex, GLint>(); |
| } |
| ANGLE_CAPTURE(GetProgramResourceLocationIndex, isCallValid, context, programPacked, |
| programInterface, name, returnValue); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| returnValue = GetDefaultReturnValue<EntryPoint::GetProgramResourceLocationIndex, GLint>(); |
| } |
| return returnValue; |
| } |
| |
| void GL_APIENTRY GetProgramResourceName(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLchar *name) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramResourceName, "glGetProgramResourceName", |
| "context = %d, program = %u, programInterface = %s, index = %u, bufSize = %d, length = " |
| "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| index, bufSize, (uintptr_t)length, (uintptr_t)name); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateGetProgramResourceName(context, programPacked, programInterface, |
| index, bufSize, length, name)); |
| if (isCallValid) |
| { |
| context->getProgramResourceName(programPacked, programInterface, index, bufSize, length, |
| name); |
| } |
| ANGLE_CAPTURE(GetProgramResourceName, isCallValid, context, programPacked, programInterface, |
| index, bufSize, length, name); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY GetProgramResourceiv(GLuint program, |
| GLenum programInterface, |
| GLuint index, |
| GLsizei propCount, |
| const GLenum *props, |
| GLsizei bufSize, |
| GLsizei *length, |
| GLint *params) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::GetProgramResourceiv, "glGetProgramResourceiv", |
| "context = %d, program = %u, programInterface = %s, index = %u, propCount = %d, props = " |
| "0x%016" PRIxPTR ", bufSize = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", |
| CID(context), program, GLenumToString(GLenumGroup::ProgramInterface, programInterface), |
| index, propCount, (uintptr_t)props, bufSize, (uintptr_t)length, (uintptr_t)params); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateGetProgramResourceiv(context, programPacked, programInterface, index, |
| propCount, props, bufSize, length, params)); |
| if (isCallValid) |
| { |
| context->getProgramResourceiv(programPacked, programInterface, index, propCount, props, |
| bufSize, length, params); |
| } |
| ANGLE_CAPTURE(GetProgramResourceiv, isCallValid, context, programPacked, programInterface, |
| index, propCount, props, bufSize, length, params); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateBufferData(GLuint buffer) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateBufferData, "glInvalidateBufferData", |
| "context = %d, buffer = %u", CID(context), buffer); |
| |
| if (context) |
| { |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateInvalidateBufferData(context, bufferPacked)); |
| if (isCallValid) |
| { |
| context->invalidateBufferData(bufferPacked); |
| } |
| ANGLE_CAPTURE(InvalidateBufferData, isCallValid, context, bufferPacked); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateBufferSubData, "glInvalidateBufferSubData", |
| "context = %d, buffer = %u, offset = %llu, length = %llu", CID(context), buffer, |
| static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length)); |
| |
| if (context) |
| { |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateInvalidateBufferSubData(context, bufferPacked, offset, length)); |
| if (isCallValid) |
| { |
| context->invalidateBufferSubData(bufferPacked, offset, length); |
| } |
| ANGLE_CAPTURE(InvalidateBufferSubData, isCallValid, context, bufferPacked, offset, length); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateFramebuffer(GLenum target, |
| GLsizei numAttachments, |
| const GLenum *attachments) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateFramebuffer, "glInvalidateFramebuffer", |
| "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::FramebufferTarget, target), numAttachments, |
| (uintptr_t)attachments); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateInvalidateFramebuffer(context, target, numAttachments, attachments)); |
| if (isCallValid) |
| { |
| context->invalidateFramebuffer(target, numAttachments, attachments); |
| } |
| ANGLE_CAPTURE(InvalidateFramebuffer, isCallValid, context, target, numAttachments, |
| attachments); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateSubFramebuffer(GLenum target, |
| GLsizei numAttachments, |
| const GLenum *attachments, |
| GLint x, |
| GLint y, |
| GLsizei width, |
| GLsizei height) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateSubFramebuffer, "glInvalidateSubFramebuffer", |
| "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR |
| ", x = %d, y = %d, width = %d, height = %d", |
| CID(context), GLenumToString(GLenumGroup::DefaultGroup, target), numAttachments, |
| (uintptr_t)attachments, x, y, width, height); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateInvalidateSubFramebuffer(context, target, numAttachments, |
| attachments, x, y, width, height)); |
| if (isCallValid) |
| { |
| context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, |
| height); |
| } |
| ANGLE_CAPTURE(InvalidateSubFramebuffer, isCallValid, context, target, numAttachments, |
| attachments, x, y, width, height); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateTexImage(GLuint texture, GLint level) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateTexImage, "glInvalidateTexImage", |
| "context = %d, texture = %u, level = %d", CID(context), texture, level); |
| |
| if (context) |
| { |
| TextureID texturePacked = FromGL<TextureID>(texture); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateInvalidateTexImage(context, texturePacked, level)); |
| if (isCallValid) |
| { |
| context->invalidateTexImage(texturePacked, level); |
| } |
| ANGLE_CAPTURE(InvalidateTexImage, isCallValid, context, texturePacked, level); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY InvalidateTexSubImage(GLuint texture, |
| GLint level, |
| GLint xoffset, |
| GLint yoffset, |
| GLint zoffset, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::InvalidateTexSubImage, "glInvalidateTexSubImage", |
| "context = %d, texture = %u, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " |
| "= %d, height = %d, depth = %d", |
| CID(context), texture, level, xoffset, yoffset, zoffset, width, height, depth); |
| |
| if (context) |
| { |
| TextureID texturePacked = FromGL<TextureID>(texture); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateInvalidateTexSubImage(context, texturePacked, level, xoffset, |
| yoffset, zoffset, width, height, depth)); |
| if (isCallValid) |
| { |
| context->invalidateTexSubImage(texturePacked, level, xoffset, yoffset, zoffset, width, |
| height, depth); |
| } |
| ANGLE_CAPTURE(InvalidateTexSubImage, isCallValid, context, texturePacked, level, xoffset, |
| yoffset, zoffset, width, height, depth); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawArraysIndirect(GLenum mode, |
| const void *indirect, |
| GLsizei drawcount, |
| GLsizei stride) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::MultiDrawArraysIndirect, "glMultiDrawArraysIndirect", |
| "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), (uintptr_t)indirect, |
| drawcount, stride); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateMultiDrawArraysIndirect(context, mode, indirect, drawcount, stride)); |
| if (isCallValid) |
| { |
| context->multiDrawArraysIndirect(mode, indirect, drawcount, stride); |
| } |
| ANGLE_CAPTURE(MultiDrawArraysIndirect, isCallValid, context, mode, indirect, drawcount, |
| stride); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY MultiDrawElementsIndirect(GLenum mode, |
| GLenum type, |
| const void *indirect, |
| GLsizei drawcount, |
| GLsizei stride) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::MultiDrawElementsIndirect, "glMultiDrawElementsIndirect", |
| "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR |
| ", drawcount = %d, stride = %d", |
| CID(context), GLenumToString(GLenumGroup::PrimitiveType, mode), |
| GLenumToString(GLenumGroup::DrawElementsType, type), (uintptr_t)indirect, drawcount, |
| stride); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateMultiDrawElementsIndirect(context, mode, type, indirect, drawcount, stride)); |
| if (isCallValid) |
| { |
| context->multiDrawElementsIndirect(mode, type, indirect, drawcount, stride); |
| } |
| ANGLE_CAPTURE(MultiDrawElementsIndirect, isCallValid, context, mode, type, indirect, |
| drawcount, stride); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::ObjectLabel, "glObjectLabel", |
| "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::ObjectIdentifier, identifier), name, length, |
| (uintptr_t)label); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateObjectLabel(context, identifier, name, length, label)); |
| if (isCallValid) |
| { |
| context->objectLabel(identifier, name, length, label); |
| } |
| ANGLE_CAPTURE(ObjectLabel, isCallValid, context, identifier, name, length, label); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY ObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::ObjectPtrLabel, "glObjectPtrLabel", |
| "context = %d, ptr = 0x%016" PRIxPTR ", length = %d, label = 0x%016" PRIxPTR "", |
| CID(context), (uintptr_t)ptr, length, (uintptr_t)label); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || ValidateObjectPtrLabel(context, ptr, length, label)); |
| if (isCallValid) |
| { |
| context->objectPtrLabel(ptr, length, label); |
| } |
| ANGLE_CAPTURE(ObjectPtrLabel, isCallValid, context, ptr, length, label); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY PopDebugGroup() |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::PopDebugGroup, "glPopDebugGroup", "context = %d", CID(context)); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || ValidatePopDebugGroup(context)); |
| if (isCallValid) |
| { |
| context->popDebugGroup(); |
| } |
| ANGLE_CAPTURE(PopDebugGroup, isCallValid, context); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::PushDebugGroup, "glPushDebugGroup", |
| "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "", |
| CID(context), GLenumToString(GLenumGroup::DebugSource, source), id, length, |
| (uintptr_t)message); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidatePushDebugGroup(context, source, id, length, message)); |
| if (isCallValid) |
| { |
| context->pushDebugGroup(source, id, length, message); |
| } |
| ANGLE_CAPTURE(PushDebugGroup, isCallValid, context, source, id, length, message); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY ShaderStorageBlockBinding(GLuint program, |
| GLuint storageBlockIndex, |
| GLuint storageBlockBinding) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::ShaderStorageBlockBinding, "glShaderStorageBlockBinding", |
| "context = %d, program = %u, storageBlockIndex = %u, storageBlockBinding = %u", |
| CID(context), program, storageBlockIndex, storageBlockBinding); |
| |
| if (context) |
| { |
| ShaderProgramID programPacked = FromGL<ShaderProgramID>(program); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateShaderStorageBlockBinding( |
| context, programPacked, storageBlockIndex, storageBlockBinding)); |
| if (isCallValid) |
| { |
| context->shaderStorageBlockBinding(programPacked, storageBlockIndex, |
| storageBlockBinding); |
| } |
| ANGLE_CAPTURE(ShaderStorageBlockBinding, isCallValid, context, programPacked, |
| storageBlockIndex, storageBlockBinding); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY TexBufferRange(GLenum target, |
| GLenum internalformat, |
| GLuint buffer, |
| GLintptr offset, |
| GLsizeiptr size) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::TexBufferRange, "glTexBufferRange", |
| "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), buffer, |
| static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size)); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| BufferID bufferPacked = FromGL<BufferID>(buffer); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateTexBufferRange(context, targetPacked, internalformat, |
| bufferPacked, offset, size)); |
| if (isCallValid) |
| { |
| context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size); |
| } |
| ANGLE_CAPTURE(TexBufferRange, isCallValid, context, targetPacked, internalformat, |
| bufferPacked, offset, size); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY TexStorage2DMultisample(GLenum target, |
| GLsizei samples, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLboolean fixedsamplelocations) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::TexStorage2DMultisample, "glTexStorage2DMultisample", |
| "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " |
| "fixedsamplelocations = %s", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, |
| GLbooleanToString(fixedsamplelocations)); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexStorage2DMultisample(context, targetPacked, samples, internalformat, width, |
| height, fixedsamplelocations)); |
| if (isCallValid) |
| { |
| context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height, |
| fixedsamplelocations); |
| } |
| ANGLE_CAPTURE(TexStorage2DMultisample, isCallValid, context, targetPacked, samples, |
| internalformat, width, height, fixedsamplelocations); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY TexStorage3DMultisample(GLenum target, |
| GLsizei samples, |
| GLenum internalformat, |
| GLsizei width, |
| GLsizei height, |
| GLsizei depth, |
| GLboolean fixedsamplelocations) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::TexStorage3DMultisample, "glTexStorage3DMultisample", |
| "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " |
| "depth = %d, fixedsamplelocations = %s", |
| CID(context), GLenumToString(GLenumGroup::TextureTarget, target), samples, |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), width, height, depth, |
| GLbooleanToString(fixedsamplelocations)); |
| |
| if (context) |
| { |
| TextureType targetPacked = FromGL<TextureType>(target); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTexStorage3DMultisample(context, targetPacked, samples, internalformat, width, |
| height, depth, fixedsamplelocations)); |
| if (isCallValid) |
| { |
| context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height, |
| depth, fixedsamplelocations); |
| } |
| ANGLE_CAPTURE(TexStorage3DMultisample, isCallValid, context, targetPacked, samples, |
| internalformat, width, height, depth, fixedsamplelocations); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY TextureView(GLuint texture, |
| GLenum target, |
| GLuint origtexture, |
| GLenum internalformat, |
| GLuint minlevel, |
| GLuint numlevels, |
| GLuint minlayer, |
| GLuint numlayers) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::TextureView, "glTextureView", |
| "context = %d, texture = %u, target = %s, origtexture = %u, internalformat = %s, " |
| "minlevel = %u, numlevels = %u, minlayer = %u, numlayers = %u", |
| CID(context), texture, GLenumToString(GLenumGroup::TextureTarget, target), origtexture, |
| GLenumToString(GLenumGroup::InternalFormat, internalformat), minlevel, numlevels, |
| minlayer, numlayers); |
| |
| if (context) |
| { |
| TextureID texturePacked = FromGL<TextureID>(texture); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateTextureView(context, texturePacked, target, origtexture, internalformat, |
| minlevel, numlevels, minlayer, numlayers)); |
| if (isCallValid) |
| { |
| context->textureView(texturePacked, target, origtexture, internalformat, minlevel, |
| numlevels, minlayer, numlayers); |
| } |
| ANGLE_CAPTURE(TextureView, isCallValid, context, texturePacked, target, origtexture, |
| internalformat, minlevel, numlevels, minlayer, numlayers); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribBinding(GLuint attribindex, GLuint bindingindex) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::VertexAttribBinding, "glVertexAttribBinding", |
| "context = %d, attribindex = %u, bindingindex = %u", CID(context), attribindex, |
| bindingindex); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexAttribBinding(context, attribindex, bindingindex)); |
| if (isCallValid) |
| { |
| context->vertexAttribBinding(attribindex, bindingindex); |
| } |
| ANGLE_CAPTURE(VertexAttribBinding, isCallValid, context, attribindex, bindingindex); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribFormat(GLuint attribindex, |
| GLint size, |
| GLenum type, |
| GLboolean normalized, |
| GLuint relativeoffset) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::VertexAttribFormat, "glVertexAttribFormat", |
| "context = %d, attribindex = %u, size = %d, type = %s, normalized = %s, relativeoffset = " |
| "%u", |
| CID(context), attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), |
| GLbooleanToString(normalized), relativeoffset); |
| |
| if (context) |
| { |
| VertexAttribType typePacked = FromGL<VertexAttribType>(type); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexAttribFormat(context, attribindex, size, typePacked, |
| normalized, relativeoffset)); |
| if (isCallValid) |
| { |
| context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset); |
| } |
| ANGLE_CAPTURE(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked, |
| normalized, relativeoffset); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribIFormat(GLuint attribindex, |
| GLint size, |
| GLenum type, |
| GLuint relativeoffset) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::VertexAttribIFormat, "glVertexAttribIFormat", |
| "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), |
| attribindex, size, GLenumToString(GLenumGroup::DefaultGroup, type), relativeoffset); |
| |
| if (context) |
| { |
| VertexAttribType typePacked = FromGL<VertexAttribType>(type); |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateVertexAttribIFormat(context, attribindex, size, typePacked, relativeoffset)); |
| if (isCallValid) |
| { |
| context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset); |
| } |
| ANGLE_CAPTURE(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked, |
| relativeoffset); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY VertexAttribLFormat(GLuint attribindex, |
| GLint size, |
| GLenum type, |
| GLuint relativeoffset) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::VertexAttribLFormat, "glVertexAttribLFormat", |
| "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), |
| attribindex, size, GLenumToString(GLenumGroup::VertexAttribType, type), relativeoffset); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = |
| (context->skipValidation() || |
| ValidateVertexAttribLFormat(context, attribindex, size, type, relativeoffset)); |
| if (isCallValid) |
| { |
| context->vertexAttribLFormat(attribindex, size, type, relativeoffset); |
| } |
| ANGLE_CAPTURE(VertexAttribLFormat, isCallValid, context, attribindex, size, type, |
| relativeoffset); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| |
| void GL_APIENTRY VertexBindingDivisor(GLuint bindingindex, GLuint divisor) |
| { |
| Context *context = GetValidGlobalContext(); |
| EVENT(context, gl::EntryPoint::VertexBindingDivisor, "glVertexBindingDivisor", |
| "context = %d, bindingindex = %u, divisor = %u", CID(context), bindingindex, divisor); |
| |
| if (context) |
| { |
| std::unique_lock<angle::GlobalMutex> shareContextLock = GetShareGroupLock(context); |
| bool isCallValid = (context->skipValidation() || |
| ValidateVertexBindingDivisor(context, bindingindex, divisor)); |
| if (isCallValid) |
| { |
| context->vertexBindingDivisor(bindingindex, divisor); |
| } |
| ANGLE_CAPTURE(VertexBindingDivisor, isCallValid, context, bindingindex, divisor); |
| } |
| else |
| { |
| GenerateContextLostErrorOnCurrentGlobalContext(); |
| } |
| } |
| } // namespace gl |