diff options
Diffstat (limited to 'gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.cpp')
| -rw-r--r-- | gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.cpp | 1327 |
1 files changed, 1327 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.cpp new file mode 100644 index 0000000000..831c92acee --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.cpp @@ -0,0 +1,1327 @@ +// 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_3_2_autogen.cpp: +// Defines the GLES 3.2 entry points. + +#include "libGLESv2/entry_points_gles_3_2_autogen.h" + +#include "common/entry_points_enum_autogen.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/capture/capture_gles_3_2_autogen.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationES32.h" +#include "libGLESv2/global_state.h" + +using namespace gl; + +extern "C" { +void GL_APIENTRY GL_BlendBarrier() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendBarrier, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBlendBarrier(context, angle::EntryPoint::GLBlendBarrier)); + if (isCallValid) + { + context->blendBarrier(); + } + ANGLE_CAPTURE_GL(BlendBarrier, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationSeparatei, "context = %d, buf = %u, modeRGB = %s, modeAlpha = %s", + CID(context), buf, GLenumToString(GLESEnum::BlendEquationModeEXT, modeRGB), + GLenumToString(GLESEnum::BlendEquationModeEXT, modeAlpha)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendEquationSeparatei(context, angle::EntryPoint::GLBlendEquationSeparatei, + buf, modeRGB, modeAlpha)); + if (isCallValid) + { + context->blendEquationSeparatei(buf, modeRGB, modeAlpha); + } + ANGLE_CAPTURE_GL(BlendEquationSeparatei, isCallValid, context, buf, modeRGB, modeAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendEquationi(GLuint buf, GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationi, "context = %d, buf = %u, mode = %s", CID(context), buf, + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendEquationi(context, angle::EntryPoint::GLBlendEquationi, buf, mode)); + if (isCallValid) + { + context->blendEquationi(buf, mode); + } + ANGLE_CAPTURE_GL(BlendEquationi, isCallValid, context, buf, mode); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFuncSeparatei, + "context = %d, buf = %u, srcRGB = %s, dstRGB = %s, srcAlpha = %s, dstAlpha = %s", + CID(context), buf, GLenumToString(GLESEnum::BlendingFactor, srcRGB), + GLenumToString(GLESEnum::BlendingFactor, dstRGB), + GLenumToString(GLESEnum::BlendingFactor, srcAlpha), + GLenumToString(GLESEnum::BlendingFactor, dstAlpha)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendFuncSeparatei(context, angle::EntryPoint::GLBlendFuncSeparatei, buf, + srcRGB, dstRGB, srcAlpha, dstAlpha)); + if (isCallValid) + { + context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); + } + ANGLE_CAPTURE_GL(BlendFuncSeparatei, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha, + dstAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendFunci(GLuint buf, GLenum src, GLenum dst) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFunci, "context = %d, buf = %u, src = %s, dst = %s", CID(context), buf, + GLenumToString(GLESEnum::BlendingFactor, src), + GLenumToString(GLESEnum::BlendingFactor, dst)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendFunci(context, angle::EntryPoint::GLBlendFunci, buf, src, dst)); + if (isCallValid) + { + context->blendFunci(buf, src, dst); + } + ANGLE_CAPTURE_GL(BlendFunci, isCallValid, context, buf, src, dst); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColorMaski, "context = %d, index = %u, r = %s, g = %s, b = %s, a = %s", + CID(context), index, GLbooleanToString(r), GLbooleanToString(g), GLbooleanToString(b), + GLbooleanToString(a)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateColorMaski(context, angle::EntryPoint::GLColorMaski, index, r, g, b, a)); + if (isCallValid) + { + context->colorMaski(index, r, g, b, a); + } + ANGLE_CAPTURE_GL(ColorMaski, isCallValid, context, index, r, g, b, a); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_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, 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(GLESEnum::CopyImageSubDataTarget, srcTarget), + srcLevel, srcX, srcY, srcZ, dstName, + GLenumToString(GLESEnum::CopyImageSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCopyImageSubData(context, angle::EntryPoint::GLCopyImageSubData, 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_GL(CopyImageSubData, isCallValid, context, srcName, srcTarget, srcLevel, srcX, + srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, + srcHeight, srcDepth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageCallback, + "context = %d, callback = 0x%016" PRIxPTR ", userParam = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)callback, (uintptr_t)userParam); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDebugMessageCallback(context, angle::EntryPoint::GLDebugMessageCallback, + callback, userParam)); + if (isCallValid) + { + context->debugMessageCallback(callback, userParam); + } + ANGLE_CAPTURE_GL(DebugMessageCallback, isCallValid, context, callback, userParam); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DebugMessageControl(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageControl, + "context = %d, source = %s, type = %s, severity = %s, count = %d, ids = 0x%016" PRIxPTR + ", enabled = %s", + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), + GLenumToString(GLESEnum::DebugSeverity, severity), count, (uintptr_t)ids, + GLbooleanToString(enabled)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDebugMessageControl(context, angle::EntryPoint::GLDebugMessageControl, source, + type, severity, count, ids, enabled)); + if (isCallValid) + { + context->debugMessageControl(source, type, severity, count, ids, enabled); + } + ANGLE_CAPTURE_GL(DebugMessageControl, isCallValid, context, source, type, severity, count, + ids, enabled); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DebugMessageInsert(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageInsert, + "context = %d, source = %s, type = %s, id = %u, severity = %s, length = %d, buf = " + "0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::DebugSource, source), + GLenumToString(GLESEnum::DebugType, type), id, + GLenumToString(GLESEnum::DebugSeverity, severity), length, (uintptr_t)buf); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDebugMessageInsert(context, angle::EntryPoint::GLDebugMessageInsert, source, + type, id, severity, length, buf)); + if (isCallValid) + { + context->debugMessageInsert(source, type, id, severity, length, buf); + } + ANGLE_CAPTURE_GL(DebugMessageInsert, isCallValid, context, source, type, id, severity, + length, buf); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Disablei(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDisablei, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDisablei(context, angle::EntryPoint::GLDisablei, target, index)); + if (isCallValid) + { + context->disablei(target, index); + } + ANGLE_CAPTURE_GL(Disablei, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsBaseVertex, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", basevertex = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsBaseVertex(context, angle::EntryPoint::GLDrawElementsBaseVertex, + modePacked, count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsBaseVertex, isCallValid, context, modePacked, count, + typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseVertex, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", instancecount = %d, basevertex = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, + basevertex); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawElementsInstancedBaseVertex( + context, angle::EntryPoint::GLDrawElementsInstancedBaseVertex, + modePacked, count, typePacked, indices, instancecount, basevertex)); + if (isCallValid) + { + context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices, + instancecount, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertex, isCallValid, context, modePacked, count, + typePacked, indices, instancecount, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawRangeElementsBaseVertex(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawRangeElementsBaseVertex, + "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " + "0x%016" PRIxPTR ", basevertex = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, basevertex); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawRangeElementsBaseVertex( + context, angle::EntryPoint::GLDrawRangeElementsBaseVertex, + modePacked, start, end, count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices, + basevertex); + } + ANGLE_CAPTURE_GL(DrawRangeElementsBaseVertex, isCallValid, context, modePacked, start, end, + count, typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Enablei(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEnablei, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEnablei(context, angle::EntryPoint::GLEnablei, target, index)); + if (isCallValid) + { + context->enablei(target, index); + } + ANGLE_CAPTURE_GL(Enablei, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferTexture(GLenum target, + GLenum attachment, + GLuint texture, + GLint level) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTexture, + "context = %d, target = %s, attachment = %s, texture = %u, level = %d", CID(context), + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level); + + if (context) + { + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferTexture(context, angle::EntryPoint::GLFramebufferTexture, target, + attachment, texturePacked, level)); + if (isCallValid) + { + context->framebufferTexture(target, attachment, texturePacked, level); + } + ANGLE_CAPTURE_GL(FramebufferTexture, isCallValid, context, target, attachment, + texturePacked, level); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_GetDebugMessageLog(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, 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) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetDebugMessageLog( + context, angle::EntryPoint::GLGetDebugMessageLog, count, bufSize, + sources, types, ids, severities, lengths, messageLog)); + if (isCallValid) + { + returnValue = context->getDebugMessageLog(count, bufSize, sources, types, ids, + severities, lengths, messageLog); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLog, GLuint>(); + } + ANGLE_CAPTURE_GL(GetDebugMessageLog, isCallValid, context, count, bufSize, sources, types, + ids, severities, lengths, messageLog, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLog, GLuint>(); + } + return returnValue; +} + +GLenum GL_APIENTRY GL_GetGraphicsResetStatus() +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetGraphicsResetStatus, "context = %d", CID(context)); + + GLenum returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetGraphicsResetStatus(context, angle::EntryPoint::GLGetGraphicsResetStatus)); + if (isCallValid) + { + returnValue = context->getGraphicsResetStatus(); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatus, GLenum>(); + } + ANGLE_CAPTURE_GL(GetGraphicsResetStatus, isCallValid, context, returnValue); + } + else + { + + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatus, GLenum>(); + } + return returnValue; +} + +void GL_APIENTRY +GL_GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetObjectLabel, + "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", label = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, bufSize, + (uintptr_t)length, (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetObjectLabel(context, angle::EntryPoint::GLGetObjectLabel, + identifier, name, bufSize, length, label)); + if (isCallValid) + { + context->getObjectLabel(identifier, name, bufSize, length, label); + } + ANGLE_CAPTURE_GL(GetObjectLabel, isCallValid, context, identifier, name, bufSize, length, + label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetObjectPtrLabel(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, 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) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetObjectPtrLabel(context, angle::EntryPoint::GLGetObjectPtrLabel, ptr, + bufSize, length, label)); + if (isCallValid) + { + context->getObjectPtrLabel(ptr, bufSize, length, label); + } + ANGLE_CAPTURE_GL(GetObjectPtrLabel, isCallValid, context, ptr, bufSize, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPointerv(GLenum pname, void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPointerv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::GetPointervPName, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetPointerv(context, angle::EntryPoint::GLGetPointerv, pname, params)); + if (isCallValid) + { + context->getPointerv(pname, params); + } + ANGLE_CAPTURE_GL(GetPointerv, isCallValid, context, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIiv, + "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetSamplerParameterIiv(context, angle::EntryPoint::GLGetSamplerParameterIiv, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIiv, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIuiv, + "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetSamplerParameterIuiv(context, angle::EntryPoint::GLGetSamplerParameterIuiv, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIuiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIuiv, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIiv, + "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() || + ValidateGetTexParameterIiv(context, angle::EntryPoint::GLGetTexParameterIiv, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIiv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIuiv, + "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() || + ValidateGetTexParameterIuiv(context, angle::EntryPoint::GLGetTexParameterIuiv, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIuiv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformfv, + "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformfv(context, angle::EntryPoint::GLGetnUniformfv, + programPacked, locationPacked, bufSize, params)); + if (isCallValid) + { + context->getnUniformfv(programPacked, locationPacked, bufSize, params); + } + ANGLE_CAPTURE_GL(GetnUniformfv, isCallValid, context, programPacked, locationPacked, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformiv, + "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformiv(context, angle::EntryPoint::GLGetnUniformiv, + programPacked, locationPacked, bufSize, params)); + if (isCallValid) + { + context->getnUniformiv(programPacked, locationPacked, bufSize, params); + } + ANGLE_CAPTURE_GL(GetnUniformiv, isCallValid, context, programPacked, locationPacked, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformuiv, + "context = %d, program = %u, location = %d, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformuiv(context, angle::EntryPoint::GLGetnUniformuiv, + programPacked, locationPacked, bufSize, params)); + if (isCallValid) + { + context->getnUniformuiv(programPacked, locationPacked, bufSize, params); + } + ANGLE_CAPTURE_GL(GetnUniformuiv, isCallValid, context, programPacked, locationPacked, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsEnabledi(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsEnabledi, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + GLboolean returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsEnabledi(context, angle::EntryPoint::GLIsEnabledi, target, index)); + if (isCallValid) + { + returnValue = context->isEnabledi(target, index); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabledi, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsEnabledi, isCallValid, context, target, index, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnabledi, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_MinSampleShading(GLfloat value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMinSampleShading, "context = %d, value = %f", CID(context), value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMinSampleShading(context, angle::EntryPoint::GLMinSampleShading, value)); + if (isCallValid) + { + context->minSampleShading(value); + } + ANGLE_CAPTURE_GL(MinSampleShading, isCallValid, context, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLObjectLabel, + "context = %d, identifier = %s, name = %u, length = %d, label = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::ObjectIdentifier, identifier), name, length, + (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateObjectLabel(context, angle::EntryPoint::GLObjectLabel, + identifier, name, length, label)); + if (isCallValid) + { + context->objectLabel(identifier, name, length, label); + } + ANGLE_CAPTURE_GL(ObjectLabel, isCallValid, context, identifier, name, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLObjectPtrLabel, + "context = %d, ptr = 0x%016" PRIxPTR ", length = %d, label = 0x%016" PRIxPTR "", + CID(context), (uintptr_t)ptr, length, (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateObjectPtrLabel(context, angle::EntryPoint::GLObjectPtrLabel, + ptr, length, label)); + if (isCallValid) + { + context->objectPtrLabel(ptr, length, label); + } + ANGLE_CAPTURE_GL(ObjectPtrLabel, isCallValid, context, ptr, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PatchParameteri(GLenum pname, GLint value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPatchParameteri, "context = %d, pname = %s, value = %d", CID(context), + GLenumToString(GLESEnum::PatchParameterName, pname), value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePatchParameteri(context, angle::EntryPoint::GLPatchParameteri, pname, value)); + if (isCallValid) + { + context->patchParameteri(pname, value); + } + ANGLE_CAPTURE_GL(PatchParameteri, isCallValid, context, pname, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PopDebugGroup() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPopDebugGroup, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePopDebugGroup(context, angle::EntryPoint::GLPopDebugGroup)); + if (isCallValid) + { + context->popDebugGroup(); + } + ANGLE_CAPTURE_GL(PopDebugGroup, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PrimitiveBoundingBox(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPrimitiveBoundingBox, + "context = %d, minX = %f, minY = %f, minZ = %f, minW = %f, maxX = %f, maxY = %f, maxZ = " + "%f, maxW = %f", + CID(context), minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePrimitiveBoundingBox(context, angle::EntryPoint::GLPrimitiveBoundingBox, minX, + minY, minZ, minW, maxX, maxY, maxZ, maxW)); + if (isCallValid) + { + context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + } + ANGLE_CAPTURE_GL(PrimitiveBoundingBox, isCallValid, context, minX, minY, minZ, minW, maxX, + maxY, maxZ, maxW); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPushDebugGroup, + "context = %d, source = %s, id = %u, length = %d, message = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::DebugSource, source), id, length, + (uintptr_t)message); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePushDebugGroup(context, angle::EntryPoint::GLPushDebugGroup, + source, id, length, message)); + if (isCallValid) + { + context->pushDebugGroup(source, id, length, message); + } + ANGLE_CAPTURE_GL(PushDebugGroup, isCallValid, context, source, id, length, message); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReadnPixels(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReadnPixels, + "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " + "= %d, data = 0x%016" PRIxPTR "", + CID(context), x, y, width, height, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type), bufSize, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateReadnPixels(context, angle::EntryPoint::GLReadnPixels, x, y, + width, height, format, type, bufSize, data)); + if (isCallValid) + { + context->readnPixels(x, y, width, height, format, type, bufSize, data); + } + ANGLE_CAPTURE_GL(ReadnPixels, isCallValid, context, x, y, width, height, format, type, + bufSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIiv, + "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSamplerParameterIiv(context, angle::EntryPoint::GLSamplerParameterIiv, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIiv, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIuiv, + "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSamplerParameterIuiv(context, angle::EntryPoint::GLSamplerParameterIuiv, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIuiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIuiv, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBuffer, "context = %d, target = %s, internalformat = %s, buffer = %u", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + BufferID bufferPacked = PackParam<BufferID>(buffer); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexBuffer(context, angle::EntryPoint::GLTexBuffer, targetPacked, + internalformat, bufferPacked)); + if (isCallValid) + { + context->texBuffer(targetPacked, internalformat, bufferPacked); + } + ANGLE_CAPTURE_GL(TexBuffer, isCallValid, context, targetPacked, internalformat, + bufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexBufferRange(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBufferRange, + "context = %d, target = %s, internalformat = %s, buffer = %u, offset = %llu, size = %llu", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), buffer, + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + BufferID bufferPacked = PackParam<BufferID>(buffer); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexBufferRange(context, angle::EntryPoint::GLTexBufferRange, targetPacked, + internalformat, bufferPacked, offset, size)); + if (isCallValid) + { + context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size); + } + ANGLE_CAPTURE_GL(TexBufferRange, isCallValid, context, targetPacked, internalformat, + bufferPacked, offset, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIiv(GLenum target, GLenum pname, const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIiv, + "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() || + ValidateTexParameterIiv(context, angle::EntryPoint::GLTexParameterIiv, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIiv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIuiv, + "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() || + ValidateTexParameterIuiv(context, angle::EntryPoint::GLTexParameterIuiv, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIuiv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorage3DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage3DMultisample, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d, fixedsamplelocations = %s", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth, + GLbooleanToString(fixedsamplelocations)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage3DMultisample(context, angle::EntryPoint::GLTexStorage3DMultisample, + targetPacked, samples, internalformat, width, height, + depth, fixedsamplelocations)); + if (isCallValid) + { + context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height, + depth, fixedsamplelocations); + } + ANGLE_CAPTURE_GL(TexStorage3DMultisample, isCallValid, context, targetPacked, samples, + internalformat, width, height, depth, fixedsamplelocations); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +} // extern "C" |