diff options
Diffstat (limited to 'gfx/angle/checkout/src/libGLESv2')
28 files changed, 45698 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs.cpp b/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs.cpp new file mode 100644 index 0000000000..2476d50139 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs.cpp @@ -0,0 +1,974 @@ +// +// 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. +// +// egl_ext_stubs.cpp: Stubs for EXT extension entry points. +// + +#include "libGLESv2/egl_ext_stubs_autogen.h" + +#include "libANGLE/Device.h" +#include "libANGLE/Display.h" +#include "libANGLE/EGLSync.h" +#include "libANGLE/Surface.h" +#include "libANGLE/Thread.h" +#include "libANGLE/capture/capture_egl.h" +#include "libANGLE/capture/frame_capture_utils_autogen.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/queryutils.h" +#include "libANGLE/renderer/DisplayImpl.h" +#include "libANGLE/validationEGL.h" +#include "libANGLE/validationEGL_autogen.h" +#include "libGLESv2/global_state.h" + +namespace egl +{ +EGLint ClientWaitSyncKHR(Thread *thread, + Display *display, + Sync *syncObject, + EGLint flags, + EGLTimeKHR timeout) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglClientWaitSync", + GetDisplayIfValid(display), EGL_FALSE); + gl::Context *currentContext = thread->getContext(); + EGLint syncStatus = EGL_FALSE; + ANGLE_EGL_TRY_RETURN( + thread, syncObject->clientWait(display, currentContext, flags, timeout, &syncStatus), + "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return syncStatus; +} + +EGLImageKHR CreateImageKHR(Thread *thread, + Display *display, + gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateImageKHR", + GetDisplayIfValid(display), EGL_NO_IMAGE); + Image *image = nullptr; + ANGLE_EGL_TRY_RETURN(thread, display->createImage(context, target, buffer, attributes, &image), + "", GetDisplayIfValid(display), EGL_NO_IMAGE); + + ANGLE_CAPTURE_EGL(EGLCreateImage, thread, context, target, buffer, attributes, image); + + thread->setSuccess(); + return static_cast<EGLImage>(image); +} + +EGLClientBuffer CreateNativeClientBufferANDROID(Thread *thread, const AttributeMap &attribMap) +{ + EGLClientBuffer eglClientBuffer = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + egl::Display::CreateNativeClientBuffer(attribMap, &eglClientBuffer), + "eglCreateNativeClientBufferANDROID", nullptr, nullptr); + + ANGLE_CAPTURE_EGL(CreateNativeClientBufferANDROID, thread, attribMap, eglClientBuffer); + + thread->setSuccess(); + return eglClientBuffer; +} + +EGLSurface CreatePlatformPixmapSurfaceEXT(Thread *thread, + Display *display, + Config *configPacked, + void *native_pixmap, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurfaceEXT", + GetDisplayIfValid(display), EGL_NO_SURFACE); + thread->setError(EGL_BAD_DISPLAY, "eglCreatePlatformPixmapSurfaceEXT", + GetDisplayIfValid(display), "CreatePlatformPixmapSurfaceEXT unimplemented."); + return EGL_NO_SURFACE; +} + +EGLSurface CreatePlatformWindowSurfaceEXT(Thread *thread, + Display *display, + Config *configPacked, + void *native_window, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformWindowSurfaceEXT", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + + // In X11, eglCreatePlatformWindowSurfaceEXT expects the native_window argument to be a pointer + // to a Window while the EGLNativeWindowType for X11 is its actual value. + // https://www.khronos.org/registry/EGL/extensions/KHR/EGL_KHR_platform_x11.txt + void *actualNativeWindow = display->getImplementation()->isX11() + ? *reinterpret_cast<void **>(native_window) + : native_window; + EGLNativeWindowType nativeWindow = reinterpret_cast<EGLNativeWindowType>(actualNativeWindow); + + ANGLE_EGL_TRY_RETURN( + thread, display->createWindowSurface(configPacked, nativeWindow, attributes, &surface), + "eglPlatformCreateWindowSurfaceEXT", GetDisplayIfValid(display), EGL_NO_SURFACE); + + return static_cast<EGLSurface>(surface); +} + +EGLStreamKHR CreateStreamKHR(Thread *thread, Display *display, const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateStreamKHR", + GetDisplayIfValid(display), EGL_NO_STREAM_KHR); + Stream *stream; + ANGLE_EGL_TRY_RETURN(thread, display->createStream(attributes, &stream), "eglCreateStreamKHR", + GetDisplayIfValid(display), EGL_NO_STREAM_KHR); + + thread->setSuccess(); + return static_cast<EGLStreamKHR>(stream); +} + +EGLSyncKHR CreateSyncKHR(Thread *thread, + Display *display, + EGLenum type, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSyncKHR", + GetDisplayIfValid(display), EGL_NO_SYNC); + egl::Sync *syncObject = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + display->createSync(thread->getContext(), type, attributes, &syncObject), + "eglCreateSyncKHR", GetDisplayIfValid(display), EGL_NO_SYNC); + + thread->setSuccess(); + return static_cast<EGLSync>(syncObject); +} + +EGLint DebugMessageControlKHR(Thread *thread, + EGLDEBUGPROCKHR callback, + const AttributeMap &attributes) +{ + Debug *debug = GetDebug(); + debug->setCallback(callback, attributes); + + thread->setSuccess(); + return EGL_SUCCESS; +} + +EGLBoolean DestroyImageKHR(Thread *thread, Display *display, Image *img) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyImageKHR", + GetDisplayIfValid(display), EGL_FALSE); + display->destroyImage(img); + + ANGLE_CAPTURE_EGL(EGLDestroyImage, thread, display, img); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean DestroyStreamKHR(Thread *thread, Display *display, Stream *streamObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyStreamKHR", + GetDisplayIfValid(display), EGL_FALSE); + display->destroyStream(streamObject); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean DestroySyncKHR(Thread *thread, Display *display, Sync *syncObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySync", + GetDisplayIfValid(display), EGL_FALSE); + display->destroySync(syncObject); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLint DupNativeFenceFDANDROID(Thread *thread, Display *display, Sync *syncObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDupNativeFenceFDANDROID", + GetDisplayIfValid(display), EGL_NO_NATIVE_FENCE_FD_ANDROID); + EGLint result = EGL_NO_NATIVE_FENCE_FD_ANDROID; + ANGLE_EGL_TRY_RETURN(thread, syncObject->dupNativeFenceFD(display, &result), + "eglDupNativeFenceFDANDROID", GetSyncIfValid(display, syncObject), + EGL_NO_NATIVE_FENCE_FD_ANDROID); + + thread->setSuccess(); + return result; +} + +EGLClientBuffer GetNativeClientBufferANDROID(Thread *thread, const struct AHardwareBuffer *buffer) +{ + thread->setSuccess(); + return egl::Display::GetNativeClientBuffer(buffer); +} + +EGLDisplay GetPlatformDisplayEXT(Thread *thread, + EGLenum platform, + void *native_display, + const AttributeMap &attribMap) +{ + switch (platform) + { + case EGL_PLATFORM_ANGLE_ANGLE: + case EGL_PLATFORM_GBM_KHR: + case EGL_PLATFORM_WAYLAND_EXT: + { + return egl::Display::GetDisplayFromNativeDisplay( + platform, gl::bitCast<EGLNativeDisplayType>(native_display), attribMap); + } + case EGL_PLATFORM_DEVICE_EXT: + { + Device *eglDevice = static_cast<Device *>(native_display); + return egl::Display::GetDisplayFromDevice(eglDevice, attribMap); + } + default: + { + UNREACHABLE(); + return EGL_NO_DISPLAY; + } + } +} + +EGLBoolean GetSyncAttribKHR(Thread *thread, + Display *display, + Sync *syncObject, + EGLint attribute, + EGLint *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetSyncAttrib", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, value), + "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLint LabelObjectKHR(Thread *thread, + Display *display, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label) +{ + LabeledObject *labeledObject = + GetLabeledObjectIfValid(thread, display, objectTypePacked, object); + ASSERT(labeledObject != nullptr); + labeledObject->setLabel(label); + + thread->setSuccess(); + return EGL_SUCCESS; +} + +EGLBoolean PostSubBufferNV(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglPostSubBufferNV", + GetDisplayIfValid(display), EGL_FALSE); + Error error = eglSurface->postSubBuffer(thread->getContext(), x, y, width, height); + if (error.isError()) + { + thread->setError(error, "eglPostSubBufferNV", GetSurfaceIfValid(display, eglSurface)); + return EGL_FALSE; + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean PresentationTimeANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + EGLnsecsANDROID time) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglPresentationTimeANDROID", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->setPresentationTime(time), + "eglPresentationTimeANDROID", GetSurfaceIfValid(display, eglSurface), + EGL_FALSE); + + return EGL_TRUE; +} + +EGLBoolean GetCompositorTimingSupportedANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + CompositorTiming nameInternal) +{ + thread->setSuccess(); + return eglSurface->getSupportedCompositorTimings().test(nameInternal); +} + +EGLBoolean GetCompositorTimingANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetCompositorTimingANDROIDD", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->getCompositorTiming(numTimestamps, names, values), + "eglGetCompositorTimingANDROIDD", GetSurfaceIfValid(display, eglSurface), + EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetNextFrameIdANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + EGLuint64KHR *frameId) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetNextFrameIdANDROID", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->getNextFrameId(frameId), "eglGetNextFrameIdANDROID", + GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetFrameTimestampSupportedANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + Timestamp timestampInternal) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryTimestampSupportedANDROID", + GetDisplayIfValid(display), EGL_FALSE); + thread->setSuccess(); + return eglSurface->getSupportedTimestamps().test(timestampInternal); +} + +EGLBoolean GetFrameTimestampsANDROID(Thread *thread, + Display *display, + Surface *eglSurface, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetFrameTimestampsANDROID", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN( + thread, eglSurface->getFrameTimestamps(frameId, numTimestamps, timestamps, values), + "eglGetFrameTimestampsANDROID", GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryDebugKHR(Thread *thread, EGLint attribute, EGLAttrib *value) +{ + Debug *debug = GetDebug(); + switch (attribute) + { + case EGL_DEBUG_MSG_CRITICAL_KHR: + case EGL_DEBUG_MSG_ERROR_KHR: + case EGL_DEBUG_MSG_WARN_KHR: + case EGL_DEBUG_MSG_INFO_KHR: + *value = debug->isMessageTypeEnabled(FromEGLenum<MessageType>(attribute)) ? EGL_TRUE + : EGL_FALSE; + break; + case EGL_DEBUG_CALLBACK_KHR: + *value = reinterpret_cast<EGLAttrib>(debug->getCallback()); + break; + + default: + UNREACHABLE(); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryDeviceAttribEXT(Thread *thread, Device *dev, EGLint attribute, EGLAttrib *value) +{ + ANGLE_EGL_TRY_RETURN(thread, dev->getAttribute(attribute, value), "eglQueryDeviceAttribEXT", + GetDeviceIfValid(dev), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +const char *QueryDeviceStringEXT(Thread *thread, Device *dev, EGLint name) +{ + egl::Display *owningDisplay = dev->getOwningDisplay(); + ANGLE_EGL_TRY_RETURN(thread, owningDisplay->prepareForCall(), "eglQueryDeviceStringEXT", + GetDisplayIfValid(owningDisplay), EGL_FALSE); + const char *result; + switch (name) + { + case EGL_EXTENSIONS: + result = dev->getExtensionString().c_str(); + break; + default: + thread->setError(EglBadDevice(), "eglQueryDeviceStringEXT", GetDeviceIfValid(dev)); + return nullptr; + } + + thread->setSuccess(); + return result; +} + +EGLBoolean QueryDisplayAttribEXT(Thread *thread, + Display *display, + EGLint attribute, + EGLAttrib *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribEXT", + GetDisplayIfValid(display), EGL_FALSE); + *value = display->queryAttrib(attribute); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryStreamKHR(Thread *thread, + Display *display, + Stream *streamObject, + EGLenum attribute, + EGLint *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStreamKHR", + GetDisplayIfValid(display), EGL_FALSE); + switch (attribute) + { + case EGL_STREAM_STATE_KHR: + *value = streamObject->getState(); + break; + case EGL_CONSUMER_LATENCY_USEC_KHR: + *value = streamObject->getConsumerLatency(); + break; + case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR: + *value = streamObject->getConsumerAcquireTimeout(); + break; + default: + UNREACHABLE(); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryStreamu64KHR(Thread *thread, + Display *display, + Stream *streamObject, + EGLenum attribute, + EGLuint64KHR *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStreamu64KHR", + GetDisplayIfValid(display), EGL_FALSE); + switch (attribute) + { + case EGL_PRODUCER_FRAME_KHR: + *value = streamObject->getProducerFrame(); + break; + case EGL_CONSUMER_FRAME_KHR: + *value = streamObject->getConsumerFrame(); + break; + default: + UNREACHABLE(); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QuerySurfacePointerANGLE(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint attribute, + void **value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQuerySurfacePointerANGLE", + GetDisplayIfValid(display), EGL_FALSE); + Error error = eglSurface->querySurfacePointerANGLE(attribute, value); + if (error.isError()) + { + thread->setError(error, "eglQuerySurfacePointerANGLE", + GetSurfaceIfValid(display, eglSurface)); + return EGL_FALSE; + } + + thread->setSuccess(); + return EGL_TRUE; +} + +void SetBlobCacheFuncsANDROID(Thread *thread, + Display *display, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglSetBlobCacheFuncsANDROID", + GetDisplayIfValid(display)); + thread->setSuccess(); + display->setBlobCacheFuncs(set, get); +} + +EGLBoolean SignalSyncKHR(Thread *thread, Display *display, Sync *syncObject, EGLenum mode) +{ + gl::Context *currentContext = thread->getContext(); + ANGLE_EGL_TRY_RETURN(thread, syncObject->signal(display, currentContext, mode), + "eglSignalSyncKHR", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamAttribKHR(Thread *thread, + Display *display, + Stream *streamObject, + EGLenum attribute, + EGLint value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamAttribKHR", + GetDisplayIfValid(display), EGL_FALSE); + switch (attribute) + { + case EGL_CONSUMER_LATENCY_USEC_KHR: + streamObject->setConsumerLatency(value); + break; + case EGL_CONSUMER_ACQUIRE_TIMEOUT_USEC_KHR: + streamObject->setConsumerAcquireTimeout(value); + break; + default: + UNREACHABLE(); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamConsumerAcquireKHR(Thread *thread, Display *display, Stream *streamObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerAcquireKHR", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerAcquire(thread->getContext()), + "eglStreamConsumerAcquireKHR", GetStreamIfValid(display, streamObject), + EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamConsumerGLTextureExternalKHR(Thread *thread, + Display *display, + Stream *streamObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerGLTextureExternalKHR", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN( + thread, streamObject->createConsumerGLTextureExternal(AttributeMap(), thread->getContext()), + "eglStreamConsumerGLTextureExternalKHR", GetStreamIfValid(display, streamObject), + EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamConsumerGLTextureExternalAttribsNV(Thread *thread, + Display *display, + Stream *streamObject, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), + "eglStreamConsumerGLTextureExternalAttribsNV", GetDisplayIfValid(display), + EGL_FALSE); + + gl::Context *context = gl::GetValidGlobalContext(); + ANGLE_EGL_TRY_RETURN(thread, streamObject->createConsumerGLTextureExternal(attributes, context), + "eglStreamConsumerGLTextureExternalAttribsNV", + GetStreamIfValid(display, streamObject), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamConsumerReleaseKHR(Thread *thread, Display *display, Stream *streamObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamConsumerReleaseKHR", + GetDisplayIfValid(display), EGL_FALSE); + + gl::Context *context = gl::GetValidGlobalContext(); + ANGLE_EGL_TRY_RETURN(thread, streamObject->consumerRelease(context), + "eglStreamConsumerReleaseKHR", GetStreamIfValid(display, streamObject), + EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean SwapBuffersWithDamageKHR(Thread *thread, + Display *display, + Surface *eglSurface, + const EGLint *rects, + EGLint n_rects) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffersWithDamageEXT", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->swapWithDamage(thread->getContext(), rects, n_rects), + "eglSwapBuffersWithDamageEXT", GetSurfaceIfValid(display, eglSurface), + EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean PrepareSwapBuffersANGLE(EGLDisplay dpy, EGLSurface surface) + +{ + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + Thread *thread = egl::GetCurrentThread(); + { + ANGLE_SCOPED_GLOBAL_LOCK(); + + EGL_EVENT(PrepareSwapBuffersANGLE, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface); + + ANGLE_EGL_VALIDATE(thread, PrepareSwapBuffersANGLE, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, surfacePacked); + + ANGLE_EGL_TRY_RETURN(thread, dpyPacked->prepareForCall(), "eglPrepareSwapBuffersANGLE", + GetDisplayIfValid(dpyPacked), EGL_FALSE); + } + ANGLE_EGL_TRY_RETURN(thread, surfacePacked->prepareSwap(thread->getContext()), "prepareSwap", + GetSurfaceIfValid(dpyPacked, surfacePacked), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLint WaitSyncKHR(Thread *thread, Display *display, Sync *syncObject, EGLint flags) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync", + GetDisplayIfValid(display), EGL_FALSE); + gl::Context *currentContext = thread->getContext(); + ANGLE_EGL_TRY_RETURN(thread, syncObject->serverWait(display, currentContext, flags), + "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLDeviceEXT CreateDeviceANGLE(Thread *thread, + EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list) +{ + Device *device = nullptr; + ANGLE_EGL_TRY_RETURN(thread, Device::CreateDevice(device_type, native_device, &device), + "eglCreateDeviceANGLE", GetThreadIfValid(thread), EGL_NO_DEVICE_EXT); + + thread->setSuccess(); + return device; +} + +EGLBoolean ReleaseDeviceANGLE(Thread *thread, Device *dev) +{ + SafeDelete(dev); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean CreateStreamProducerD3DTextureANGLE(Thread *thread, + Display *display, + Stream *streamObject, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), + "eglCreateStreamProducerD3DTextureANGLE", GetDisplayIfValid(display), + EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, streamObject->createProducerD3D11Texture(attributes), + "eglCreateStreamProducerD3DTextureANGLE", + GetStreamIfValid(display, streamObject), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean StreamPostD3DTextureANGLE(Thread *thread, + Display *display, + Stream *streamObject, + void *texture, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglStreamPostD3DTextureANGLE", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, streamObject->postD3D11Texture(texture, attributes), + "eglStreamPostD3DTextureANGLE", GetStreamIfValid(display, streamObject), + EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetMscRateANGLE(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint *numerator, + EGLint *denominator) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetMscRateANGLE", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->getMscRate(numerator, denominator), + "eglGetMscRateANGLE", GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetSyncValuesCHROMIUM(Thread *thread, + Display *display, + Surface *eglSurface, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglGetSyncValuesCHROMIUM", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->getSyncValues(ust, msc, sbc), + "eglGetSyncValuesCHROMIUM", GetSurfaceIfValid(display, eglSurface), + EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLint ProgramCacheGetAttribANGLE(Thread *thread, Display *display, EGLenum attrib) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglProgramCacheGetAttribANGLE", + GetDisplayIfValid(display), 0); + thread->setSuccess(); + return display->programCacheGetAttrib(attrib); +} + +void ProgramCacheQueryANGLE(Thread *thread, + Display *display, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglProgramCacheQueryANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, display->programCacheQuery(index, key, keysize, binary, binarysize), + "eglProgramCacheQueryANGLE", GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +void ProgramCachePopulateANGLE(Thread *thread, + Display *display, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglProgramCachePopulateANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, display->programCachePopulate(key, keysize, binary, binarysize), + "eglProgramCachePopulateANGLE", GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +EGLint ProgramCacheResizeANGLE(Thread *thread, Display *display, EGLint limit, EGLint mode) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglProgramCacheResizeANGLE", + GetDisplayIfValid(display), 0); + thread->setSuccess(); + return display->programCacheResize(limit, mode); +} + +const char *QueryStringiANGLE(Thread *thread, Display *display, EGLint name, EGLint index) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryStringiANGLE", + GetDisplayIfValid(display), nullptr); + thread->setSuccess(); + return display->queryStringi(name, index); +} + +EGLBoolean SwapBuffersWithFrameTokenANGLE(Thread *thread, + Display *display, + Surface *eglSurface, + EGLFrameTokenANGLE frametoken) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffersWithFrameTokenANGLE", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->swapWithFrameToken(thread->getContext(), frametoken), + "eglSwapBuffersWithFrameTokenANGLE", GetDisplayIfValid(display), + EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +void ReleaseHighPowerGPUANGLE(Thread *thread, Display *display, gl::Context *context) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglReleaseHighPowerGPUANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, context->releaseHighPowerGPU(), "eglReleaseHighPowerGPUANGLE", + GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +void ReacquireHighPowerGPUANGLE(Thread *thread, Display *display, gl::Context *context) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglReacquireHighPowerGPUANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, context->reacquireHighPowerGPU(), "eglReacquireHighPowerGPUANGLE", + GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +void HandleGPUSwitchANGLE(Thread *thread, Display *display) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglHandleGPUSwitchANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, display->handleGPUSwitch(), "eglHandleGPUSwitchANGLE", + GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +void ForceGPUSwitchANGLE(Thread *thread, Display *display, EGLint gpuIDHigh, EGLint gpuIDLow) +{ + ANGLE_EGL_TRY(thread, display->prepareForCall(), "eglForceGPUSwitchANGLE", + GetDisplayIfValid(display)); + ANGLE_EGL_TRY(thread, display->forceGPUSwitch(gpuIDHigh, gpuIDLow), "eglForceGPUSwitchANGLE", + GetDisplayIfValid(display)); + + thread->setSuccess(); +} + +EGLBoolean QueryDisplayAttribANGLE(Thread *thread, + Display *display, + EGLint attribute, + EGLAttrib *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDisplayAttribEXT", + GetDisplayIfValid(display), EGL_FALSE); + *value = display->queryAttrib(attribute); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean LockSurfaceKHR(Thread *thread, + egl::Display *display, + Surface *surface, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglLockSurfaceKHR", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, surface->lockSurfaceKHR(display, attributes), "eglLockSurfaceKHR", + GetSurfaceIfValid(display, surface), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean UnlockSurfaceKHR(Thread *thread, egl::Display *display, Surface *surface) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglUnlockSurfaceKHR", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, surface->unlockSurfaceKHR(display), "eglQuerySurface64KHR", + GetSurfaceIfValid(display, surface), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QuerySurface64KHR(Thread *thread, + egl::Display *display, + Surface *surface, + EGLint attribute, + EGLAttribKHR *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQuerySurface64KHR", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN( + thread, QuerySurfaceAttrib64KHR(display, thread->getContext(), surface, attribute, value), + "eglQuerySurface64KHR", GetSurfaceIfValid(display, surface), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean ExportVkImageANGLE(Thread *thread, + egl::Display *display, + Image *image, + void *vk_image, + void *vk_image_create_info) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglExportVkImageANGLE", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, image->exportVkImage(vk_image, vk_image_create_info), + "eglExportVkImageANGLE", GetImageIfValid(display, image), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean SetDamageRegionKHR(Thread *thread, + egl::Display *display, + egl::Surface *surface, + EGLint *rects, + EGLint n_rects) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSetDamageRegionKHR", + GetDisplayIfValid(display), EGL_FALSE); + surface->setDamageRegion(rects, n_rects); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryDmaBufFormatsEXT(Thread *thread, + egl::Display *display, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDmaBufFormatsEXT", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, display->queryDmaBufFormats(max_formats, formats, num_formats), + "eglQueryDmaBufFormatsEXT", GetDisplayIfValid(display), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean QueryDmaBufModifiersEXT(Thread *thread, + egl::Display *display, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryDmaBufModifiersEXT", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, + display->queryDmaBufModifiers(format, max_modifiers, modifiers, + external_only, num_modifiers), + "eglQueryDmaBufModifiersEXT", GetDisplayIfValid(display), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +void *CopyMetalSharedEventANGLE(Thread *thread, Display *display, Sync *syncObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCopyMetalSharedEventANGLE", + GetDisplayIfValid(display), nullptr); + void *result = nullptr; + ANGLE_EGL_TRY_RETURN(thread, syncObject->copyMetalSharedEventANGLE(display, &result), + "eglCopyMetalSharedEventANGLE", GetSyncIfValid(display, syncObject), + nullptr); + + thread->setSuccess(); + return result; +} + +} // namespace egl diff --git a/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs_autogen.h b/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs_autogen.h new file mode 100644 index 0000000000..5d2d7b92f1 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/egl_ext_stubs_autogen.h @@ -0,0 +1,264 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.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. +// +// egl_ext_stubs_autogen.h: Stubs for EXT extension entry points. + +#ifndef LIBGLESV2_EGL_EXT_STUBS_AUTOGEN_H_ +#define LIBGLESV2_EGL_EXT_STUBS_AUTOGEN_H_ + +#include <EGL/egl.h> +#include <EGL/eglext.h> + +#include "common/PackedEGLEnums_autogen.h" + +namespace gl +{ +class Context; +} // namespace gl + +namespace egl +{ +class AttributeMap; +class Device; +class Display; +class Image; +class Stream; +class Surface; +class Sync; +class Thread; +struct Config; + +EGLint ClientWaitSyncKHR(Thread *thread, + egl::Display *dpyPacked, + Sync *syncPacked, + EGLint flags, + EGLTimeKHR timeout); +EGLImageKHR CreateImageKHR(Thread *thread, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked); +EGLClientBuffer CreateNativeClientBufferANDROID(Thread *thread, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePlatformPixmapSurfaceEXT(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePlatformWindowSurfaceEXT(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked); +EGLStreamKHR CreateStreamKHR(Thread *thread, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked); +EGLSyncKHR CreateSyncKHR(Thread *thread, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); +EGLint DebugMessageControlKHR(Thread *thread, + EGLDEBUGPROCKHR callback, + const AttributeMap &attrib_listPacked); +EGLBoolean DestroyImageKHR(Thread *thread, egl::Display *dpyPacked, Image *imagePacked); +EGLBoolean DestroyStreamKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); +EGLBoolean DestroySyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); +EGLint DupNativeFenceFDANDROID(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); +EGLBoolean GetMscRateANGLE(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint *numerator, + EGLint *denominator); +EGLClientBuffer GetNativeClientBufferANDROID(Thread *thread, const struct AHardwareBuffer *buffer); +EGLDisplay GetPlatformDisplayEXT(Thread *thread, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked); +EGLBoolean GetSyncAttribKHR(Thread *thread, + egl::Display *dpyPacked, + Sync *syncPacked, + EGLint attribute, + EGLint *value); +EGLint LabelObjectKHR(Thread *thread, + egl::Display *displayPacked, + ObjectType objectTypePacked, + EGLObjectKHR object, + EGLLabelKHR label); +EGLBoolean LockSurfaceKHR(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + const AttributeMap &attrib_listPacked); +EGLBoolean PostSubBufferNV(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint x, + EGLint y, + EGLint width, + EGLint height); +EGLBoolean PresentationTimeANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLnsecsANDROID time); +EGLBoolean GetCompositorTimingSupportedANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + CompositorTiming namePacked); +EGLBoolean GetCompositorTimingANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values); +EGLBoolean GetNextFrameIdANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR *frameId); +EGLBoolean GetFrameTimestampSupportedANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + Timestamp timestampPacked); +EGLBoolean GetFrameTimestampsANDROID(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values); +EGLBoolean QueryDebugKHR(Thread *thread, EGLint attribute, EGLAttrib *value); +EGLBoolean QueryDeviceAttribEXT(Thread *thread, + Device *devicePacked, + EGLint attribute, + EGLAttrib *value); +const char *QueryDeviceStringEXT(Thread *thread, Device *devicePacked, EGLint name); +EGLBoolean QueryDisplayAttribEXT(Thread *thread, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value); +EGLBoolean QueryDmaBufFormatsEXT(Thread *thread, + egl::Display *dpyPacked, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats); +EGLBoolean QueryDmaBufModifiersEXT(Thread *thread, + egl::Display *dpyPacked, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers); +EGLBoolean QueryStreamKHR(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLint *value); +EGLBoolean QueryStreamu64KHR(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLuint64KHR *value); +EGLBoolean QuerySurface64KHR(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + EGLAttribKHR *value); +EGLBoolean QuerySurfacePointerANGLE(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + void **value); +void SetBlobCacheFuncsANDROID(Thread *thread, + egl::Display *dpyPacked, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get); +EGLBoolean SetDamageRegionKHR(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint *rects, + EGLint n_rects); +EGLBoolean SignalSyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLenum mode); +EGLBoolean StreamAttribKHR(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + EGLenum attribute, + EGLint value); +EGLBoolean StreamConsumerAcquireKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); +EGLBoolean StreamConsumerGLTextureExternalKHR(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked); +EGLBoolean StreamConsumerGLTextureExternalAttribsNV(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + const AttributeMap &attrib_listPacked); +EGLBoolean StreamConsumerReleaseKHR(Thread *thread, egl::Display *dpyPacked, Stream *streamPacked); +EGLBoolean SwapBuffersWithDamageKHR(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + const EGLint *rects, + EGLint n_rects); +EGLBoolean UnlockSurfaceKHR(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked); +EGLint WaitSyncKHR(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLint flags); +EGLDeviceEXT CreateDeviceANGLE(Thread *thread, + EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list); +EGLBoolean ReleaseDeviceANGLE(Thread *thread, Device *devicePacked); +EGLBoolean CreateStreamProducerD3DTextureANGLE(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + const AttributeMap &attrib_listPacked); +EGLBoolean StreamPostD3DTextureANGLE(Thread *thread, + egl::Display *dpyPacked, + Stream *streamPacked, + void *texture, + const AttributeMap &attrib_listPacked); +EGLBoolean GetSyncValuesCHROMIUM(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc); +EGLint ProgramCacheGetAttribANGLE(Thread *thread, egl::Display *dpyPacked, EGLenum attrib); +void ProgramCacheQueryANGLE(Thread *thread, + egl::Display *dpyPacked, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize); +void ProgramCachePopulateANGLE(Thread *thread, + egl::Display *dpyPacked, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize); +EGLint ProgramCacheResizeANGLE(Thread *thread, egl::Display *dpyPacked, EGLint limit, EGLint mode); +const char *QueryStringiANGLE(Thread *thread, egl::Display *dpyPacked, EGLint name, EGLint index); +EGLBoolean SwapBuffersWithFrameTokenANGLE(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLFrameTokenANGLE frametoken); +EGLBoolean PrepareSwapBuffersANGLE(EGLDisplay dpy, EGLSurface surface); +void ReleaseHighPowerGPUANGLE(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); +void ReacquireHighPowerGPUANGLE(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); +void HandleGPUSwitchANGLE(Thread *thread, egl::Display *dpyPacked); +void ForceGPUSwitchANGLE(Thread *thread, + egl::Display *dpyPacked, + EGLint gpuIDHigh, + EGLint gpuIDLow); +EGLBoolean QueryDisplayAttribANGLE(Thread *thread, + egl::Display *dpyPacked, + EGLint attribute, + EGLAttrib *value); +EGLBoolean ExportVkImageANGLE(Thread *thread, + egl::Display *dpyPacked, + Image *imagePacked, + void *vk_image, + void *vk_image_create_info); +void *CopyMetalSharedEventANGLE(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); +} // namespace egl +#endif // LIBGLESV2_EGL_EXT_STUBS_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/egl_stubs.cpp b/gfx/angle/checkout/src/libGLESv2/egl_stubs.cpp new file mode 100644 index 0000000000..f2b8ad3dba --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/egl_stubs.cpp @@ -0,0 +1,777 @@ +// +// 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. +// +// egl_stubs.cpp: Stubs for EGL entry points. +// + +#include "libGLESv2/egl_stubs_autogen.h" + +#include "common/angle_version_info.h" +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/EGLSync.h" +#include "libANGLE/Surface.h" +#include "libANGLE/Thread.h" +#include "libANGLE/capture/capture_egl.h" +#include "libANGLE/capture/frame_capture_utils_autogen.h" +#include "libANGLE/capture/gl_enum_utils_autogen.h" +#include "libANGLE/queryutils.h" +#include "libANGLE/validationEGL.h" +#include "libGLESv2/global_state.h" +#include "libGLESv2/proc_table_egl.h" + +namespace egl +{ +namespace +{ + +bool CompareProc(const ProcEntry &a, const char *b) +{ + return strcmp(a.first, b) < 0; +} + +void ClipConfigs(const std::vector<const Config *> &filteredConfigs, + EGLConfig *outputConfigs, + EGLint configSize, + EGLint *numConfigs) +{ + EGLint resultSize = static_cast<EGLint>(filteredConfigs.size()); + if (outputConfigs) + { + resultSize = std::max(std::min(resultSize, configSize), 0); + for (EGLint i = 0; i < resultSize; i++) + { + outputConfigs[i] = const_cast<Config *>(filteredConfigs[i]); + } + } + *numConfigs = resultSize; +} +} // anonymous namespace + +EGLBoolean BindAPI(Thread *thread, EGLenum api) +{ + thread->setAPI(api); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean BindTexImage(Thread *thread, Display *display, Surface *eglSurface, EGLint buffer) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglBindTexImage", + GetDisplayIfValid(display), EGL_FALSE); + + gl::Context *context = thread->getContext(); + if (context && !context->isContextLost()) + { + gl::TextureType type = + egl_gl::EGLTextureTargetToTextureType(eglSurface->getTextureTarget()); + gl::Texture *textureObject = context->getTextureByType(type); + ANGLE_EGL_TRY_RETURN(thread, eglSurface->bindTexImage(context, textureObject, buffer), + "eglBindTexImage", GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + ANGLE_CAPTURE_EGL(EGLBindTexImage, thread, eglSurface, buffer); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean ChooseConfig(Thread *thread, + Display *display, + const AttributeMap &attribMap, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config) +{ + ClipConfigs(display->chooseConfig(attribMap), configs, config_size, num_config); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLint ClientWaitSync(Thread *thread, + Display *display, + Sync *syncObject, + EGLint flags, + EGLTime timeout) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglClientWaitSync", + GetDisplayIfValid(display), EGL_FALSE); + gl::Context *currentContext = thread->getContext(); + EGLint syncStatus = EGL_FALSE; + ANGLE_EGL_TRY_RETURN( + thread, syncObject->clientWait(display, currentContext, flags, timeout, &syncStatus), + "eglClientWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return syncStatus; +} + +EGLBoolean CopyBuffers(Thread *thread, + Display *display, + Surface *eglSurface, + EGLNativePixmapType target) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCopyBuffers", + GetDisplayIfValid(display), EGL_FALSE); + UNIMPLEMENTED(); // FIXME + + thread->setSuccess(); + return 0; +} + +EGLContext CreateContext(Thread *thread, + Display *display, + Config *configuration, + gl::Context *sharedGLContext, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateContext", + GetDisplayIfValid(display), EGL_NO_CONTEXT); + gl::Context *context = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + display->createContext(configuration, sharedGLContext, thread->getAPI(), + attributes, &context), + "eglCreateContext", GetDisplayIfValid(display), EGL_NO_CONTEXT); + + thread->setSuccess(); + return static_cast<EGLContext>(context); +} + +EGLImage CreateImage(Thread *thread, + Display *display, + gl::Context *context, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateImage", + GetDisplayIfValid(display), EGL_FALSE); + + Image *image = nullptr; + Error error = display->createImage(context, target, buffer, attributes, &image); + if (error.isError()) + { + thread->setError(error, "eglCreateImage", GetDisplayIfValid(display)); + return EGL_NO_IMAGE; + } + + ANGLE_CAPTURE_EGL(EGLCreateImage, thread, context, target, buffer, attributes, image); + + thread->setSuccess(); + return static_cast<EGLImage>(image); +} + +EGLSurface CreatePbufferFromClientBuffer(Thread *thread, + Display *display, + EGLenum buftype, + EGLClientBuffer buffer, + Config *configuration, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePbufferFromClientBuffer", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + display->createPbufferFromClientBuffer(configuration, buftype, buffer, + attributes, &surface), + "eglCreatePbufferFromClientBuffer", GetDisplayIfValid(display), + EGL_NO_SURFACE); + + return static_cast<EGLSurface>(surface); +} + +EGLSurface CreatePbufferSurface(Thread *thread, + Display *display, + Config *configuration, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePbufferSurface", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + ANGLE_EGL_TRY_RETURN(thread, display->createPbufferSurface(configuration, attributes, &surface), + "eglCreatePbufferSurface", GetDisplayIfValid(display), EGL_NO_SURFACE); + + ANGLE_CAPTURE_EGL(EGLCreatePbufferSurface, thread, attributes, surface); + + return static_cast<EGLSurface>(surface); +} + +EGLSurface CreatePixmapSurface(Thread *thread, + Display *display, + Config *configuration, + EGLNativePixmapType pixmap, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePixmapSurface", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + display->createPixmapSurface(configuration, pixmap, attributes, &surface), + "eglCreatePixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE); + + thread->setSuccess(); + return static_cast<EGLSurface>(surface); +} + +EGLSurface CreatePlatformPixmapSurface(Thread *thread, + Display *display, + Config *configuration, + void *pixmap, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformPixmapSurface", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + EGLNativePixmapType nativePixmap = reinterpret_cast<EGLNativePixmapType>(pixmap); + ANGLE_EGL_TRY_RETURN( + thread, display->createPixmapSurface(configuration, nativePixmap, attributes, &surface), + "eglCreatePlatformPixmapSurface", GetDisplayIfValid(display), EGL_NO_SURFACE); + + thread->setSuccess(); + return static_cast<EGLSurface>(surface); +} + +EGLSurface CreatePlatformWindowSurface(Thread *thread, + Display *display, + Config *configuration, + void *win, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreatePlatformWindowSurface", + GetDisplayIfValid(display), EGL_NO_SURFACE); + Surface *surface = nullptr; + EGLNativeWindowType nativeWindow = reinterpret_cast<EGLNativeWindowType>(win); + ANGLE_EGL_TRY_RETURN( + thread, display->createWindowSurface(configuration, nativeWindow, attributes, &surface), + "eglPlatformCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE); + + return static_cast<EGLSurface>(surface); +} + +EGLSync CreateSync(Thread *thread, Display *display, EGLenum type, const AttributeMap &attributes) +{ + gl::Context *currentContext = thread->getContext(); + + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateSync", + GetDisplayIfValid(display), EGL_FALSE); + Sync *syncObject = nullptr; + ANGLE_EGL_TRY_RETURN(thread, display->createSync(currentContext, type, attributes, &syncObject), + "eglCreateSync", GetDisplayIfValid(display), EGL_NO_SYNC); + + thread->setSuccess(); + return static_cast<EGLSync>(syncObject); +} + +EGLSurface CreateWindowSurface(Thread *thread, + Display *display, + Config *configuration, + EGLNativeWindowType win, + const AttributeMap &attributes) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglCreateWindowSurface", + GetDisplayIfValid(display), EGL_NO_SURFACE); + + Surface *surface = nullptr; + ANGLE_EGL_TRY_RETURN(thread, + display->createWindowSurface(configuration, win, attributes, &surface), + "eglCreateWindowSurface", GetDisplayIfValid(display), EGL_NO_SURFACE); + + return static_cast<EGLSurface>(surface); +} + +EGLBoolean DestroyContext(Thread *thread, Display *display, gl::Context *context) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyContext", + GetDisplayIfValid(display), EGL_FALSE); + + ScopedSyncCurrentContextFromThread scopedSyncCurrent(thread); + + ANGLE_EGL_TRY_RETURN(thread, display->destroyContext(thread, context), "eglDestroyContext", + GetContextIfValid(display, context), EGL_FALSE); + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean DestroyImage(Thread *thread, Display *display, Image *img) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroyImage", + GetDisplayIfValid(display), EGL_FALSE); + display->destroyImage(img); + + ANGLE_CAPTURE_EGL(EGLDestroyImage, thread, display, img); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean DestroySurface(Thread *thread, Display *display, Surface *eglSurface) +{ + ANGLE_CAPTURE_EGL(EGLDestroySurface, thread, display, eglSurface); + + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySurface", + GetDisplayIfValid(display), EGL_FALSE); + + ANGLE_EGL_TRY_RETURN(thread, display->destroySurface(eglSurface), "eglDestroySurface", + GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean DestroySync(Thread *thread, Display *display, Sync *syncObject) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglDestroySync", + GetDisplayIfValid(display), EGL_FALSE); + display->destroySync(syncObject); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetConfigAttrib(Thread *thread, + Display *display, + Config *configuration, + EGLint attribute, + EGLint *value) +{ + QueryConfigAttrib(configuration, attribute, value); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean GetConfigs(Thread *thread, + Display *display, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config) +{ + ClipConfigs(display->getConfigs(AttributeMap()), configs, config_size, num_config); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLContext GetCurrentContext(Thread *thread) +{ + gl::Context *context = thread->getContext(); + + thread->setSuccess(); + return static_cast<EGLContext>(context); +} + +EGLDisplay GetCurrentDisplay(Thread *thread) +{ + thread->setSuccess(); + if (thread->getContext() != nullptr) + { + return thread->getContext()->getDisplay(); + } + return EGL_NO_DISPLAY; +} + +EGLSurface GetCurrentSurface(Thread *thread, EGLint readdraw) +{ + if (readdraw == EGL_READ) + { + thread->setSuccess(); + return thread->getCurrentReadSurface(); + } + else if (readdraw == EGL_DRAW) + { + thread->setSuccess(); + return thread->getCurrentDrawSurface(); + } + else + { + thread->setError(EglBadParameter(), "eglGetCurrentSurface", nullptr); + return EGL_NO_SURFACE; + } +} + +EGLDisplay GetDisplay(Thread *thread, EGLNativeDisplayType display_id) +{ + return Display::GetDisplayFromNativeDisplay(EGL_PLATFORM_ANGLE_ANGLE, display_id, + AttributeMap()); +} + +EGLint GetError(Thread *thread) +{ + EGLint error = thread->getError(); + thread->setSuccess(); + return error; +} + +EGLDisplay GetPlatformDisplay(Thread *thread, + EGLenum platform, + void *native_display, + const AttributeMap &attribMap) +{ + switch (platform) + { + case EGL_PLATFORM_ANGLE_ANGLE: + case EGL_PLATFORM_GBM_KHR: + case EGL_PLATFORM_WAYLAND_EXT: + { + return Display::GetDisplayFromNativeDisplay( + platform, gl::bitCast<EGLNativeDisplayType>(native_display), attribMap); + } + case EGL_PLATFORM_DEVICE_EXT: + { + Device *eglDevice = static_cast<Device *>(native_display); + return Display::GetDisplayFromDevice(eglDevice, attribMap); + } + default: + { + UNREACHABLE(); + return EGL_NO_DISPLAY; + } + } +} + +__eglMustCastToProperFunctionPointerType GetProcAddress(Thread *thread, const char *procname) +{ + const ProcEntry *entry = + std::lower_bound(&g_procTable[0], &g_procTable[g_numProcs], procname, CompareProc); + + thread->setSuccess(); + + if (entry == &g_procTable[g_numProcs] || strcmp(entry->first, procname) != 0) + { + return nullptr; + } + + return entry->second; +} + +EGLBoolean GetSyncAttrib(Thread *thread, + Display *display, + Sync *syncObject, + EGLint attribute, + EGLAttrib *value) +{ + EGLint valueExt; + ANGLE_EGL_TRY_RETURN(thread, GetSyncAttrib(display, syncObject, attribute, &valueExt), + "eglGetSyncAttrib", GetSyncIfValid(display, syncObject), EGL_FALSE); + *value = valueExt; + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean Initialize(Thread *thread, Display *display, EGLint *major, EGLint *minor) +{ + ANGLE_EGL_TRY_RETURN(thread, display->initialize(), "eglInitialize", GetDisplayIfValid(display), + EGL_FALSE); + + if (major) + { + *major = kEglMajorVersion; + } + if (minor) + { + *minor = kEglMinorVersion; + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean MakeCurrent(Thread *thread, + Display *display, + Surface *drawSurface, + Surface *readSurface, + gl::Context *context) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglMakeCurrent", + GetDisplayIfValid(display), EGL_FALSE); + ScopedSyncCurrentContextFromThread scopedSyncCurrent(thread); + + Surface *previousDraw = thread->getCurrentDrawSurface(); + Surface *previousRead = thread->getCurrentReadSurface(); + gl::Context *previousContext = thread->getContext(); + + // Only call makeCurrent if the context or surfaces have changed. + if (previousDraw != drawSurface || previousRead != readSurface || previousContext != context) + { + ANGLE_EGL_TRY_RETURN( + thread, + display->makeCurrent(thread, previousContext, drawSurface, readSurface, context), + "eglMakeCurrent", GetContextIfValid(display, context), EGL_FALSE); + + ANGLE_CAPTURE_EGL(EGLMakeCurrent, thread, drawSurface, readSurface, context); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLenum QueryAPI(Thread *thread) +{ + EGLenum API = thread->getAPI(); + + thread->setSuccess(); + return API; +} + +EGLBoolean QueryContext(Thread *thread, + Display *display, + gl::Context *context, + EGLint attribute, + EGLint *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryContext", + GetDisplayIfValid(display), EGL_FALSE); + QueryContextAttrib(context, attribute, value); + + thread->setSuccess(); + return EGL_TRUE; +} + +const char *QueryString(Thread *thread, Display *display, EGLint name) +{ + if (display) + { + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQueryString", + GetDisplayIfValid(display), nullptr); + } + + const char *result = nullptr; + switch (name) + { + case EGL_CLIENT_APIS: + result = display->getClientAPIString().c_str(); + break; + case EGL_EXTENSIONS: + if (display == EGL_NO_DISPLAY) + { + result = Display::GetClientExtensionString().c_str(); + } + else + { + result = display->getExtensionString().c_str(); + } + break; + case EGL_VENDOR: + result = display->getVendorString().c_str(); + break; + case EGL_VERSION: + { + static const char *sVersionString = + MakeStaticString(std::string("1.5 (ANGLE ") + angle::GetANGLEVersionString() + ")"); + result = sVersionString; + break; + } + default: + UNREACHABLE(); + break; + } + + thread->setSuccess(); + return result; +} + +EGLBoolean QuerySurface(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint attribute, + EGLint *value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglQuerySurface", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN( + thread, QuerySurfaceAttrib(display, thread->getContext(), eglSurface, attribute, value), + "eglQuerySurface", GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean ReleaseTexImage(Thread *thread, Display *display, Surface *eglSurface, EGLint buffer) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglReleaseTexImage", + GetDisplayIfValid(display), EGL_FALSE); + gl::Context *context = thread->getContext(); + if (context && !context->isContextLost()) + { + gl::Texture *texture = eglSurface->getBoundTexture(); + + if (texture) + { + ANGLE_EGL_TRY_RETURN(thread, eglSurface->releaseTexImage(thread->getContext(), buffer), + "eglReleaseTexImage", GetSurfaceIfValid(display, eglSurface), + EGL_FALSE); + ANGLE_CAPTURE_EGL(EGLReleaseTexImage, thread, eglSurface, buffer); + } + } + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean ReleaseThread(Thread *thread) +{ + ScopedSyncCurrentContextFromThread scopedSyncCurrent(thread); + + Surface *previousDraw = thread->getCurrentDrawSurface(); + Surface *previousRead = thread->getCurrentReadSurface(); + gl::Context *previousContext = thread->getContext(); + Display *previousDisplay = thread->getDisplay(); + + if (previousDisplay != EGL_NO_DISPLAY) + { + ANGLE_EGL_TRY_RETURN(thread, previousDisplay->prepareForCall(), "eglReleaseThread", + GetDisplayIfValid(previousDisplay), EGL_FALSE); + // Only call makeCurrent if the context or surfaces have changed. + if (previousDraw != EGL_NO_SURFACE || previousRead != EGL_NO_SURFACE || + previousContext != EGL_NO_CONTEXT) + { + ANGLE_EGL_TRY_RETURN( + thread, + previousDisplay->makeCurrent(thread, previousContext, nullptr, nullptr, nullptr), + "eglReleaseThread", nullptr, EGL_FALSE); + } + ANGLE_EGL_TRY_RETURN(thread, previousDisplay->releaseThread(), "eglReleaseThread", + GetDisplayIfValid(previousDisplay), EGL_FALSE); + } + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean SurfaceAttrib(Thread *thread, + Display *display, + Surface *eglSurface, + EGLint attribute, + EGLint value) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSurfaceAttrib", + GetDisplayIfValid(display), EGL_FALSE); + + ANGLE_EGL_TRY_RETURN(thread, SetSurfaceAttrib(eglSurface, attribute, value), "eglSurfaceAttrib", + GetDisplayIfValid(display), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean SwapBuffers(Thread *thread, Display *display, Surface *eglSurface) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapBuffers", + GetDisplayIfValid(display), EGL_FALSE); + + ANGLE_EGL_TRY_RETURN(thread, eglSurface->swap(thread->getContext()), "eglSwapBuffers", + GetSurfaceIfValid(display, eglSurface), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean SwapInterval(Thread *thread, Display *display, EGLint interval) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglSwapInterval", + GetDisplayIfValid(display), EGL_FALSE); + + Surface *drawSurface = static_cast<Surface *>(thread->getCurrentDrawSurface()); + const Config *surfaceConfig = drawSurface->getConfig(); + EGLint clampedInterval = std::min(std::max(interval, surfaceConfig->minSwapInterval), + surfaceConfig->maxSwapInterval); + + drawSurface->setSwapInterval(clampedInterval); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean Terminate(Thread *thread, Display *display) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglTerminate", + GetDisplayIfValid(display), EGL_FALSE); + + ScopedSyncCurrentContextFromThread scopedSyncCurrent(thread); + + ANGLE_EGL_TRY_RETURN(thread, display->terminate(thread, Display::TerminateReason::Api), + "eglTerminate", GetDisplayIfValid(display), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean WaitClient(Thread *thread) +{ + Display *display = thread->getDisplay(); + if (display == nullptr) + { + // EGL spec says this about eglWaitClient - + // If there is no current context for the current rendering API, + // the function has no effect but still returns EGL_TRUE. + return EGL_TRUE; + } + + gl::Context *context = thread->getContext(); + + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitClient", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, display->waitClient(context), "eglWaitClient", + GetContextIfValid(display, context), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean WaitGL(Thread *thread) +{ + Display *display = thread->getDisplay(); + if (display == nullptr) + { + // EGL spec says this about eglWaitGL - + // eglWaitGL is ignored if there is no current EGL rendering context for OpenGL ES. + return EGL_TRUE; + } + + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitGL", GetDisplayIfValid(display), + EGL_FALSE); + + // eglWaitGL like calling eglWaitClient with the OpenGL ES API bound. Since we only implement + // OpenGL ES we can do the call directly. + ANGLE_EGL_TRY_RETURN(thread, display->waitClient(thread->getContext()), "eglWaitGL", + GetDisplayIfValid(display), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean WaitNative(Thread *thread, EGLint engine) +{ + Display *display = thread->getDisplay(); + if (display == nullptr) + { + // EGL spec says this about eglWaitNative - + // eglWaitNative is ignored if there is no current EGL rendering context. + return EGL_TRUE; + } + + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitNative", + GetDisplayIfValid(display), EGL_FALSE); + ANGLE_EGL_TRY_RETURN(thread, display->waitNative(thread->getContext(), engine), "eglWaitNative", + GetThreadIfValid(thread), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} + +EGLBoolean WaitSync(Thread *thread, Display *display, Sync *syncObject, EGLint flags) +{ + ANGLE_EGL_TRY_RETURN(thread, display->prepareForCall(), "eglWaitSync", + GetDisplayIfValid(display), EGL_FALSE); + gl::Context *currentContext = thread->getContext(); + ANGLE_EGL_TRY_RETURN(thread, syncObject->serverWait(display, currentContext, flags), + "eglWaitSync", GetSyncIfValid(display, syncObject), EGL_FALSE); + + thread->setSuccess(); + return EGL_TRUE; +} +} // namespace egl diff --git a/gfx/angle/checkout/src/libGLESv2/egl_stubs_autogen.h b/gfx/angle/checkout/src/libGLESv2/egl_stubs_autogen.h new file mode 100644 index 0000000000..6d7d210d9d --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/egl_stubs_autogen.h @@ -0,0 +1,165 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.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. +// +// egl_stubs_autogen.h: Stubs for EGL entry points. + +#ifndef LIBGLESV2_EGL_STUBS_AUTOGEN_H_ +#define LIBGLESV2_EGL_STUBS_AUTOGEN_H_ + +#include <EGL/egl.h> +#include <EGL/eglext.h> + +#include "common/PackedEGLEnums_autogen.h" + +namespace gl +{ +class Context; +} // namespace gl + +namespace egl +{ +class AttributeMap; +class Device; +class Display; +class Image; +class Stream; +class Surface; +class Sync; +class Thread; +struct Config; + +EGLBoolean BindAPI(Thread *thread, EGLenum api); +EGLBoolean BindTexImage(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint buffer); +EGLBoolean ChooseConfig(Thread *thread, + egl::Display *dpyPacked, + const AttributeMap &attrib_listPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); +EGLint ClientWaitSync(Thread *thread, + egl::Display *dpyPacked, + Sync *syncPacked, + EGLint flags, + EGLTime timeout); +EGLBoolean CopyBuffers(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLNativePixmapType target); +EGLContext CreateContext(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + gl::Context *share_contextPacked, + const AttributeMap &attrib_listPacked); +EGLImage CreateImage(Thread *thread, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLenum target, + EGLClientBuffer buffer, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePbufferFromClientBuffer(Thread *thread, + egl::Display *dpyPacked, + EGLenum buftype, + EGLClientBuffer buffer, + Config *configPacked, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePbufferSurface(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePixmapSurface(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + EGLNativePixmapType pixmap, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePlatformPixmapSurface(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + void *native_pixmap, + const AttributeMap &attrib_listPacked); +EGLSurface CreatePlatformWindowSurface(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + void *native_window, + const AttributeMap &attrib_listPacked); +EGLSync CreateSync(Thread *thread, + egl::Display *dpyPacked, + EGLenum type, + const AttributeMap &attrib_listPacked); +EGLSurface CreateWindowSurface(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + EGLNativeWindowType win, + const AttributeMap &attrib_listPacked); +EGLBoolean DestroyContext(Thread *thread, egl::Display *dpyPacked, gl::Context *ctxPacked); +EGLBoolean DestroyImage(Thread *thread, egl::Display *dpyPacked, Image *imagePacked); +EGLBoolean DestroySurface(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked); +EGLBoolean DestroySync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked); +EGLBoolean GetConfigAttrib(Thread *thread, + egl::Display *dpyPacked, + Config *configPacked, + EGLint attribute, + EGLint *value); +EGLBoolean GetConfigs(Thread *thread, + egl::Display *dpyPacked, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); +EGLContext GetCurrentContext(Thread *thread); +EGLDisplay GetCurrentDisplay(Thread *thread); +EGLSurface GetCurrentSurface(Thread *thread, EGLint readdraw); +EGLDisplay GetDisplay(Thread *thread, EGLNativeDisplayType display_id); +EGLint GetError(Thread *thread); +EGLDisplay GetPlatformDisplay(Thread *thread, + EGLenum platform, + void *native_display, + const AttributeMap &attrib_listPacked); +__eglMustCastToProperFunctionPointerType GetProcAddress(Thread *thread, const char *procname); +EGLBoolean GetSyncAttrib(Thread *thread, + egl::Display *dpyPacked, + Sync *syncPacked, + EGLint attribute, + EGLAttrib *value); +EGLBoolean Initialize(Thread *thread, egl::Display *dpyPacked, EGLint *major, EGLint *minor); +EGLBoolean MakeCurrent(Thread *thread, + egl::Display *dpyPacked, + Surface *drawPacked, + Surface *readPacked, + gl::Context *ctxPacked); +EGLenum QueryAPI(Thread *thread); +EGLBoolean QueryContext(Thread *thread, + egl::Display *dpyPacked, + gl::Context *ctxPacked, + EGLint attribute, + EGLint *value); +const char *QueryString(Thread *thread, egl::Display *dpyPacked, EGLint name); +EGLBoolean QuerySurface(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + EGLint *value); +EGLBoolean ReleaseTexImage(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint buffer); +EGLBoolean ReleaseThread(Thread *thread); +EGLBoolean SurfaceAttrib(Thread *thread, + egl::Display *dpyPacked, + Surface *surfacePacked, + EGLint attribute, + EGLint value); +EGLBoolean SwapBuffers(Thread *thread, egl::Display *dpyPacked, Surface *surfacePacked); +EGLBoolean SwapInterval(Thread *thread, egl::Display *dpyPacked, EGLint interval); +EGLBoolean Terminate(Thread *thread, egl::Display *dpyPacked); +EGLBoolean WaitClient(Thread *thread); +EGLBoolean WaitGL(Thread *thread); +EGLBoolean WaitNative(Thread *thread, EGLint engine); +EGLBoolean WaitSync(Thread *thread, egl::Display *dpyPacked, Sync *syncPacked, EGLint flags); +} // namespace egl +#endif // LIBGLESV2_EGL_STUBS_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.cpp new file mode 100644 index 0000000000..3bd9761b1a --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.cpp @@ -0,0 +1,865 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.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_egl_autogen.cpp: +// Defines the EGL entry points. + +#include "libGLESv2/entry_points_egl_autogen.h" + +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationEGL_autogen.h" +#include "libGLESv2/egl_ext_stubs_autogen.h" +#include "libGLESv2/egl_stubs_autogen.h" +#include "libGLESv2/global_state.h" + +using namespace egl; + +extern "C" { + +// EGL 1.0 +EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy, + const EGLint *attrib_list, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ChooseConfig, + "dpy = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR ", configs = 0x%016" PRIxPTR + ", config_size = %d, num_config = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)attrib_list, (uintptr_t)configs, config_size, + (uintptr_t)num_config); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, ChooseConfig, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + attrib_listPacked, configs, config_size, num_config); + + return ChooseConfig(thread, dpyPacked, attrib_listPacked, configs, config_size, num_config); +} + +EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy, + EGLSurface surface, + EGLNativePixmapType target) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CopyBuffers, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", target = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)target); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, CopyBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, target); + + return CopyBuffers(thread, dpyPacked, surfacePacked, target); +} + +EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy, + EGLConfig config, + EGLContext share_context, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateContext, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", share_context = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)share_context, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + gl::Context *share_contextPacked = PackParam<gl::Context *>(share_context); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateContext, GetDisplayIfValid(dpyPacked), EGLContext, dpyPacked, + configPacked, share_contextPacked, attrib_listPacked); + + return CreateContext(thread, dpyPacked, configPacked, share_contextPacked, attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy, + EGLConfig config, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePbufferSurface, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePbufferSurface, GetDisplayIfValid(dpyPacked), EGLSurface, + dpyPacked, configPacked, attrib_listPacked); + + return CreatePbufferSurface(thread, dpyPacked, configPacked, attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy, + EGLConfig config, + EGLNativePixmapType pixmap, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePixmapSurface, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", pixmap = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)pixmap, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePixmapSurface, GetDisplayIfValid(dpyPacked), EGLSurface, + dpyPacked, configPacked, pixmap, attrib_listPacked); + + return CreatePixmapSurface(thread, dpyPacked, configPacked, pixmap, attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy, + EGLConfig config, + EGLNativeWindowType win, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateWindowSurface, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", win = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)win, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateWindowSurface, GetDisplayIfValid(dpyPacked), EGLSurface, + dpyPacked, configPacked, win, attrib_listPacked); + + return CreateWindowSurface(thread, dpyPacked, configPacked, win, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroyContext, "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)ctx); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + + ANGLE_EGL_VALIDATE(thread, DestroyContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + ctxPacked); + + return DestroyContext(thread, dpyPacked, ctxPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroySurface, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, DestroySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked); + + return DestroySurface(thread, dpyPacked, surfacePacked); +} + +EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy, + EGLConfig config, + EGLint attribute, + EGLint *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetConfigAttrib, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + + ANGLE_EGL_VALIDATE(thread, GetConfigAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + configPacked, attribute, value); + + return GetConfigAttrib(thread, dpyPacked, configPacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetConfigs, + "dpy = 0x%016" PRIxPTR ", configs = 0x%016" PRIxPTR + ", config_size = %d, num_config = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)configs, config_size, (uintptr_t)num_config); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, GetConfigs, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + configs, config_size, num_config); + + return GetConfigs(thread, dpyPacked, configs, config_size, num_config); +} + +EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetCurrentDisplay, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetCurrentDisplay, nullptr, EGLDisplay); + + return GetCurrentDisplay(thread); +} + +EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetCurrentSurface, "readdraw = %d", readdraw); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetCurrentSurface, nullptr, EGLSurface, readdraw); + + return GetCurrentSurface(thread, readdraw); +} + +EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetDisplay, "display_id = 0x%016" PRIxPTR "", (uintptr_t)display_id); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetDisplay, nullptr, EGLDisplay, display_id); + + return GetDisplay(thread, display_id); +} + +EGLint EGLAPIENTRY EGL_GetError() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetError, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetError, nullptr, EGLint); + + return GetError(thread); +} + +__eglMustCastToProperFunctionPointerType EGLAPIENTRY EGL_GetProcAddress(const char *procname) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetProcAddress, "procname = 0x%016" PRIxPTR "", (uintptr_t)procname); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetProcAddress, nullptr, __eglMustCastToProperFunctionPointerType, + procname); + + return GetProcAddress(thread, procname); +} + +EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(Initialize, + "dpy = 0x%016" PRIxPTR ", major = 0x%016" PRIxPTR ", minor = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)major, (uintptr_t)minor); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, Initialize, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + major, minor); + + return Initialize(thread, dpyPacked, major, minor); +} + +EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy, + EGLSurface draw, + EGLSurface read, + EGLContext ctx) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(MakeCurrent, + "dpy = 0x%016" PRIxPTR ", draw = 0x%016" PRIxPTR ", read = 0x%016" PRIxPTR + ", ctx = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)draw, (uintptr_t)read, (uintptr_t)ctx); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *drawPacked = PackParam<Surface *>(draw); + Surface *readPacked = PackParam<Surface *>(read); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + + ANGLE_EGL_VALIDATE(thread, MakeCurrent, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + drawPacked, readPacked, ctxPacked); + + return MakeCurrent(thread, dpyPacked, drawPacked, readPacked, ctxPacked); +} + +EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy, + EGLContext ctx, + EGLint attribute, + EGLint *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryContext, + "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)ctx, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + + ANGLE_EGL_VALIDATE(thread, QueryContext, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + ctxPacked, attribute, value); + + return QueryContext(thread, dpyPacked, ctxPacked, attribute, value); +} + +const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryString, "dpy = 0x%016" PRIxPTR ", name = %d", (uintptr_t)dpy, name); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryString, GetDisplayIfValid(dpyPacked), const char *, dpyPacked, + name); + + return QueryString(thread, dpyPacked, name); +} + +EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLint *value) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QuerySurface, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, QuerySurface, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, attribute, value); + + return QuerySurface(thread, dpyPacked, surfacePacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface) +{ + ANGLE_EGLBOOLEAN_TRY(PrepareSwapBuffersANGLE(dpy, surface)); + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SwapBuffers, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)surface); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffers, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked); + + return SwapBuffers(thread, dpyPacked, surfacePacked); +} + +EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(Terminate, "dpy = 0x%016" PRIxPTR "", (uintptr_t)dpy); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, Terminate, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked); + + return Terminate(thread, dpyPacked); +} + +EGLBoolean EGLAPIENTRY EGL_WaitGL() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(WaitGL, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, WaitGL, nullptr, EGLBoolean); + + return WaitGL(thread); +} + +EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(WaitNative, "engine = %d", engine); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, WaitNative, nullptr, EGLBoolean, engine); + + return WaitNative(thread, engine); +} + +// EGL 1.1 +EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(BindTexImage, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", buffer = %d", + (uintptr_t)dpy, (uintptr_t)surface, buffer); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, BindTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, buffer); + + return BindTexImage(thread, dpyPacked, surfacePacked, buffer); +} + +EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ReleaseTexImage, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", buffer = %d", + (uintptr_t)dpy, (uintptr_t)surface, buffer); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, ReleaseTexImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, buffer); + + return ReleaseTexImage(thread, dpyPacked, surfacePacked, buffer); +} + +EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLint value) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SurfaceAttrib, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", attribute = %d, value = %d", + (uintptr_t)dpy, (uintptr_t)surface, attribute, value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, SurfaceAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, attribute, value); + + return SurfaceAttrib(thread, dpyPacked, surfacePacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SwapInterval, "dpy = 0x%016" PRIxPTR ", interval = %d", (uintptr_t)dpy, interval); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, SwapInterval, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + interval); + + return SwapInterval(thread, dpyPacked, interval); +} + +// EGL 1.2 +EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(BindAPI, "api = 0x%X", api); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, BindAPI, nullptr, EGLBoolean, api); + + return BindAPI(thread, api); +} + +EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy, + EGLenum buftype, + EGLClientBuffer buffer, + EGLConfig config, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePbufferFromClientBuffer, + "dpy = 0x%016" PRIxPTR ", buftype = 0x%X, buffer = 0x%016" PRIxPTR + ", config = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, buftype, (uintptr_t)buffer, (uintptr_t)config, + (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePbufferFromClientBuffer, GetDisplayIfValid(dpyPacked), + EGLSurface, dpyPacked, buftype, buffer, configPacked, attrib_listPacked); + + return CreatePbufferFromClientBuffer(thread, dpyPacked, buftype, buffer, configPacked, + attrib_listPacked); +} + +EGLenum EGLAPIENTRY EGL_QueryAPI() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryAPI, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, QueryAPI, nullptr, EGLenum); + + return QueryAPI(thread); +} + +EGLBoolean EGLAPIENTRY EGL_ReleaseThread() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ReleaseThread, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, ReleaseThread, nullptr, EGLBoolean); + + return ReleaseThread(thread); +} + +EGLBoolean EGLAPIENTRY EGL_WaitClient() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(WaitClient, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, WaitClient, nullptr, EGLBoolean); + + return WaitClient(thread); +} + +// EGL 1.4 +EGLContext EGLAPIENTRY EGL_GetCurrentContext() +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetCurrentContext, ""); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetCurrentContext, nullptr, EGLContext); + + return GetCurrentContext(thread); +} + +// EGL 1.5 +EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ClientWaitSync, + "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d, timeout = %llu", + (uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout)); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, ClientWaitSync, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags, timeout); + + return ClientWaitSync(thread, dpyPacked, syncPacked, flags, timeout); +} + +EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateImage, + "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR + ", target = 0x%X, buffer = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)ctx, target, (uintptr_t)buffer, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateImage, GetDisplayIfValid(dpyPacked), EGLImage, dpyPacked, + ctxPacked, target, buffer, attrib_listPacked); + + return CreateImage(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy, + EGLConfig config, + void *native_pixmap, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePlatformPixmapSurface, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_pixmap = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurface, GetDisplayIfValid(dpyPacked), + EGLSurface, dpyPacked, configPacked, native_pixmap, attrib_listPacked); + + return CreatePlatformPixmapSurface(thread, dpyPacked, configPacked, native_pixmap, + attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy, + EGLConfig config, + void *native_window, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePlatformWindowSurface, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_window = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurface, GetDisplayIfValid(dpyPacked), + EGLSurface, dpyPacked, configPacked, native_window, attrib_listPacked); + + return CreatePlatformWindowSurface(thread, dpyPacked, configPacked, native_window, + attrib_listPacked); +} + +EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateSync, "dpy = 0x%016" PRIxPTR ", type = 0x%X, attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, type, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateSync, GetDisplayIfValid(dpyPacked), EGLSync, dpyPacked, type, + attrib_listPacked); + + return CreateSync(thread, dpyPacked, type, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroyImage, "dpy = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)image); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Image *imagePacked = PackParam<Image *>(image); + + ANGLE_EGL_VALIDATE(thread, DestroyImage, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + imagePacked); + + return DestroyImage(thread, dpyPacked, imagePacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroySync, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)sync); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, DestroySync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked); + + return DestroySync(thread, dpyPacked, syncPacked); +} + +EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform, + void *native_display, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetPlatformDisplay, + "platform = 0x%X, native_display = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + platform, (uintptr_t)native_display, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, GetPlatformDisplay, nullptr, EGLDisplay, platform, native_display, + attrib_listPacked); + + return GetPlatformDisplay(thread, platform, native_display, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy, + EGLSync sync, + EGLint attribute, + EGLAttrib *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetSyncAttrib, + "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, GetSyncAttrib, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, attribute, value); + + return GetSyncAttrib(thread, dpyPacked, syncPacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(WaitSync, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d", + (uintptr_t)dpy, (uintptr_t)sync, flags); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, WaitSync, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, flags); + + return WaitSync(thread, dpyPacked, syncPacked, flags); +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.h new file mode 100644 index 0000000000..407054b3e6 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_autogen.h @@ -0,0 +1,138 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.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_egl_autogen.h: +// Defines the EGL entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_EGL_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_EGL_AUTOGEN_H_ + +#include <EGL/egl.h> +#include <export.h> + +extern "C" { + +// EGL 1.0 +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ChooseConfig(EGLDisplay dpy, + const EGLint *attrib_list, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_CopyBuffers(EGLDisplay dpy, + EGLSurface surface, + EGLNativePixmapType target); +ANGLE_EXPORT EGLContext EGLAPIENTRY EGL_CreateContext(EGLDisplay dpy, + EGLConfig config, + EGLContext share_context, + const EGLint *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePbufferSurface(EGLDisplay dpy, + EGLConfig config, + const EGLint *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePixmapSurface(EGLDisplay dpy, + EGLConfig config, + EGLNativePixmapType pixmap, + const EGLint *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreateWindowSurface(EGLDisplay dpy, + EGLConfig config, + EGLNativeWindowType win, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyContext(EGLDisplay dpy, EGLContext ctx); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySurface(EGLDisplay dpy, EGLSurface surface); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetConfigAttrib(EGLDisplay dpy, + EGLConfig config, + EGLint attribute, + EGLint *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetConfigs(EGLDisplay dpy, + EGLConfig *configs, + EGLint config_size, + EGLint *num_config); +ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetCurrentDisplay(); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_GetCurrentSurface(EGLint readdraw); +ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetDisplay(EGLNativeDisplayType display_id); +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_GetError(); +ANGLE_EXPORT __eglMustCastToProperFunctionPointerType EGLAPIENTRY +EGL_GetProcAddress(const char *procname); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_Initialize(EGLDisplay dpy, EGLint *major, EGLint *minor); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_MakeCurrent(EGLDisplay dpy, + EGLSurface draw, + EGLSurface read, + EGLContext ctx); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryContext(EGLDisplay dpy, + EGLContext ctx, + EGLint attribute, + EGLint *value); +ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryString(EGLDisplay dpy, EGLint name); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QuerySurface(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLint *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapBuffers(EGLDisplay dpy, EGLSurface surface); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_Terminate(EGLDisplay dpy); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitGL(); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitNative(EGLint engine); + +// EGL 1.1 +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_BindTexImage(EGLDisplay dpy, + EGLSurface surface, + EGLint buffer); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseTexImage(EGLDisplay dpy, + EGLSurface surface, + EGLint buffer); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SurfaceAttrib(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLint value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapInterval(EGLDisplay dpy, EGLint interval); + +// EGL 1.2 +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_BindAPI(EGLenum api); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePbufferFromClientBuffer(EGLDisplay dpy, + EGLenum buftype, + EGLClientBuffer buffer, + EGLConfig config, + const EGLint *attrib_list); +ANGLE_EXPORT EGLenum EGLAPIENTRY EGL_QueryAPI(); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseThread(); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitClient(); + +// EGL 1.4 +ANGLE_EXPORT EGLContext EGLAPIENTRY EGL_GetCurrentContext(); + +// EGL 1.5 +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSync(EGLDisplay dpy, + EGLSync sync, + EGLint flags, + EGLTime timeout); +ANGLE_EXPORT EGLImage EGLAPIENTRY EGL_CreateImage(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurface(EGLDisplay dpy, + EGLConfig config, + void *native_pixmap, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurface(EGLDisplay dpy, + EGLConfig config, + void *native_window, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLSync EGLAPIENTRY EGL_CreateSync(EGLDisplay dpy, + EGLenum type, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImage(EGLDisplay dpy, EGLImage image); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySync(EGLDisplay dpy, EGLSync sync); +ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplay(EGLenum platform, + void *native_display, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttrib(EGLDisplay dpy, + EGLSync sync, + EGLint attribute, + EGLAttrib *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_WaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_EGL_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.cpp new file mode 100644 index 0000000000..c07c518e77 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.cpp @@ -0,0 +1,1403 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.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_egl_ext_autogen.cpp: +// Defines the EGL Extension entry points. + +#include "libGLESv2/entry_points_egl_ext_autogen.h" + +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationEGL_autogen.h" +#include "libGLESv2/egl_ext_stubs_autogen.h" +#include "libGLESv2/global_state.h" + +using namespace egl; + +extern "C" { + +// EGL_ANDROID_blob_cache +void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SetBlobCacheFuncsANDROID, + "dpy = 0x%016" PRIxPTR ", set = 0x%016" PRIxPTR ", get = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)set, (uintptr_t)get); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, SetBlobCacheFuncsANDROID, GetDisplayIfValid(dpyPacked), + dpyPacked, set, get); + + SetBlobCacheFuncsANDROID(thread, dpyPacked, set, get); +} + +// EGL_ANDROID_create_native_client_buffer +EGLClientBuffer EGLAPIENTRY EGL_CreateNativeClientBufferANDROID(const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateNativeClientBufferANDROID, "attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateNativeClientBufferANDROID, nullptr, EGLClientBuffer, + attrib_listPacked); + + return CreateNativeClientBufferANDROID(thread, attrib_listPacked); +} + +// EGL_ANDROID_get_frame_timestamps +EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint name) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetCompositorTimingSupportedANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", name = %d", (uintptr_t)dpy, + (uintptr_t)surface, name); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + CompositorTiming namePacked = PackParam<CompositorTiming>(name); + + ANGLE_EGL_VALIDATE(thread, GetCompositorTimingSupportedANDROID, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, surfacePacked, namePacked); + + return GetCompositorTimingSupportedANDROID(thread, dpyPacked, surfacePacked, namePacked); +} + +EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetCompositorTimingANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", numTimestamps = %d, names = 0x%016" PRIxPTR ", values = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, numTimestamps, (uintptr_t)names, + (uintptr_t)values); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, GetCompositorTimingANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, numTimestamps, names, values); + + return GetCompositorTimingANDROID(thread, dpyPacked, surfacePacked, numTimestamps, names, + values); +} + +EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR *frameId) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetNextFrameIdANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", frameId = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)frameId); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, GetNextFrameIdANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, frameId); + + return GetNextFrameIdANDROID(thread, dpyPacked, surfacePacked, frameId); +} + +EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint timestamp) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetFrameTimestampSupportedANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", timestamp = %d", + (uintptr_t)dpy, (uintptr_t)surface, timestamp); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + Timestamp timestampPacked = PackParam<Timestamp>(timestamp); + + ANGLE_EGL_VALIDATE(thread, GetFrameTimestampSupportedANDROID, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, surfacePacked, timestampPacked); + + return GetFrameTimestampSupportedANDROID(thread, dpyPacked, surfacePacked, timestampPacked); +} + +EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetFrameTimestampsANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", frameId = %llu, numTimestamps = %d, timestamps = 0x%016" PRIxPTR + ", values = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, static_cast<unsigned long long>(frameId), + numTimestamps, (uintptr_t)timestamps, (uintptr_t)values); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, GetFrameTimestampsANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, frameId, numTimestamps, timestamps, values); + + return GetFrameTimestampsANDROID(thread, dpyPacked, surfacePacked, frameId, numTimestamps, + timestamps, values); +} + +// EGL_ANDROID_get_native_client_buffer +EGLClientBuffer EGLAPIENTRY EGL_GetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetNativeClientBufferANDROID, "buffer = 0x%016" PRIxPTR "", (uintptr_t)buffer); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, GetNativeClientBufferANDROID, nullptr, EGLClientBuffer, buffer); + + return GetNativeClientBufferANDROID(thread, buffer); +} + +// EGL_ANDROID_native_fence_sync +EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DupNativeFenceFDANDROID, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)sync); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, DupNativeFenceFDANDROID, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, syncPacked); + + return DupNativeFenceFDANDROID(thread, dpyPacked, syncPacked); +} + +// EGL_ANDROID_presentation_time +EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLnsecsANDROID time) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(PresentationTimeANDROID, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", time = %llu", (uintptr_t)dpy, + (uintptr_t)surface, static_cast<unsigned long long>(time)); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, PresentationTimeANDROID, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, time); + + return PresentationTimeANDROID(thread, dpyPacked, surfacePacked, time); +} + +// EGL_ANGLE_device_creation +EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateDeviceANGLE, + "device_type = %d, native_device = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + device_type, (uintptr_t)native_device, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, CreateDeviceANGLE, nullptr, EGLDeviceEXT, device_type, native_device, + attrib_list); + + return CreateDeviceANGLE(thread, device_type, native_device, attrib_list); +} + +EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ReleaseDeviceANGLE, "device = 0x%016" PRIxPTR "", (uintptr_t)device); + + Thread *thread = egl::GetCurrentThread(); + + Device *devicePacked = PackParam<Device *>(device); + + ANGLE_EGL_VALIDATE(thread, ReleaseDeviceANGLE, nullptr, EGLBoolean, devicePacked); + + return ReleaseDeviceANGLE(thread, devicePacked); +} + +// EGL_ANGLE_feature_control +const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy, EGLint name, EGLint index) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryStringiANGLE, "dpy = 0x%016" PRIxPTR ", name = %d, index = %d", (uintptr_t)dpy, + name, index); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryStringiANGLE, GetDisplayIfValid(dpyPacked), const char *, + dpyPacked, name, index); + + return QueryStringiANGLE(thread, dpyPacked, name, index); +} + +EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy, + EGLint attribute, + EGLAttrib *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDisplayAttribANGLE, + "dpy = 0x%016" PRIxPTR ", attribute = %d, value = 0x%016" PRIxPTR "", (uintptr_t)dpy, + attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, attribute, value); + + return QueryDisplayAttribANGLE(thread, dpyPacked, attribute, value); +} + +// EGL_ANGLE_metal_shared_event_sync +void *EGLAPIENTRY EGL_CopyMetalSharedEventANGLE(EGLDisplay dpy, EGLSyncKHR sync) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CopyMetalSharedEventANGLE, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)sync); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, CopyMetalSharedEventANGLE, GetDisplayIfValid(dpyPacked), void *, + dpyPacked, syncPacked); + + return CopyMetalSharedEventANGLE(thread, dpyPacked, syncPacked); +} + +// EGL_ANGLE_power_preference +void EGLAPIENTRY EGL_ReleaseHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ReleaseHighPowerGPUANGLE, "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)ctx); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + + ANGLE_EGL_VALIDATE_VOID(thread, ReleaseHighPowerGPUANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, ctxPacked); + + ReleaseHighPowerGPUANGLE(thread, dpyPacked, ctxPacked); +} + +void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ReacquireHighPowerGPUANGLE, "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)ctx); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + + ANGLE_EGL_VALIDATE_VOID(thread, ReacquireHighPowerGPUANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, ctxPacked); + + ReacquireHighPowerGPUANGLE(thread, dpyPacked, ctxPacked); +} + +void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(HandleGPUSwitchANGLE, "dpy = 0x%016" PRIxPTR "", (uintptr_t)dpy); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, HandleGPUSwitchANGLE, GetDisplayIfValid(dpyPacked), dpyPacked); + + HandleGPUSwitchANGLE(thread, dpyPacked); +} + +void EGLAPIENTRY EGL_ForceGPUSwitchANGLE(EGLDisplay dpy, EGLint gpuIDHigh, EGLint gpuIDLow) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ForceGPUSwitchANGLE, "dpy = 0x%016" PRIxPTR ", gpuIDHigh = %d, gpuIDLow = %d", + (uintptr_t)dpy, gpuIDHigh, gpuIDLow); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, ForceGPUSwitchANGLE, GetDisplayIfValid(dpyPacked), dpyPacked, + gpuIDHigh, gpuIDLow); + + ForceGPUSwitchANGLE(thread, dpyPacked, gpuIDHigh, gpuIDLow); +} + +// EGL_ANGLE_prepare_swap_buffers +EGLBoolean EGLAPIENTRY EGL_PrepareSwapBuffersANGLE(EGLDisplay dpy, EGLSurface surface) +{ + return PrepareSwapBuffersANGLE(dpy, surface); +} + +// EGL_ANGLE_program_cache_control +EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ProgramCacheGetAttribANGLE, "dpy = 0x%016" PRIxPTR ", attrib = 0x%X", (uintptr_t)dpy, + attrib); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, ProgramCacheGetAttribANGLE, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, attrib); + + return ProgramCacheGetAttribANGLE(thread, dpyPacked, attrib); +} + +void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ProgramCacheQueryANGLE, + "dpy = 0x%016" PRIxPTR ", index = %d, key = 0x%016" PRIxPTR + ", keysize = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR + ", binarysize = 0x%016" PRIxPTR "", + (uintptr_t)dpy, index, (uintptr_t)key, (uintptr_t)keysize, (uintptr_t)binary, + (uintptr_t)binarysize); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, ProgramCacheQueryANGLE, GetDisplayIfValid(dpyPacked), dpyPacked, + index, key, keysize, binary, binarysize); + + ProgramCacheQueryANGLE(thread, dpyPacked, index, key, keysize, binary, binarysize); +} + +void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ProgramCachePopulateANGLE, + "dpy = 0x%016" PRIxPTR ", key = 0x%016" PRIxPTR + ", keysize = %d, binary = 0x%016" PRIxPTR ", binarysize = %d", + (uintptr_t)dpy, (uintptr_t)key, keysize, (uintptr_t)binary, binarysize); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE_VOID(thread, ProgramCachePopulateANGLE, GetDisplayIfValid(dpyPacked), + dpyPacked, key, keysize, binary, binarysize); + + ProgramCachePopulateANGLE(thread, dpyPacked, key, keysize, binary, binarysize); +} + +EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, EGLint limit, EGLint mode) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ProgramCacheResizeANGLE, "dpy = 0x%016" PRIxPTR ", limit = %d, mode = %d", + (uintptr_t)dpy, limit, mode); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, ProgramCacheResizeANGLE, GetDisplayIfValid(dpyPacked), EGLint, + dpyPacked, limit, mode); + + return ProgramCacheResizeANGLE(thread, dpyPacked, limit, mode); +} + +// EGL_ANGLE_query_surface_pointer +EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + void **value) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QuerySurfacePointerANGLE, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, QuerySurfacePointerANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, attribute, value); + + return QuerySurfacePointerANGLE(thread, dpyPacked, surfacePacked, attribute, value); +} + +// EGL_ANGLE_stream_producer_d3d_texture +EGLBoolean EGLAPIENTRY EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy, + EGLStreamKHR stream, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateStreamProducerD3DTextureANGLE, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateStreamProducerD3DTextureANGLE, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, streamPacked, attrib_listPacked); + + return CreateStreamProducerD3DTextureANGLE(thread, dpyPacked, streamPacked, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy, + EGLStreamKHR stream, + void *texture, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamPostD3DTextureANGLE, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR ", texture = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)texture, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, StreamPostD3DTextureANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked, texture, attrib_listPacked); + + return StreamPostD3DTextureANGLE(thread, dpyPacked, streamPacked, texture, attrib_listPacked); +} + +// EGL_ANGLE_swap_with_frame_token +EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLFrameTokenANGLE frametoken) +{ + ANGLE_EGLBOOLEAN_TRY(PrepareSwapBuffersANGLE(dpy, surface)); + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SwapBuffersWithFrameTokenANGLE, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", frametoken = 0x%llX", + (uintptr_t)dpy, (uintptr_t)surface, static_cast<unsigned long long>(frametoken)); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffersWithFrameTokenANGLE, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, surfacePacked, frametoken); + + return SwapBuffersWithFrameTokenANGLE(thread, dpyPacked, surfacePacked, frametoken); +} + +// EGL_ANGLE_sync_control_rate +EGLBoolean EGLAPIENTRY EGL_GetMscRateANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLint *numerator, + EGLint *denominator) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetMscRateANGLE, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", numerator = 0x%016" PRIxPTR + ", denominator = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)numerator, (uintptr_t)denominator); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, GetMscRateANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, numerator, denominator); + + return GetMscRateANGLE(thread, dpyPacked, surfacePacked, numerator, denominator); +} + +// EGL_ANGLE_vulkan_image +EGLBoolean EGLAPIENTRY EGL_ExportVkImageANGLE(EGLDisplay dpy, + EGLImage image, + void *vk_image, + void *vk_image_create_info) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ExportVkImageANGLE, + "dpy = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR ", vk_image = 0x%016" PRIxPTR + ", vk_image_create_info = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)image, (uintptr_t)vk_image, + (uintptr_t)vk_image_create_info); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Image *imagePacked = PackParam<Image *>(image); + + ANGLE_EGL_VALIDATE(thread, ExportVkImageANGLE, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, imagePacked, vk_image, vk_image_create_info); + + return ExportVkImageANGLE(thread, dpyPacked, imagePacked, vk_image, vk_image_create_info); +} + +// EGL_CHROMIUM_sync_control +EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetSyncValuesCHROMIUM, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", ust = 0x%016" PRIxPTR + ", msc = 0x%016" PRIxPTR ", sbc = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)ust, (uintptr_t)msc, (uintptr_t)sbc); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, GetSyncValuesCHROMIUM, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, ust, msc, sbc); + + return GetSyncValuesCHROMIUM(thread, dpyPacked, surfacePacked, ust, msc, sbc); +} + +// EGL_EXT_device_query +EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device, + EGLint attribute, + EGLAttrib *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDeviceAttribEXT, + "device = 0x%016" PRIxPTR ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)device, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + Device *devicePacked = PackParam<Device *>(device); + + ANGLE_EGL_VALIDATE(thread, QueryDeviceAttribEXT, nullptr, EGLBoolean, devicePacked, attribute, + value); + + return QueryDeviceAttribEXT(thread, devicePacked, attribute, value); +} + +const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDeviceStringEXT, "device = 0x%016" PRIxPTR ", name = %d", (uintptr_t)device, + name); + + Thread *thread = egl::GetCurrentThread(); + + Device *devicePacked = PackParam<Device *>(device); + + ANGLE_EGL_VALIDATE(thread, QueryDeviceStringEXT, nullptr, const char *, devicePacked, name); + + return QueryDeviceStringEXT(thread, devicePacked, name); +} + +EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDisplayAttribEXT, + "dpy = 0x%016" PRIxPTR ", attribute = %d, value = 0x%016" PRIxPTR "", (uintptr_t)dpy, + attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDisplayAttribEXT, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, attribute, value); + + return QueryDisplayAttribEXT(thread, dpyPacked, attribute, value); +} + +// EGL_EXT_image_dma_buf_import_modifiers +EGLBoolean EGLAPIENTRY EGL_QueryDmaBufFormatsEXT(EGLDisplay dpy, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDmaBufFormatsEXT, + "dpy = 0x%016" PRIxPTR ", max_formats = %d, formats = 0x%016" PRIxPTR + ", num_formats = 0x%016" PRIxPTR "", + (uintptr_t)dpy, max_formats, (uintptr_t)formats, (uintptr_t)num_formats); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDmaBufFormatsEXT, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, max_formats, formats, num_formats); + + return QueryDmaBufFormatsEXT(thread, dpyPacked, max_formats, formats, num_formats); +} + +EGLBoolean EGLAPIENTRY EGL_QueryDmaBufModifiersEXT(EGLDisplay dpy, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDmaBufModifiersEXT, + "dpy = 0x%016" PRIxPTR ", format = %d, max_modifiers = %d, modifiers = 0x%016" PRIxPTR + ", external_only = 0x%016" PRIxPTR ", num_modifiers = 0x%016" PRIxPTR "", + (uintptr_t)dpy, format, max_modifiers, (uintptr_t)modifiers, (uintptr_t)external_only, + (uintptr_t)num_modifiers); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + + ANGLE_EGL_VALIDATE(thread, QueryDmaBufModifiersEXT, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, format, max_modifiers, modifiers, external_only, num_modifiers); + + return QueryDmaBufModifiersEXT(thread, dpyPacked, format, max_modifiers, modifiers, + external_only, num_modifiers); +} + +// EGL_EXT_platform_base +EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, + EGLConfig config, + void *native_pixmap, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePlatformPixmapSurfaceEXT, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_pixmap = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_pixmap, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePlatformPixmapSurfaceEXT, GetDisplayIfValid(dpyPacked), + EGLSurface, dpyPacked, configPacked, native_pixmap, attrib_listPacked); + + return CreatePlatformPixmapSurfaceEXT(thread, dpyPacked, configPacked, native_pixmap, + attrib_listPacked); +} + +EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, + EGLConfig config, + void *native_window, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreatePlatformWindowSurfaceEXT, + "dpy = 0x%016" PRIxPTR ", config = 0x%016" PRIxPTR ", native_window = 0x%016" PRIxPTR + ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)config, (uintptr_t)native_window, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Config *configPacked = PackParam<Config *>(config); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreatePlatformWindowSurfaceEXT, GetDisplayIfValid(dpyPacked), + EGLSurface, dpyPacked, configPacked, native_window, attrib_listPacked); + + return CreatePlatformWindowSurfaceEXT(thread, dpyPacked, configPacked, native_window, + attrib_listPacked); +} + +EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform, + void *native_display, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetPlatformDisplayEXT, + "platform = 0x%X, native_display = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + platform, (uintptr_t)native_display, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, GetPlatformDisplayEXT, nullptr, EGLDisplay, platform, native_display, + attrib_listPacked); + + return GetPlatformDisplayEXT(thread, platform, native_display, attrib_listPacked); +} + +// EGL_KHR_debug +EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DebugMessageControlKHR, + "callback = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", (uintptr_t)callback, + (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, DebugMessageControlKHR, nullptr, EGLint, callback, + attrib_listPacked); + + return DebugMessageControlKHR(thread, callback, attrib_listPacked); +} + +EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display, + EGLenum objectType, + EGLObjectKHR object, + EGLLabelKHR label) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(LabelObjectKHR, + "display = 0x%016" PRIxPTR ", objectType = 0x%X, object = 0x%016" PRIxPTR + ", label = 0x%016" PRIxPTR "", + (uintptr_t)display, objectType, (uintptr_t)object, (uintptr_t)label); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *displayPacked = PackParam<egl::Display *>(display); + ObjectType objectTypePacked = PackParam<ObjectType>(objectType); + + ANGLE_EGL_VALIDATE(thread, LabelObjectKHR, GetDisplayIfValid(displayPacked), EGLint, + displayPacked, objectTypePacked, object, label); + + return LabelObjectKHR(thread, displayPacked, objectTypePacked, object, label); +} + +EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryDebugKHR, "attribute = %d, value = 0x%016" PRIxPTR "", attribute, + (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + ANGLE_EGL_VALIDATE(thread, QueryDebugKHR, nullptr, EGLBoolean, attribute, value); + + return QueryDebugKHR(thread, attribute, value); +} + +// EGL_KHR_fence_sync +EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLint flags, + EGLTimeKHR timeout) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(ClientWaitSyncKHR, + "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d, timeout = %llu", + (uintptr_t)dpy, (uintptr_t)sync, flags, static_cast<unsigned long long>(timeout)); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, ClientWaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags, timeout); + + return ClientWaitSyncKHR(thread, dpyPacked, syncPacked, flags, timeout); +} + +EGLSyncKHR EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateSyncKHR, + "dpy = 0x%016" PRIxPTR ", type = 0x%X, attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, type, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateSyncKHR, GetDisplayIfValid(dpyPacked), EGLSyncKHR, dpyPacked, + type, attrib_listPacked); + + return CreateSyncKHR(thread, dpyPacked, type, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroySyncKHR, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)sync); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, DestroySyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked); + + return DestroySyncKHR(thread, dpyPacked, syncPacked); +} + +EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLint attribute, + EGLint *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(GetSyncAttribKHR, + "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)sync, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, GetSyncAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, syncPacked, attribute, value); + + return GetSyncAttribKHR(thread, dpyPacked, syncPacked, attribute, value); +} + +// EGL_KHR_image +EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateImageKHR, + "dpy = 0x%016" PRIxPTR ", ctx = 0x%016" PRIxPTR + ", target = 0x%X, buffer = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)ctx, target, (uintptr_t)buffer, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + gl::Context *ctxPacked = PackParam<gl::Context *>(ctx); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateImageKHR, GetDisplayIfValid(dpyPacked), EGLImageKHR, dpyPacked, + ctxPacked, target, buffer, attrib_listPacked); + + return CreateImageKHR(thread, dpyPacked, ctxPacked, target, buffer, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroyImageKHR, "dpy = 0x%016" PRIxPTR ", image = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)image); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Image *imagePacked = PackParam<Image *>(image); + + ANGLE_EGL_VALIDATE(thread, DestroyImageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + imagePacked); + + return DestroyImageKHR(thread, dpyPacked, imagePacked); +} + +// EGL_KHR_lock_surface3 +EGLBoolean EGLAPIENTRY EGL_LockSurfaceKHR(EGLDisplay dpy, + EGLSurface surface, + const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(LockSurfaceKHR, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, LockSurfaceKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, attrib_listPacked); + + return LockSurfaceKHR(thread, dpyPacked, surfacePacked, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_QuerySurface64KHR(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLAttribKHR *value) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QuerySurface64KHR, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", attribute = %d, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, QuerySurface64KHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, attribute, value); + + return QuerySurface64KHR(thread, dpyPacked, surfacePacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_UnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(UnlockSurfaceKHR, "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)surface); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, UnlockSurfaceKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked); + + return UnlockSurfaceKHR(thread, dpyPacked, surfacePacked); +} + +// EGL_KHR_partial_update +EGLBoolean EGLAPIENTRY EGL_SetDamageRegionKHR(EGLDisplay dpy, + EGLSurface surface, + EGLint *rects, + EGLint n_rects) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SetDamageRegionKHR, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", rects = 0x%016" PRIxPTR + ", n_rects = %d", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)rects, n_rects); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, SetDamageRegionKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, rects, n_rects); + + return SetDamageRegionKHR(thread, dpyPacked, surfacePacked, rects, n_rects); +} + +// EGL_KHR_reusable_sync +EGLBoolean EGLAPIENTRY EGL_SignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SignalSyncKHR, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", mode = 0x%X", + (uintptr_t)dpy, (uintptr_t)sync, mode); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, SignalSyncKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + syncPacked, mode); + + return SignalSyncKHR(thread, dpyPacked, syncPacked, mode); +} + +// ClientWaitSyncKHR is already defined. + +// CreateSyncKHR is already defined. + +// DestroySyncKHR is already defined. + +// GetSyncAttribKHR is already defined. + +// EGL_KHR_stream +EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, const EGLint *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(CreateStreamKHR, "dpy = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, CreateStreamKHR, GetDisplayIfValid(dpyPacked), EGLStreamKHR, + dpyPacked, attrib_listPacked); + + return CreateStreamKHR(thread, dpyPacked, attrib_listPacked); +} + +EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(DestroyStreamKHR, "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, DestroyStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); + + return DestroyStreamKHR(thread, dpyPacked, streamPacked); +} + +EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLint *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryStreamKHR, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR + ", attribute = 0x%X, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, QueryStreamKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + streamPacked, attribute, value); + + return QueryStreamKHR(thread, dpyPacked, streamPacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLuint64KHR *value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(QueryStreamu64KHR, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR + ", attribute = 0x%X, value = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream, attribute, (uintptr_t)value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, QueryStreamu64KHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked, attribute, value); + + return QueryStreamu64KHR(thread, dpyPacked, streamPacked, attribute, value); +} + +EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLint value) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamAttribKHR, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR ", attribute = 0x%X, value = %d", + (uintptr_t)dpy, (uintptr_t)stream, attribute, value); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, StreamAttribKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + streamPacked, attribute, value); + + return StreamAttribKHR(thread, dpyPacked, streamPacked, attribute, value); +} + +// EGL_KHR_stream_consumer_gltexture +EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, EGLStreamKHR stream) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamConsumerAcquireKHR, "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerAcquireKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); + + return StreamConsumerAcquireKHR(thread, dpyPacked, streamPacked); +} + +EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, EGLStreamKHR stream) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamConsumerGLTextureExternalKHR, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR "", (uintptr_t)dpy, + (uintptr_t)stream); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalKHR, GetDisplayIfValid(dpyPacked), + EGLBoolean, dpyPacked, streamPacked); + + return StreamConsumerGLTextureExternalKHR(thread, dpyPacked, streamPacked); +} + +EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, EGLStreamKHR stream) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamConsumerReleaseKHR, "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR "", + (uintptr_t)dpy, (uintptr_t)stream); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerReleaseKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, streamPacked); + + return StreamConsumerReleaseKHR(thread, dpyPacked, streamPacked); +} + +// EGL_KHR_swap_buffers_with_damage +EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy, + EGLSurface surface, + const EGLint *rects, + EGLint n_rects) +{ + ANGLE_EGLBOOLEAN_TRY(PrepareSwapBuffersANGLE(dpy, surface)); + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(SwapBuffersWithDamageKHR, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR ", rects = 0x%016" PRIxPTR + ", n_rects = %d", + (uintptr_t)dpy, (uintptr_t)surface, (uintptr_t)rects, n_rects); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, SwapBuffersWithDamageKHR, GetDisplayIfValid(dpyPacked), EGLBoolean, + dpyPacked, surfacePacked, rects, n_rects); + + return SwapBuffersWithDamageKHR(thread, dpyPacked, surfacePacked, rects, n_rects); +} + +// EGL_KHR_wait_sync +EGLint EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(WaitSyncKHR, "dpy = 0x%016" PRIxPTR ", sync = 0x%016" PRIxPTR ", flags = %d", + (uintptr_t)dpy, (uintptr_t)sync, flags); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Sync *syncPacked = PackParam<Sync *>(sync); + + ANGLE_EGL_VALIDATE(thread, WaitSyncKHR, GetDisplayIfValid(dpyPacked), EGLint, dpyPacked, + syncPacked, flags); + + return WaitSyncKHR(thread, dpyPacked, syncPacked, flags); +} + +// EGL_NV_post_sub_buffer +EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy, + EGLSurface surface, + EGLint x, + EGLint y, + EGLint width, + EGLint height) +{ + + ANGLE_SCOPED_GLOBAL_SURFACE_LOCK(); + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(PostSubBufferNV, + "dpy = 0x%016" PRIxPTR ", surface = 0x%016" PRIxPTR + ", x = %d, y = %d, width = %d, height = %d", + (uintptr_t)dpy, (uintptr_t)surface, x, y, width, height); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Surface *surfacePacked = PackParam<Surface *>(surface); + + ANGLE_EGL_VALIDATE(thread, PostSubBufferNV, GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, + surfacePacked, x, y, width, height); + + return PostSubBufferNV(thread, dpyPacked, surfacePacked, x, y, width, height); +} + +// EGL_NV_stream_consumer_gltexture_yuv +EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy, + EGLStreamKHR stream, + const EGLAttrib *attrib_list) +{ + + ANGLE_SCOPED_GLOBAL_LOCK(); + EGL_EVENT(StreamConsumerGLTextureExternalAttribsNV, + "dpy = 0x%016" PRIxPTR ", stream = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR + "", + (uintptr_t)dpy, (uintptr_t)stream, (uintptr_t)attrib_list); + + Thread *thread = egl::GetCurrentThread(); + + egl::Display *dpyPacked = PackParam<egl::Display *>(dpy); + Stream *streamPacked = PackParam<Stream *>(stream); + const AttributeMap &attrib_listPacked = PackParam<const AttributeMap &>(attrib_list); + + ANGLE_EGL_VALIDATE(thread, StreamConsumerGLTextureExternalAttribsNV, + GetDisplayIfValid(dpyPacked), EGLBoolean, dpyPacked, streamPacked, + attrib_listPacked); + + return StreamConsumerGLTextureExternalAttribsNV(thread, dpyPacked, streamPacked, + attrib_listPacked); +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.h new file mode 100644 index 0000000000..b109973534 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_egl_ext_autogen.h @@ -0,0 +1,284 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from egl.xml and egl_angle_ext.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_egl_ext_autogen.h: +// Defines the EGL Extension entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_EGL_EXT_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_EGL_EXT_AUTOGEN_H_ + +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <export.h> + +extern "C" { + +// EGL_ANDROID_blob_cache +ANGLE_EXPORT void EGLAPIENTRY EGL_SetBlobCacheFuncsANDROID(EGLDisplay dpy, + EGLSetBlobFuncANDROID set, + EGLGetBlobFuncANDROID get); + +// EGL_ANDROID_create_native_client_buffer +ANGLE_EXPORT EGLClientBuffer EGLAPIENTRY +EGL_CreateNativeClientBufferANDROID(const EGLint *attrib_list); + +// EGL_ANDROID_get_frame_timestamps +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingSupportedANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint name); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetCompositorTimingANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint numTimestamps, + const EGLint *names, + EGLnsecsANDROID *values); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetNextFrameIdANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR *frameId); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampSupportedANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLint timestamp); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetFrameTimestampsANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR frameId, + EGLint numTimestamps, + const EGLint *timestamps, + EGLnsecsANDROID *values); + +// EGL_ANDROID_get_native_client_buffer +ANGLE_EXPORT EGLClientBuffer EGLAPIENTRY +EGL_GetNativeClientBufferANDROID(const struct AHardwareBuffer *buffer); + +// EGL_ANDROID_native_fence_sync +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_DupNativeFenceFDANDROID(EGLDisplay dpy, EGLSyncKHR sync); + +// EGL_ANDROID_presentation_time +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_PresentationTimeANDROID(EGLDisplay dpy, + EGLSurface surface, + EGLnsecsANDROID time); + +// EGL_ANGLE_device_creation +ANGLE_EXPORT EGLDeviceEXT EGLAPIENTRY EGL_CreateDeviceANGLE(EGLint device_type, + void *native_device, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ReleaseDeviceANGLE(EGLDeviceEXT device); + +// EGL_ANGLE_feature_control +ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryStringiANGLE(EGLDisplay dpy, + EGLint name, + EGLint index); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribANGLE(EGLDisplay dpy, + EGLint attribute, + EGLAttrib *value); + +// EGL_ANGLE_metal_shared_event_sync +ANGLE_EXPORT void *EGLAPIENTRY EGL_CopyMetalSharedEventANGLE(EGLDisplay dpy, EGLSyncKHR sync); + +// EGL_ANGLE_power_preference +ANGLE_EXPORT void EGLAPIENTRY EGL_ReleaseHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx); +ANGLE_EXPORT void EGLAPIENTRY EGL_ReacquireHighPowerGPUANGLE(EGLDisplay dpy, EGLContext ctx); +ANGLE_EXPORT void EGLAPIENTRY EGL_HandleGPUSwitchANGLE(EGLDisplay dpy); +ANGLE_EXPORT void EGLAPIENTRY EGL_ForceGPUSwitchANGLE(EGLDisplay dpy, + EGLint gpuIDHigh, + EGLint gpuIDLow); + +// EGL_ANGLE_prepare_swap_buffers +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_PrepareSwapBuffersANGLE(EGLDisplay dpy, EGLSurface surface); + +// EGL_ANGLE_program_cache_control +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ProgramCacheGetAttribANGLE(EGLDisplay dpy, EGLenum attrib); +ANGLE_EXPORT void EGLAPIENTRY EGL_ProgramCacheQueryANGLE(EGLDisplay dpy, + EGLint index, + void *key, + EGLint *keysize, + void *binary, + EGLint *binarysize); +ANGLE_EXPORT void EGLAPIENTRY EGL_ProgramCachePopulateANGLE(EGLDisplay dpy, + const void *key, + EGLint keysize, + const void *binary, + EGLint binarysize); +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ProgramCacheResizeANGLE(EGLDisplay dpy, + EGLint limit, + EGLint mode); + +// EGL_ANGLE_query_surface_pointer +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QuerySurfacePointerANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + void **value); + +// EGL_ANGLE_stream_producer_d3d_texture +ANGLE_EXPORT EGLBoolean EGLAPIENTRY +EGL_CreateStreamProducerD3DTextureANGLE(EGLDisplay dpy, + EGLStreamKHR stream, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamPostD3DTextureANGLE(EGLDisplay dpy, + EGLStreamKHR stream, + void *texture, + const EGLAttrib *attrib_list); + +// EGL_ANGLE_swap_with_frame_token +ANGLE_EXPORT EGLBoolean EGLAPIENTRY +EGL_SwapBuffersWithFrameTokenANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLFrameTokenANGLE frametoken); + +// EGL_ANGLE_sync_control_rate +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetMscRateANGLE(EGLDisplay dpy, + EGLSurface surface, + EGLint *numerator, + EGLint *denominator); + +// EGL_ANGLE_vulkan_image +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_ExportVkImageANGLE(EGLDisplay dpy, + EGLImage image, + void *vk_image, + void *vk_image_create_info); + +// EGL_CHROMIUM_sync_control +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncValuesCHROMIUM(EGLDisplay dpy, + EGLSurface surface, + EGLuint64KHR *ust, + EGLuint64KHR *msc, + EGLuint64KHR *sbc); + +// EGL_EXT_device_query +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDeviceAttribEXT(EGLDeviceEXT device, + EGLint attribute, + EGLAttrib *value); +ANGLE_EXPORT const char *EGLAPIENTRY EGL_QueryDeviceStringEXT(EGLDeviceEXT device, EGLint name); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDisplayAttribEXT(EGLDisplay dpy, + EGLint attribute, + EGLAttrib *value); + +// EGL_EXT_image_dma_buf_import_modifiers +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDmaBufFormatsEXT(EGLDisplay dpy, + EGLint max_formats, + EGLint *formats, + EGLint *num_formats); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDmaBufModifiersEXT(EGLDisplay dpy, + EGLint format, + EGLint max_modifiers, + EGLuint64KHR *modifiers, + EGLBoolean *external_only, + EGLint *num_modifiers); + +// EGL_EXT_platform_base +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformPixmapSurfaceEXT(EGLDisplay dpy, + EGLConfig config, + void *native_pixmap, + const EGLint *attrib_list); +ANGLE_EXPORT EGLSurface EGLAPIENTRY EGL_CreatePlatformWindowSurfaceEXT(EGLDisplay dpy, + EGLConfig config, + void *native_window, + const EGLint *attrib_list); +ANGLE_EXPORT EGLDisplay EGLAPIENTRY EGL_GetPlatformDisplayEXT(EGLenum platform, + void *native_display, + const EGLint *attrib_list); + +// EGL_KHR_debug +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_DebugMessageControlKHR(EGLDEBUGPROCKHR callback, + const EGLAttrib *attrib_list); +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_LabelObjectKHR(EGLDisplay display, + EGLenum objectType, + EGLObjectKHR object, + EGLLabelKHR label); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryDebugKHR(EGLint attribute, EGLAttrib *value); + +// EGL_KHR_fence_sync +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_ClientWaitSyncKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLint flags, + EGLTimeKHR timeout); +ANGLE_EXPORT EGLSyncKHR EGLAPIENTRY EGL_CreateSyncKHR(EGLDisplay dpy, + EGLenum type, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_GetSyncAttribKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLint attribute, + EGLint *value); + +// EGL_KHR_image +ANGLE_EXPORT EGLImageKHR EGLAPIENTRY EGL_CreateImageKHR(EGLDisplay dpy, + EGLContext ctx, + EGLenum target, + EGLClientBuffer buffer, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyImageKHR(EGLDisplay dpy, EGLImageKHR image); + +// EGL_KHR_lock_surface3 +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_LockSurfaceKHR(EGLDisplay dpy, + EGLSurface surface, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QuerySurface64KHR(EGLDisplay dpy, + EGLSurface surface, + EGLint attribute, + EGLAttribKHR *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_UnlockSurfaceKHR(EGLDisplay dpy, EGLSurface surface); + +// EGL_KHR_partial_update +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SetDamageRegionKHR(EGLDisplay dpy, + EGLSurface surface, + EGLint *rects, + EGLint n_rects); + +// EGL_KHR_reusable_sync +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SignalSyncKHR(EGLDisplay dpy, + EGLSyncKHR sync, + EGLenum mode); + +// EGL_KHR_stream +ANGLE_EXPORT EGLStreamKHR EGLAPIENTRY EGL_CreateStreamKHR(EGLDisplay dpy, + const EGLint *attrib_list); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_DestroyStreamKHR(EGLDisplay dpy, EGLStreamKHR stream); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryStreamKHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLint *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_QueryStreamu64KHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLuint64KHR *value); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamAttribKHR(EGLDisplay dpy, + EGLStreamKHR stream, + EGLenum attribute, + EGLint value); + +// EGL_KHR_stream_consumer_gltexture +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerAcquireKHR(EGLDisplay dpy, + EGLStreamKHR stream); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerGLTextureExternalKHR(EGLDisplay dpy, + EGLStreamKHR stream); +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_StreamConsumerReleaseKHR(EGLDisplay dpy, + EGLStreamKHR stream); + +// EGL_KHR_swap_buffers_with_damage +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_SwapBuffersWithDamageKHR(EGLDisplay dpy, + EGLSurface surface, + const EGLint *rects, + EGLint n_rects); + +// EGL_KHR_wait_sync +ANGLE_EXPORT EGLint EGLAPIENTRY EGL_WaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags); + +// EGL_NV_post_sub_buffer +ANGLE_EXPORT EGLBoolean EGLAPIENTRY EGL_PostSubBufferNV(EGLDisplay dpy, + EGLSurface surface, + EGLint x, + EGLint y, + EGLint width, + EGLint height); + +// EGL_NV_stream_consumer_gltexture_yuv +ANGLE_EXPORT EGLBoolean EGLAPIENTRY +EGL_StreamConsumerGLTextureExternalAttribsNV(EGLDisplay dpy, + EGLStreamKHR stream, + const EGLAttrib *attrib_list); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_EGL_EXT_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp new file mode 100644 index 0000000000..243d630881 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.cpp @@ -0,0 +1,2116 @@ +// 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_1_0_autogen.cpp: +// Defines the GLES 1.0 entry points. + +#include "libGLESv2/entry_points_gles_1_0_autogen.h" + +#include "common/entry_points_enum_autogen.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/capture/capture_gles_1_0_autogen.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationES1.h" +#include "libGLESv2/global_state.h" + +using namespace gl; + +extern "C" { +void GL_APIENTRY GL_AlphaFunc(GLenum func, GLfloat ref) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLAlphaFunc, "context = %d, func = %s, ref = %f", CID(context), + GLenumToString(GLESEnum::AlphaFunction, func), ref); + + if (context) + { + AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateAlphaFunc(context, angle::EntryPoint::GLAlphaFunc, funcPacked, ref)); + if (isCallValid) + { + context->alphaFunc(funcPacked, ref); + } + ANGLE_CAPTURE_GL(AlphaFunc, isCallValid, context, funcPacked, ref); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_AlphaFuncx(GLenum func, GLfixed ref) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLAlphaFuncx, "context = %d, func = %s, ref = 0x%X", CID(context), + GLenumToString(GLESEnum::AlphaFunction, func), ref); + + if (context) + { + AlphaTestFunc funcPacked = PackParam<AlphaTestFunc>(func); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateAlphaFuncx(context, angle::EntryPoint::GLAlphaFuncx, funcPacked, ref)); + if (isCallValid) + { + context->alphaFuncx(funcPacked, ref); + } + ANGLE_CAPTURE_GL(AlphaFuncx, isCallValid, context, funcPacked, ref); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearColorx, + "context = %d, red = 0x%X, green = 0x%X, blue = 0x%X, alpha = 0x%X", CID(context), red, + green, blue, alpha); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearColorx(context, angle::EntryPoint::GLClearColorx, red, + green, blue, alpha)); + if (isCallValid) + { + context->clearColorx(red, green, blue, alpha); + } + ANGLE_CAPTURE_GL(ClearColorx, isCallValid, context, red, green, blue, alpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearDepthx(GLfixed depth) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearDepthx, "context = %d, depth = 0x%X", CID(context), depth); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearDepthx(context, angle::EntryPoint::GLClearDepthx, depth)); + if (isCallValid) + { + context->clearDepthx(depth); + } + ANGLE_CAPTURE_GL(ClearDepthx, isCallValid, context, depth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClientActiveTexture(GLenum texture) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClientActiveTexture, "context = %d, texture = %s", CID(context), + GLenumToString(GLESEnum::TextureUnit, texture)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClientActiveTexture( + context, angle::EntryPoint::GLClientActiveTexture, texture)); + if (isCallValid) + { + context->clientActiveTexture(texture); + } + ANGLE_CAPTURE_GL(ClientActiveTexture, isCallValid, context, texture); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClipPlanef(GLenum p, const GLfloat *eqn) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClipPlanef, "context = %d, p = %s, eqn = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::ClipPlaneName, p), (uintptr_t)eqn); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClipPlanef(context, angle::EntryPoint::GLClipPlanef, p, eqn)); + if (isCallValid) + { + context->clipPlanef(p, eqn); + } + ANGLE_CAPTURE_GL(ClipPlanef, isCallValid, context, p, eqn); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClipPlanex(GLenum plane, const GLfixed *equation) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateClipPlanex(context, angle::EntryPoint::GLClipPlanex, plane, equation)); + if (isCallValid) + { + context->clipPlanex(plane, equation); + } + ANGLE_CAPTURE_GL(ClipPlanex, isCallValid, context, plane, equation); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColor4f, "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() || + ValidateColor4f(context, angle::EntryPoint::GLColor4f, red, green, blue, alpha)); + if (isCallValid) + { + context->color4f(red, green, blue, alpha); + } + ANGLE_CAPTURE_GL(Color4f, isCallValid, context, red, green, blue, alpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColor4ub, "context = %d, red = %d, green = %d, blue = %d, alpha = %d", + CID(context), red, green, blue, alpha); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateColor4ub(context, angle::EntryPoint::GLColor4ub, red, green, blue, alpha)); + if (isCallValid) + { + context->color4ub(red, green, blue, alpha); + } + ANGLE_CAPTURE_GL(Color4ub, isCallValid, context, red, green, blue, alpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColor4x, "context = %d, red = 0x%X, green = 0x%X, blue = 0x%X, alpha = 0x%X", + CID(context), red, green, blue, alpha); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateColor4x(context, angle::EntryPoint::GLColor4x, red, green, blue, alpha)); + if (isCallValid) + { + context->color4x(red, green, blue, alpha); + } + ANGLE_CAPTURE_GL(Color4x, isCallValid, context, red, green, blue, alpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColorPointer, + "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", + CID(context), size, GLenumToString(GLESEnum::ColorPointerType, type), stride, + (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateColorPointer(context, angle::EntryPoint::GLColorPointer, size, + typePacked, stride, pointer)); + if (isCallValid) + { + context->colorPointer(size, typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(ColorPointer, isCallValid, context, size, typePacked, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DepthRangex(GLfixed n, GLfixed f) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDepthRangex, "context = %d, n = 0x%X, f = 0x%X", CID(context), n, f); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDepthRangex(context, angle::EntryPoint::GLDepthRangex, n, f)); + if (isCallValid) + { + context->depthRangex(n, f); + } + ANGLE_CAPTURE_GL(DepthRangex, isCallValid, context, n, f); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DisableClientState(GLenum array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDisableClientState, "context = %d, array = %s", CID(context), + GLenumToString(GLESEnum::EnableCap, array)); + + if (context) + { + ClientVertexArrayType arrayPacked = PackParam<ClientVertexArrayType>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDisableClientState( + context, angle::EntryPoint::GLDisableClientState, arrayPacked)); + if (isCallValid) + { + context->disableClientState(arrayPacked); + } + ANGLE_CAPTURE_GL(DisableClientState, isCallValid, context, arrayPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EnableClientState(GLenum array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEnableClientState, "context = %d, array = %s", CID(context), + GLenumToString(GLESEnum::EnableCap, array)); + + if (context) + { + ClientVertexArrayType arrayPacked = PackParam<ClientVertexArrayType>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEnableClientState( + context, angle::EntryPoint::GLEnableClientState, arrayPacked)); + if (isCallValid) + { + context->enableClientState(arrayPacked); + } + ANGLE_CAPTURE_GL(EnableClientState, isCallValid, context, arrayPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Fogf(GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFogf, "context = %d, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::FogParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFogf(context, angle::EntryPoint::GLFogf, pname, param)); + if (isCallValid) + { + context->fogf(pname, param); + } + ANGLE_CAPTURE_GL(Fogf, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Fogfv(GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFogfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::FogParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFogfv(context, angle::EntryPoint::GLFogfv, pname, params)); + if (isCallValid) + { + context->fogfv(pname, params); + } + ANGLE_CAPTURE_GL(Fogfv, isCallValid, context, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Fogx(GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFogx, "context = %d, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::FogPName, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFogx(context, angle::EntryPoint::GLFogx, pname, param)); + if (isCallValid) + { + context->fogx(pname, param); + } + ANGLE_CAPTURE_GL(Fogx, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Fogxv(GLenum pname, const GLfixed *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFogxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::FogPName, pname), (uintptr_t)param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFogxv(context, angle::EntryPoint::GLFogxv, pname, param)); + if (isCallValid) + { + context->fogxv(pname, param); + } + ANGLE_CAPTURE_GL(Fogxv, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFrustumf, "context = %d, l = %f, r = %f, b = %f, t = %f, n = %f, f = %f", + CID(context), l, r, b, t, n, f); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFrustumf(context, angle::EntryPoint::GLFrustumf, l, r, b, t, n, f)); + if (isCallValid) + { + context->frustumf(l, r, b, t, n, f); + } + ANGLE_CAPTURE_GL(Frustumf, isCallValid, context, l, r, b, t, n, f); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFrustumx, + "context = %d, l = 0x%X, r = 0x%X, b = 0x%X, t = 0x%X, n = 0x%X, f = 0x%X", CID(context), + l, r, b, t, n, f); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFrustumx(context, angle::EntryPoint::GLFrustumx, l, r, b, t, n, f)); + if (isCallValid) + { + context->frustumx(l, r, b, t, n, f); + } + ANGLE_CAPTURE_GL(Frustumx, isCallValid, context, l, r, b, t, n, f); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetClipPlanef(GLenum plane, GLfloat *equation) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetClipPlanef, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetClipPlanef(context, angle::EntryPoint::GLGetClipPlanef, plane, equation)); + if (isCallValid) + { + context->getClipPlanef(plane, equation); + } + ANGLE_CAPTURE_GL(GetClipPlanef, isCallValid, context, plane, equation); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetClipPlanex(GLenum plane, GLfixed *equation) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetClipPlanex, "context = %d, plane = %s, equation = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::ClipPlaneName, plane), (uintptr_t)equation); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetClipPlanex(context, angle::EntryPoint::GLGetClipPlanex, plane, equation)); + if (isCallValid) + { + context->getClipPlanex(plane, equation); + } + ANGLE_CAPTURE_GL(GetClipPlanex, isCallValid, context, plane, equation); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFixedv(GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFixedv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::GetPName, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetFixedv(context, angle::EntryPoint::GLGetFixedv, pname, params)); + if (isCallValid) + { + context->getFixedv(pname, params); + } + ANGLE_CAPTURE_GL(GetFixedv, isCallValid, context, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetLightfv(GLenum light, GLenum pname, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetLightfv(context, angle::EntryPoint::GLGetLightfv, light, + pnamePacked, params)); + if (isCallValid) + { + context->getLightfv(light, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetLightfv, isCallValid, context, light, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetLightxv(GLenum light, GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetLightxv(context, angle::EntryPoint::GLGetLightxv, light, + pnamePacked, params)); + if (isCallValid) + { + context->getLightxv(light, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetLightxv, isCallValid, context, light, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMaterialfv, + "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetMaterialfv(context, angle::EntryPoint::GLGetMaterialfv, face, + pnamePacked, params)); + if (isCallValid) + { + context->getMaterialfv(face, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetMaterialfv, isCallValid, context, face, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMaterialxv, + "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetMaterialxv(context, angle::EntryPoint::GLGetMaterialxv, face, + pnamePacked, params)); + if (isCallValid) + { + context->getMaterialxv(face, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetMaterialxv, isCallValid, context, face, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexEnvfv, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexEnvfv(context, angle::EntryPoint::GLGetTexEnvfv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->getTexEnvfv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetTexEnvfv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexEnviv(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexEnviv, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexEnviv(context, angle::EntryPoint::GLGetTexEnviv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->getTexEnviv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetTexEnviv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexEnvxv, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexEnvxv(context, angle::EntryPoint::GLGetTexEnvxv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->getTexEnvxv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(GetTexEnvxv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterxv, + "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() || + ValidateGetTexParameterxv(context, angle::EntryPoint::GLGetTexParameterxv, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterxv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterxv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LightModelf(GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightModelf, "context = %d, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::LightModelParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightModelf(context, angle::EntryPoint::GLLightModelf, pname, param)); + if (isCallValid) + { + context->lightModelf(pname, param); + } + ANGLE_CAPTURE_GL(LightModelf, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LightModelfv(GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightModelfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightModelfv(context, angle::EntryPoint::GLLightModelfv, pname, params)); + if (isCallValid) + { + context->lightModelfv(pname, params); + } + ANGLE_CAPTURE_GL(LightModelfv, isCallValid, context, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LightModelx(GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightModelx, "context = %d, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::LightModelParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightModelx(context, angle::EntryPoint::GLLightModelx, pname, param)); + if (isCallValid) + { + context->lightModelx(pname, param); + } + ANGLE_CAPTURE_GL(LightModelx, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LightModelxv(GLenum pname, const GLfixed *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightModelxv, "context = %d, pname = %s, param = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightModelParameter, pname), (uintptr_t)param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightModelxv(context, angle::EntryPoint::GLLightModelxv, pname, param)); + if (isCallValid) + { + context->lightModelxv(pname, param); + } + ANGLE_CAPTURE_GL(LightModelxv, isCallValid, context, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Lightf(GLenum light, GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightf, "context = %d, light = %s, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), param); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightf(context, angle::EntryPoint::GLLightf, light, pnamePacked, param)); + if (isCallValid) + { + context->lightf(light, pnamePacked, param); + } + ANGLE_CAPTURE_GL(Lightf, isCallValid, context, light, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Lightfv(GLenum light, GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightfv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightfv(context, angle::EntryPoint::GLLightfv, light, pnamePacked, params)); + if (isCallValid) + { + context->lightfv(light, pnamePacked, params); + } + ANGLE_CAPTURE_GL(Lightfv, isCallValid, context, light, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Lightx(GLenum light, GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightx, "context = %d, light = %s, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), param); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightx(context, angle::EntryPoint::GLLightx, light, pnamePacked, param)); + if (isCallValid) + { + context->lightx(light, pnamePacked, param); + } + ANGLE_CAPTURE_GL(Lightx, isCallValid, context, light, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Lightxv(GLenum light, GLenum pname, const GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLightxv, "context = %d, light = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::LightName, light), + GLenumToString(GLESEnum::LightParameter, pname), (uintptr_t)params); + + if (context) + { + LightParameter pnamePacked = PackParam<LightParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLightxv(context, angle::EntryPoint::GLLightxv, light, pnamePacked, params)); + if (isCallValid) + { + context->lightxv(light, pnamePacked, params); + } + ANGLE_CAPTURE_GL(Lightxv, isCallValid, context, light, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LineWidthx(GLfixed width) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLineWidthx, "context = %d, width = 0x%X", CID(context), width); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLineWidthx(context, angle::EntryPoint::GLLineWidthx, width)); + if (isCallValid) + { + context->lineWidthx(width); + } + ANGLE_CAPTURE_GL(LineWidthx, isCallValid, context, width); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LoadIdentity() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLoadIdentity, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLoadIdentity(context, angle::EntryPoint::GLLoadIdentity)); + if (isCallValid) + { + context->loadIdentity(); + } + ANGLE_CAPTURE_GL(LoadIdentity, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LoadMatrixf(const GLfloat *m) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLoadMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)m); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLoadMatrixf(context, angle::EntryPoint::GLLoadMatrixf, m)); + if (isCallValid) + { + context->loadMatrixf(m); + } + ANGLE_CAPTURE_GL(LoadMatrixf, isCallValid, context, m); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LoadMatrixx(const GLfixed *m) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLoadMatrixx, "context = %d, m = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)m); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLoadMatrixx(context, angle::EntryPoint::GLLoadMatrixx, m)); + if (isCallValid) + { + context->loadMatrixx(m); + } + ANGLE_CAPTURE_GL(LoadMatrixx, isCallValid, context, m); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LogicOp(GLenum opcode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLogicOp, "context = %d, opcode = %s", CID(context), + GLenumToString(GLESEnum::LogicOp, opcode)); + + if (context) + { + LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLogicOp(context, angle::EntryPoint::GLLogicOp, opcodePacked)); + if (isCallValid) + { + context->logicOp(opcodePacked); + } + ANGLE_CAPTURE_GL(LogicOp, isCallValid, context, opcodePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Materialf(GLenum face, GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMaterialf, "context = %d, face = %s, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), param); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMaterialf(context, angle::EntryPoint::GLMaterialf, face, pnamePacked, param)); + if (isCallValid) + { + context->materialf(face, pnamePacked, param); + } + ANGLE_CAPTURE_GL(Materialf, isCallValid, context, face, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Materialfv(GLenum face, GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMaterialfv, "context = %d, face = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)params); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMaterialfv(context, angle::EntryPoint::GLMaterialfv, face, + pnamePacked, params)); + if (isCallValid) + { + context->materialfv(face, pnamePacked, params); + } + ANGLE_CAPTURE_GL(Materialfv, isCallValid, context, face, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Materialx(GLenum face, GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMaterialx, "context = %d, face = %s, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), param); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMaterialx(context, angle::EntryPoint::GLMaterialx, face, pnamePacked, param)); + if (isCallValid) + { + context->materialx(face, pnamePacked, param); + } + ANGLE_CAPTURE_GL(Materialx, isCallValid, context, face, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Materialxv(GLenum face, GLenum pname, const GLfixed *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMaterialxv, "context = %d, face = %s, pname = %s, param = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TriangleFace, face), + GLenumToString(GLESEnum::MaterialParameter, pname), (uintptr_t)param); + + if (context) + { + MaterialParameter pnamePacked = PackParam<MaterialParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMaterialxv(context, angle::EntryPoint::GLMaterialxv, face, + pnamePacked, param)); + if (isCallValid) + { + context->materialxv(face, pnamePacked, param); + } + ANGLE_CAPTURE_GL(Materialxv, isCallValid, context, face, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MatrixMode(GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMatrixMode, "context = %d, mode = %s", CID(context), + GLenumToString(GLESEnum::MatrixMode, mode)); + + if (context) + { + MatrixType modePacked = PackParam<MatrixType>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMatrixMode(context, angle::EntryPoint::GLMatrixMode, modePacked)); + if (isCallValid) + { + context->matrixMode(modePacked); + } + ANGLE_CAPTURE_GL(MatrixMode, isCallValid, context, modePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultMatrixf(const GLfloat *m) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultMatrixf, "context = %d, m = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)m); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultMatrixf(context, angle::EntryPoint::GLMultMatrixf, m)); + if (isCallValid) + { + context->multMatrixf(m); + } + ANGLE_CAPTURE_GL(MultMatrixf, isCallValid, context, m); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultMatrixx(const GLfixed *m) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultMatrixx, "context = %d, m = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)m); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultMatrixx(context, angle::EntryPoint::GLMultMatrixx, m)); + if (isCallValid) + { + context->multMatrixx(m); + } + ANGLE_CAPTURE_GL(MultMatrixx, isCallValid, context, m); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiTexCoord4f, "context = %d, target = %s, s = %f, t = %f, r = %f, q = %f", + CID(context), GLenumToString(GLESEnum::TextureUnit, target), s, t, r, q); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiTexCoord4f(context, angle::EntryPoint::GLMultiTexCoord4f, + target, s, t, r, q)); + if (isCallValid) + { + context->multiTexCoord4f(target, s, t, r, q); + } + ANGLE_CAPTURE_GL(MultiTexCoord4f, isCallValid, context, target, s, t, r, q); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiTexCoord4x, + "context = %d, texture = %s, s = 0x%X, t = 0x%X, r = 0x%X, q = 0x%X", CID(context), + GLenumToString(GLESEnum::TextureUnit, texture), s, t, r, q); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiTexCoord4x(context, angle::EntryPoint::GLMultiTexCoord4x, + texture, s, t, r, q)); + if (isCallValid) + { + context->multiTexCoord4x(texture, s, t, r, q); + } + ANGLE_CAPTURE_GL(MultiTexCoord4x, isCallValid, context, texture, s, t, r, q); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLNormal3f, "context = %d, nx = %f, ny = %f, nz = %f", CID(context), nx, ny, nz); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateNormal3f(context, angle::EntryPoint::GLNormal3f, nx, ny, nz)); + if (isCallValid) + { + context->normal3f(nx, ny, nz); + } + ANGLE_CAPTURE_GL(Normal3f, isCallValid, context, nx, ny, nz); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLNormal3x, "context = %d, nx = 0x%X, ny = 0x%X, nz = 0x%X", CID(context), nx, + ny, nz); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateNormal3x(context, angle::EntryPoint::GLNormal3x, nx, ny, nz)); + if (isCallValid) + { + context->normal3x(nx, ny, nz); + } + ANGLE_CAPTURE_GL(Normal3x, isCallValid, context, nx, ny, nz); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_NormalPointer(GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLNormalPointer, + "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::NormalPointerType, type), stride, (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateNormalPointer(context, angle::EntryPoint::GLNormalPointer, + typePacked, stride, pointer)); + if (isCallValid) + { + context->normalPointer(typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(NormalPointer, isCallValid, context, typePacked, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLOrthof, "context = %d, l = %f, r = %f, b = %f, t = %f, n = %f, f = %f", + CID(context), l, r, b, t, n, f); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateOrthof(context, angle::EntryPoint::GLOrthof, l, r, b, t, n, f)); + if (isCallValid) + { + context->orthof(l, r, b, t, n, f); + } + ANGLE_CAPTURE_GL(Orthof, isCallValid, context, l, r, b, t, n, f); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLOrthox, + "context = %d, l = 0x%X, r = 0x%X, b = 0x%X, t = 0x%X, n = 0x%X, f = 0x%X", CID(context), + l, r, b, t, n, f); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateOrthox(context, angle::EntryPoint::GLOrthox, l, r, b, t, n, f)); + if (isCallValid) + { + context->orthox(l, r, b, t, n, f); + } + ANGLE_CAPTURE_GL(Orthox, isCallValid, context, l, r, b, t, n, f); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointParameterf(GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointParameterf, "context = %d, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::AllEnums, pname), param); + + if (context) + { + PointParameter pnamePacked = PackParam<PointParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointParameterf(context, angle::EntryPoint::GLPointParameterf, + pnamePacked, param)); + if (isCallValid) + { + context->pointParameterf(pnamePacked, param); + } + ANGLE_CAPTURE_GL(PointParameterf, isCallValid, context, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointParameterfv(GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointParameterfv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); + + if (context) + { + PointParameter pnamePacked = PackParam<PointParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointParameterfv(context, angle::EntryPoint::GLPointParameterfv, + pnamePacked, params)); + if (isCallValid) + { + context->pointParameterfv(pnamePacked, params); + } + ANGLE_CAPTURE_GL(PointParameterfv, isCallValid, context, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointParameterx(GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointParameterx, "context = %d, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::AllEnums, pname), param); + + if (context) + { + PointParameter pnamePacked = PackParam<PointParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointParameterx(context, angle::EntryPoint::GLPointParameterx, + pnamePacked, param)); + if (isCallValid) + { + context->pointParameterx(pnamePacked, param); + } + ANGLE_CAPTURE_GL(PointParameterx, isCallValid, context, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointParameterxv(GLenum pname, const GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointParameterxv, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); + + if (context) + { + PointParameter pnamePacked = PackParam<PointParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointParameterxv(context, angle::EntryPoint::GLPointParameterxv, + pnamePacked, params)); + if (isCallValid) + { + context->pointParameterxv(pnamePacked, params); + } + ANGLE_CAPTURE_GL(PointParameterxv, isCallValid, context, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointSize(GLfloat size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointSize, "context = %d, size = %f", CID(context), size); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointSize(context, angle::EntryPoint::GLPointSize, size)); + if (isCallValid) + { + context->pointSize(size); + } + ANGLE_CAPTURE_GL(PointSize, isCallValid, context, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PointSizex(GLfixed size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointSizex, "context = %d, size = 0x%X", CID(context), size); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePointSizex(context, angle::EntryPoint::GLPointSizex, size)); + if (isCallValid) + { + context->pointSizex(size); + } + ANGLE_CAPTURE_GL(PointSizex, isCallValid, context, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PolygonOffsetx(GLfixed factor, GLfixed units) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPolygonOffsetx, "context = %d, factor = 0x%X, units = 0x%X", CID(context), + factor, units); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePolygonOffsetx(context, angle::EntryPoint::GLPolygonOffsetx, factor, units)); + if (isCallValid) + { + context->polygonOffsetx(factor, units); + } + ANGLE_CAPTURE_GL(PolygonOffsetx, isCallValid, context, factor, units); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PopMatrix() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPopMatrix, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePopMatrix(context, angle::EntryPoint::GLPopMatrix)); + if (isCallValid) + { + context->popMatrix(); + } + ANGLE_CAPTURE_GL(PopMatrix, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PushMatrix() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPushMatrix, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePushMatrix(context, angle::EntryPoint::GLPushMatrix)); + if (isCallValid) + { + context->pushMatrix(); + } + ANGLE_CAPTURE_GL(PushMatrix, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRotatef, "context = %d, angle = %f, x = %f, y = %f, z = %f", CID(context), + angle, x, y, z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRotatef(context, angle::EntryPoint::GLRotatef, angle, x, y, z)); + if (isCallValid) + { + context->rotatef(angle, x, y, z); + } + ANGLE_CAPTURE_GL(Rotatef, isCallValid, context, angle, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRotatex, "context = %d, angle = 0x%X, x = 0x%X, y = 0x%X, z = 0x%X", + CID(context), angle, x, y, z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRotatex(context, angle::EntryPoint::GLRotatex, angle, x, y, z)); + if (isCallValid) + { + context->rotatex(angle, x, y, z); + } + ANGLE_CAPTURE_GL(Rotatex, isCallValid, context, angle, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SampleCoveragex(GLclampx value, GLboolean invert) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSampleCoveragex, "context = %d, value = 0x%X, invert = %s", CID(context), + value, GLbooleanToString(invert)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSampleCoveragex(context, angle::EntryPoint::GLSampleCoveragex, value, invert)); + if (isCallValid) + { + context->sampleCoveragex(value, invert); + } + ANGLE_CAPTURE_GL(SampleCoveragex, isCallValid, context, value, invert); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Scalef(GLfloat x, GLfloat y, GLfloat z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLScalef, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateScalef(context, angle::EntryPoint::GLScalef, x, y, z)); + if (isCallValid) + { + context->scalef(x, y, z); + } + ANGLE_CAPTURE_GL(Scalef, isCallValid, context, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Scalex(GLfixed x, GLfixed y, GLfixed z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLScalex, "context = %d, x = 0x%X, y = 0x%X, z = 0x%X", CID(context), x, y, z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateScalex(context, angle::EntryPoint::GLScalex, x, y, z)); + if (isCallValid) + { + context->scalex(x, y, z); + } + ANGLE_CAPTURE_GL(Scalex, isCallValid, context, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ShadeModel(GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLShadeModel, "context = %d, mode = %s", CID(context), + GLenumToString(GLESEnum::ShadingModel, mode)); + + if (context) + { + ShadingModel modePacked = PackParam<ShadingModel>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateShadeModel(context, angle::EntryPoint::GLShadeModel, modePacked)); + if (isCallValid) + { + context->shadeModel(modePacked); + } + ANGLE_CAPTURE_GL(ShadeModel, isCallValid, context, modePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexCoordPointer, + "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", + CID(context), size, GLenumToString(GLESEnum::TexCoordPointerType, type), stride, + (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexCoordPointer(context, angle::EntryPoint::GLTexCoordPointer, + size, typePacked, stride, pointer)); + if (isCallValid) + { + context->texCoordPointer(size, typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(TexCoordPointer, isCallValid, context, size, typePacked, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnvf(GLenum target, GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnvf, "context = %d, target = %s, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnvf(context, angle::EntryPoint::GLTexEnvf, + targetPacked, pnamePacked, param)); + if (isCallValid) + { + context->texEnvf(targetPacked, pnamePacked, param); + } + ANGLE_CAPTURE_GL(TexEnvf, isCallValid, context, targetPacked, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnvfv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnvfv(context, angle::EntryPoint::GLTexEnvfv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->texEnvfv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(TexEnvfv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnvi(GLenum target, GLenum pname, GLint param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnvi, "context = %d, target = %s, pname = %s, param = %d", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnvi(context, angle::EntryPoint::GLTexEnvi, + targetPacked, pnamePacked, param)); + if (isCallValid) + { + context->texEnvi(targetPacked, pnamePacked, param); + } + ANGLE_CAPTURE_GL(TexEnvi, isCallValid, context, targetPacked, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnviv(GLenum target, GLenum pname, const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnviv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnviv(context, angle::EntryPoint::GLTexEnviv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->texEnviv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(TexEnviv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnvx(GLenum target, GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnvx, "context = %d, target = %s, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), param); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnvx(context, angle::EntryPoint::GLTexEnvx, + targetPacked, pnamePacked, param)); + if (isCallValid) + { + context->texEnvx(targetPacked, pnamePacked, param); + } + ANGLE_CAPTURE_GL(TexEnvx, isCallValid, context, targetPacked, pnamePacked, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexEnvxv, "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureEnvTarget, target), + GLenumToString(GLESEnum::TextureEnvParameter, pname), (uintptr_t)params); + + if (context) + { + TextureEnvTarget targetPacked = PackParam<TextureEnvTarget>(target); + TextureEnvParameter pnamePacked = PackParam<TextureEnvParameter>(pname); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateTexEnvxv(context, angle::EntryPoint::GLTexEnvxv, + targetPacked, pnamePacked, params)); + if (isCallValid) + { + context->texEnvxv(targetPacked, pnamePacked, params); + } + ANGLE_CAPTURE_GL(TexEnvxv, isCallValid, context, targetPacked, pnamePacked, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterx(GLenum target, GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterx, "context = %d, target = %s, pname = %s, param = 0x%X", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::GetTextureParameter, pname), param); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexParameterx(context, angle::EntryPoint::GLTexParameterx, + targetPacked, pname, param)); + if (isCallValid) + { + context->texParameterx(targetPacked, pname, param); + } + ANGLE_CAPTURE_GL(TexParameterx, isCallValid, context, targetPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterxv(GLenum target, GLenum pname, const GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterxv, + "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() || + ValidateTexParameterxv(context, angle::EntryPoint::GLTexParameterxv, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterxv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterxv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Translatef(GLfloat x, GLfloat y, GLfloat z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTranslatef, "context = %d, x = %f, y = %f, z = %f", CID(context), x, y, z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTranslatef(context, angle::EntryPoint::GLTranslatef, x, y, z)); + if (isCallValid) + { + context->translatef(x, y, z); + } + ANGLE_CAPTURE_GL(Translatef, isCallValid, context, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Translatex(GLfixed x, GLfixed y, GLfixed z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTranslatex, "context = %d, x = 0x%X, y = 0x%X, z = 0x%X", CID(context), x, y, + z); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTranslatex(context, angle::EntryPoint::GLTranslatex, x, y, z)); + if (isCallValid) + { + context->translatex(x, y, z); + } + ANGLE_CAPTURE_GL(Translatex, isCallValid, context, x, y, z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexPointer, + "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", + CID(context), size, GLenumToString(GLESEnum::VertexPointerType, type), stride, + (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateVertexPointer(context, angle::EntryPoint::GLVertexPointer, size, + typePacked, stride, pointer)); + if (isCallValid) + { + context->vertexPointer(size, typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(VertexPointer, isCallValid, context, size, typePacked, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h new file mode 100644 index 0000000000..211fb5b8db --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_1_0_autogen.h @@ -0,0 +1,123 @@ +// 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_1_0_autogen.h: +// Defines the GLES 1.0 entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_ + +#include <GLES/gl.h> +#include <export.h> + +extern "C" { +ANGLE_EXPORT void GL_APIENTRY GL_AlphaFunc(GLenum func, GLfloat ref); +ANGLE_EXPORT void GL_APIENTRY GL_AlphaFuncx(GLenum func, GLfixed ref); +ANGLE_EXPORT void GL_APIENTRY GL_ClearColorx(GLfixed red, + GLfixed green, + GLfixed blue, + GLfixed alpha); +ANGLE_EXPORT void GL_APIENTRY GL_ClearDepthx(GLfixed depth); +ANGLE_EXPORT void GL_APIENTRY GL_ClientActiveTexture(GLenum texture); +ANGLE_EXPORT void GL_APIENTRY GL_ClipPlanef(GLenum p, const GLfloat *eqn); +ANGLE_EXPORT void GL_APIENTRY GL_ClipPlanex(GLenum plane, const GLfixed *equation); +ANGLE_EXPORT void GL_APIENTRY GL_Color4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +ANGLE_EXPORT void GL_APIENTRY GL_Color4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +ANGLE_EXPORT void GL_APIENTRY GL_Color4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha); +ANGLE_EXPORT void GL_APIENTRY GL_ColorPointer(GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +ANGLE_EXPORT void GL_APIENTRY GL_DepthRangex(GLfixed n, GLfixed f); +ANGLE_EXPORT void GL_APIENTRY GL_DisableClientState(GLenum array); +ANGLE_EXPORT void GL_APIENTRY GL_EnableClientState(GLenum array); +ANGLE_EXPORT void GL_APIENTRY GL_Fogf(GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_Fogfv(GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_Fogx(GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_Fogxv(GLenum pname, const GLfixed *param); +ANGLE_EXPORT void GL_APIENTRY +GL_Frustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); +ANGLE_EXPORT void GL_APIENTRY +GL_Frustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f); +ANGLE_EXPORT void GL_APIENTRY GL_GetClipPlanef(GLenum plane, GLfloat *equation); +ANGLE_EXPORT void GL_APIENTRY GL_GetClipPlanex(GLenum plane, GLfixed *equation); +ANGLE_EXPORT void GL_APIENTRY GL_GetFixedv(GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetLightfv(GLenum light, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetLightxv(GLenum light, GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetMaterialfv(GLenum face, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetMaterialxv(GLenum face, GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexEnvfv(GLenum target, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexEnviv(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexEnvxv(GLenum target, GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterxv(GLenum target, GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_LightModelf(GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_LightModelfv(GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_LightModelx(GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_LightModelxv(GLenum pname, const GLfixed *param); +ANGLE_EXPORT void GL_APIENTRY GL_Lightf(GLenum light, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_Lightfv(GLenum light, GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_Lightx(GLenum light, GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_Lightxv(GLenum light, GLenum pname, const GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_LineWidthx(GLfixed width); +ANGLE_EXPORT void GL_APIENTRY GL_LoadIdentity(); +ANGLE_EXPORT void GL_APIENTRY GL_LoadMatrixf(const GLfloat *m); +ANGLE_EXPORT void GL_APIENTRY GL_LoadMatrixx(const GLfixed *m); +ANGLE_EXPORT void GL_APIENTRY GL_LogicOp(GLenum opcode); +ANGLE_EXPORT void GL_APIENTRY GL_Materialf(GLenum face, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_Materialfv(GLenum face, GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_Materialx(GLenum face, GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_Materialxv(GLenum face, GLenum pname, const GLfixed *param); +ANGLE_EXPORT void GL_APIENTRY GL_MatrixMode(GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_MultMatrixf(const GLfloat *m); +ANGLE_EXPORT void GL_APIENTRY GL_MultMatrixx(const GLfixed *m); +ANGLE_EXPORT void GL_APIENTRY +GL_MultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +ANGLE_EXPORT void GL_APIENTRY +GL_MultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q); +ANGLE_EXPORT void GL_APIENTRY GL_Normal3f(GLfloat nx, GLfloat ny, GLfloat nz); +ANGLE_EXPORT void GL_APIENTRY GL_Normal3x(GLfixed nx, GLfixed ny, GLfixed nz); +ANGLE_EXPORT void GL_APIENTRY GL_NormalPointer(GLenum type, GLsizei stride, const void *pointer); +ANGLE_EXPORT void GL_APIENTRY +GL_Orthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); +ANGLE_EXPORT void GL_APIENTRY +GL_Orthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f); +ANGLE_EXPORT void GL_APIENTRY GL_PointParameterf(GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_PointParameterfv(GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_PointParameterx(GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_PointParameterxv(GLenum pname, const GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_PointSize(GLfloat size); +ANGLE_EXPORT void GL_APIENTRY GL_PointSizex(GLfixed size); +ANGLE_EXPORT void GL_APIENTRY GL_PolygonOffsetx(GLfixed factor, GLfixed units); +ANGLE_EXPORT void GL_APIENTRY GL_PopMatrix(); +ANGLE_EXPORT void GL_APIENTRY GL_PushMatrix(); +ANGLE_EXPORT void GL_APIENTRY GL_Rotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +ANGLE_EXPORT void GL_APIENTRY GL_Rotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z); +ANGLE_EXPORT void GL_APIENTRY GL_SampleCoveragex(GLclampx value, GLboolean invert); +ANGLE_EXPORT void GL_APIENTRY GL_Scalef(GLfloat x, GLfloat y, GLfloat z); +ANGLE_EXPORT void GL_APIENTRY GL_Scalex(GLfixed x, GLfixed y, GLfixed z); +ANGLE_EXPORT void GL_APIENTRY GL_ShadeModel(GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_TexCoordPointer(GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnvf(GLenum target, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnvfv(GLenum target, GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnvi(GLenum target, GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnviv(GLenum target, GLenum pname, const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnvx(GLenum target, GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_TexEnvxv(GLenum target, GLenum pname, const GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterx(GLenum target, GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterxv(GLenum target, GLenum pname, const GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_Translatef(GLfloat x, GLfloat y, GLfloat z); +ANGLE_EXPORT void GL_APIENTRY GL_Translatex(GLfixed x, GLfixed y, GLfixed z); +ANGLE_EXPORT void GL_APIENTRY GL_VertexPointer(GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_1_0_AUTOGEN_H_ 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" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h new file mode 100644 index 0000000000..5f5bab31ec --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_2_0_autogen.h @@ -0,0 +1,309 @@ +// 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.h: +// Defines the GLES 2.0 entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_ + +#include <GLES2/gl2.h> +#include <export.h> + +extern "C" { +ANGLE_EXPORT void GL_APIENTRY GL_ActiveTexture(GLenum texture); +ANGLE_EXPORT void GL_APIENTRY GL_AttachShader(GLuint program, GLuint shader); +ANGLE_EXPORT void GL_APIENTRY GL_BindAttribLocation(GLuint program, + GLuint index, + const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_BindBuffer(GLenum target, GLuint buffer); +ANGLE_EXPORT void GL_APIENTRY GL_BindFramebuffer(GLenum target, GLuint framebuffer); +ANGLE_EXPORT void GL_APIENTRY GL_BindRenderbuffer(GLenum target, GLuint renderbuffer); +ANGLE_EXPORT void GL_APIENTRY GL_BindTexture(GLenum target, GLuint texture); +ANGLE_EXPORT void GL_APIENTRY GL_BlendColor(GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquation(GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFunc(GLenum sfactor, GLenum dfactor); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFuncSeparate(GLenum sfactorRGB, + GLenum dfactorRGB, + GLenum sfactorAlpha, + GLenum dfactorAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BufferData(GLenum target, + GLsizeiptr size, + const void *data, + GLenum usage); +ANGLE_EXPORT void GL_APIENTRY GL_BufferSubData(GLenum target, + GLintptr offset, + GLsizeiptr size, + const void *data); +ANGLE_EXPORT GLenum GL_APIENTRY GL_CheckFramebufferStatus(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_Clear(GLbitfield mask); +ANGLE_EXPORT void GL_APIENTRY GL_ClearColor(GLfloat red, + GLfloat green, + GLfloat blue, + GLfloat alpha); +ANGLE_EXPORT void GL_APIENTRY GL_ClearDepthf(GLfloat d); +ANGLE_EXPORT void GL_APIENTRY GL_ClearStencil(GLint s); +ANGLE_EXPORT void GL_APIENTRY GL_ColorMask(GLboolean red, + GLboolean green, + GLboolean blue, + GLboolean alpha); +ANGLE_EXPORT void GL_APIENTRY GL_CompileShader(GLuint shader); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexImage2D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CopyTexImage2D(GLenum target, + GLint level, + GLenum internalformat, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLint border); +ANGLE_EXPORT void GL_APIENTRY GL_CopyTexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +ANGLE_EXPORT GLuint GL_APIENTRY GL_CreateProgram(); +ANGLE_EXPORT GLuint GL_APIENTRY GL_CreateShader(GLenum type); +ANGLE_EXPORT void GL_APIENTRY GL_CullFace(GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteBuffers(GLsizei n, const GLuint *buffers); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteFramebuffers(GLsizei n, const GLuint *framebuffers); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteProgram(GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteShader(GLuint shader); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteTextures(GLsizei n, const GLuint *textures); +ANGLE_EXPORT void GL_APIENTRY GL_DepthFunc(GLenum func); +ANGLE_EXPORT void GL_APIENTRY GL_DepthMask(GLboolean flag); +ANGLE_EXPORT void GL_APIENTRY GL_DepthRangef(GLfloat n, GLfloat f); +ANGLE_EXPORT void GL_APIENTRY GL_DetachShader(GLuint program, GLuint shader); +ANGLE_EXPORT void GL_APIENTRY GL_Disable(GLenum cap); +ANGLE_EXPORT void GL_APIENTRY GL_DisableVertexAttribArray(GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_DrawArrays(GLenum mode, GLint first, GLsizei count); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElements(GLenum mode, + GLsizei count, + GLenum type, + const void *indices); +ANGLE_EXPORT void GL_APIENTRY GL_Enable(GLenum cap); +ANGLE_EXPORT void GL_APIENTRY GL_EnableVertexAttribArray(GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_Finish(); +ANGLE_EXPORT void GL_APIENTRY GL_Flush(); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferRenderbuffer(GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexture2D(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level); +ANGLE_EXPORT void GL_APIENTRY GL_FrontFace(GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_GenBuffers(GLsizei n, GLuint *buffers); +ANGLE_EXPORT void GL_APIENTRY GL_GenFramebuffers(GLsizei n, GLuint *framebuffers); +ANGLE_EXPORT void GL_APIENTRY GL_GenRenderbuffers(GLsizei n, GLuint *renderbuffers); +ANGLE_EXPORT void GL_APIENTRY GL_GenTextures(GLsizei n, GLuint *textures); +ANGLE_EXPORT void GL_APIENTRY GL_GenerateMipmap(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveAttrib(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveUniform(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetAttachedShaders(GLuint program, + GLsizei maxCount, + GLsizei *count, + GLuint *shaders); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetAttribLocation(GLuint program, const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetBooleanv(GLenum pname, GLboolean *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferParameteriv(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT GLenum GL_APIENTRY GL_GetError(); +ANGLE_EXPORT void GL_APIENTRY GL_GetFloatv(GLenum pname, GLfloat *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferAttachmentParameteriv(GLenum target, + GLenum attachment, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetIntegerv(GLenum pname, GLint *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramInfoLog(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramiv(GLuint program, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetRenderbufferParameteriv(GLenum target, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetShaderInfoLog(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +ANGLE_EXPORT void GL_APIENTRY GL_GetShaderPrecisionFormat(GLenum shadertype, + GLenum precisiontype, + GLint *range, + GLint *precision); +ANGLE_EXPORT void GL_APIENTRY GL_GetShaderSource(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *source); +ANGLE_EXPORT void GL_APIENTRY GL_GetShaderiv(GLuint shader, GLenum pname, GLint *params); +ANGLE_EXPORT const GLubyte *GL_APIENTRY GL_GetString(GLenum name); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterfv(GLenum target, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameteriv(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetUniformLocation(GLuint program, const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformfv(GLuint program, GLint location, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformiv(GLuint program, GLint location, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribPointerv(GLuint index, + GLenum pname, + void **pointer); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribiv(GLuint index, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_Hint(GLenum target, GLenum mode); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsBuffer(GLuint buffer); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsEnabled(GLenum cap); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsFramebuffer(GLuint framebuffer); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsProgram(GLuint program); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsRenderbuffer(GLuint renderbuffer); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsShader(GLuint shader); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsTexture(GLuint texture); +ANGLE_EXPORT void GL_APIENTRY GL_LineWidth(GLfloat width); +ANGLE_EXPORT void GL_APIENTRY GL_LinkProgram(GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_PixelStorei(GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_PolygonOffset(GLfloat factor, GLfloat units); +ANGLE_EXPORT void GL_APIENTRY GL_ReadPixels(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_ReleaseShaderCompiler(); +ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorage(GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_SampleCoverage(GLfloat value, GLboolean invert); +ANGLE_EXPORT void GL_APIENTRY GL_Scissor(GLint x, GLint y, GLsizei width, GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_ShaderBinary(GLsizei count, + const GLuint *shaders, + GLenum binaryFormat, + const void *binary, + GLsizei length); +ANGLE_EXPORT void GL_APIENTRY GL_ShaderSource(GLuint shader, + GLsizei count, + const GLchar *const *string, + const GLint *length); +ANGLE_EXPORT void GL_APIENTRY GL_StencilFunc(GLenum func, GLint ref, GLuint mask); +ANGLE_EXPORT void GL_APIENTRY GL_StencilFuncSeparate(GLenum face, + GLenum func, + GLint ref, + GLuint mask); +ANGLE_EXPORT void GL_APIENTRY GL_StencilMask(GLuint mask); +ANGLE_EXPORT void GL_APIENTRY GL_StencilMaskSeparate(GLenum face, GLuint mask); +ANGLE_EXPORT void GL_APIENTRY GL_StencilOp(GLenum fail, GLenum zfail, GLenum zpass); +ANGLE_EXPORT void GL_APIENTRY GL_StencilOpSeparate(GLenum face, + GLenum sfail, + GLenum dpfail, + GLenum dppass); +ANGLE_EXPORT void GL_APIENTRY GL_TexImage2D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterf(GLenum target, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterfv(GLenum target, GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameteri(GLenum target, GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameteriv(GLenum target, GLenum pname, const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1f(GLint location, GLfloat v0); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1fv(GLint location, GLsizei count, const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1i(GLint location, GLint v0); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1iv(GLint location, GLsizei count, const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2f(GLint location, GLfloat v0, GLfloat v1); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2fv(GLint location, GLsizei count, const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2i(GLint location, GLint v0, GLint v1); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2iv(GLint location, GLsizei count, const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3fv(GLint location, GLsizei count, const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3i(GLint location, GLint v0, GLint v1, GLint v2); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3iv(GLint location, GLsizei count, const GLint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_Uniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform4fv(GLint location, GLsizei count, const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform4iv(GLint location, GLsizei count, const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UseProgram(GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_ValidateProgram(GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib1f(GLuint index, GLfloat x); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib1fv(GLuint index, const GLfloat *v); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib2f(GLuint index, GLfloat x, GLfloat y); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib2fv(GLuint index, const GLfloat *v); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib3fv(GLuint index, const GLfloat *v); +ANGLE_EXPORT void GL_APIENTRY +GL_VertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttrib4fv(GLuint index, const GLfloat *v); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribPointer(GLuint index, + GLint size, + GLenum type, + GLboolean normalized, + GLsizei stride, + const void *pointer); +ANGLE_EXPORT void GL_APIENTRY GL_Viewport(GLint x, GLint y, GLsizei width, GLsizei height); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_2_0_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp new file mode 100644 index 0000000000..a5d8c1172e --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.cpp @@ -0,0 +1,3057 @@ +// 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_0_autogen.cpp: +// Defines the GLES 3.0 entry points. + +#include "libGLESv2/entry_points_gles_3_0_autogen.h" + +#include "common/entry_points_enum_autogen.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/capture/capture_gles_3_0_autogen.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationES3.h" +#include "libGLESv2/global_state.h" + +using namespace gl; + +extern "C" { +void GL_APIENTRY GL_BeginQuery(GLenum target, GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBeginQuery, "context = %d, target = %s, id = %u", CID(context), + GLenumToString(GLESEnum::QueryTarget, target), id); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBeginQuery(context, angle::EntryPoint::GLBeginQuery, targetPacked, idPacked)); + if (isCallValid) + { + context->beginQuery(targetPacked, idPacked); + } + ANGLE_CAPTURE_GL(BeginQuery, isCallValid, context, targetPacked, idPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BeginTransformFeedback(GLenum primitiveMode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBeginTransformFeedback, "context = %d, primitiveMode = %s", CID(context), + GLenumToString(GLESEnum::PrimitiveType, primitiveMode)); + + if (context) + { + PrimitiveMode primitiveModePacked = PackParam<PrimitiveMode>(primitiveMode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBeginTransformFeedback(context, angle::EntryPoint::GLBeginTransformFeedback, + primitiveModePacked)); + if (isCallValid) + { + context->beginTransformFeedback(primitiveModePacked); + } + ANGLE_CAPTURE_GL(BeginTransformFeedback, isCallValid, context, primitiveModePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindBufferBase(GLenum target, GLuint index, GLuint buffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindBufferBase, "context = %d, target = %s, index = %u, buffer = %u", + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), index, buffer); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + BufferID bufferPacked = PackParam<BufferID>(buffer); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindBufferBase(context, angle::EntryPoint::GLBindBufferBase, + targetPacked, index, bufferPacked)); + if (isCallValid) + { + context->bindBufferBase(targetPacked, index, bufferPacked); + } + ANGLE_CAPTURE_GL(BindBufferBase, isCallValid, context, targetPacked, index, bufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindBufferRange, + "context = %d, target = %s, index = %u, buffer = %u, offset = %llu, size = %llu", + CID(context), GLenumToString(GLESEnum::BufferTargetARB, target), index, buffer, + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size)); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + BufferID bufferPacked = PackParam<BufferID>(buffer); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindBufferRange(context, angle::EntryPoint::GLBindBufferRange, targetPacked, + index, bufferPacked, offset, size)); + if (isCallValid) + { + context->bindBufferRange(targetPacked, index, bufferPacked, offset, size); + } + ANGLE_CAPTURE_GL(BindBufferRange, isCallValid, context, targetPacked, index, bufferPacked, + offset, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindSampler(GLuint unit, GLuint sampler) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindSampler, "context = %d, unit = %u, sampler = %u", CID(context), unit, + sampler); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindSampler(context, angle::EntryPoint::GLBindSampler, unit, samplerPacked)); + if (isCallValid) + { + context->bindSampler(unit, samplerPacked); + } + ANGLE_CAPTURE_GL(BindSampler, isCallValid, context, unit, samplerPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindTransformFeedback(GLenum target, GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindTransformFeedback, "context = %d, target = %s, id = %u", CID(context), + GLenumToString(GLESEnum::BindTransformFeedbackTarget, target), id); + + if (context) + { + TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindTransformFeedback(context, angle::EntryPoint::GLBindTransformFeedback, + target, idPacked)); + if (isCallValid) + { + context->bindTransformFeedback(target, idPacked); + } + ANGLE_CAPTURE_GL(BindTransformFeedback, isCallValid, context, target, idPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindVertexArray(GLuint array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindVertexArray, "context = %d, array = %u", CID(context), array); + + if (context) + { + VertexArrayID arrayPacked = PackParam<VertexArrayID>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindVertexArray(context, angle::EntryPoint::GLBindVertexArray, arrayPacked)); + if (isCallValid) + { + context->bindVertexArray(arrayPacked); + } + ANGLE_CAPTURE_GL(BindVertexArray, isCallValid, context, arrayPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlitFramebuffer(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlitFramebuffer, + "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " + "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", + CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlitFramebuffer(context, angle::EntryPoint::GLBlitFramebuffer, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)); + if (isCallValid) + { + context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); + } + ANGLE_CAPTURE_GL(BlitFramebuffer, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0, + dstY0, dstX1, dstY1, mask, filter); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearBufferfi, + "context = %d, buffer = %s, drawbuffer = %d, depth = %f, stencil = %d", CID(context), + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, depth, stencil); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearBufferfi(context, angle::EntryPoint::GLClearBufferfi, + buffer, drawbuffer, depth, stencil)); + if (isCallValid) + { + context->clearBufferfi(buffer, drawbuffer, depth, stencil); + } + ANGLE_CAPTURE_GL(ClearBufferfi, isCallValid, context, buffer, drawbuffer, depth, stencil); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearBufferfv, + "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearBufferfv(context, angle::EntryPoint::GLClearBufferfv, + buffer, drawbuffer, value)); + if (isCallValid) + { + context->clearBufferfv(buffer, drawbuffer, value); + } + ANGLE_CAPTURE_GL(ClearBufferfv, isCallValid, context, buffer, drawbuffer, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearBufferiv, + "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearBufferiv(context, angle::EntryPoint::GLClearBufferiv, + buffer, drawbuffer, value)); + if (isCallValid) + { + context->clearBufferiv(buffer, drawbuffer, value); + } + ANGLE_CAPTURE_GL(ClearBufferiv, isCallValid, context, buffer, drawbuffer, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClearBufferuiv, + "context = %d, buffer = %s, drawbuffer = %d, value = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::Buffer, buffer), drawbuffer, (uintptr_t)value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClearBufferuiv(context, angle::EntryPoint::GLClearBufferuiv, + buffer, drawbuffer, value)); + if (isCallValid) + { + context->clearBufferuiv(buffer, drawbuffer, value); + } + ANGLE_CAPTURE_GL(ClearBufferuiv, isCallValid, context, buffer, drawbuffer, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLenum GL_APIENTRY GL_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClientWaitSync, + "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu", CID(context), + (uintptr_t)sync, GLbitfieldToString(GLESEnum::SyncObjectMask, flags).c_str(), + static_cast<unsigned long long>(timeout)); + + GLenum returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateClientWaitSync(context, angle::EntryPoint::GLClientWaitSync, + sync, flags, timeout)); + if (isCallValid) + { + returnValue = context->clientWaitSync(sync, flags, timeout); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLClientWaitSync, GLenum>(); + } + ANGLE_CAPTURE_GL(ClientWaitSync, isCallValid, context, sync, flags, timeout, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLClientWaitSync, GLenum>(); + } + return returnValue; +} + +void GL_APIENTRY GL_CompressedTexImage3D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexImage3D, + "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border, + imageSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexImage3D(context, angle::EntryPoint::GLCompressedTexImage3D, + targetPacked, level, internalformat, width, height, depth, + border, imageSize, data)); + if (isCallValid) + { + context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth, + border, imageSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexImage3D, isCallValid, context, targetPacked, level, + internalformat, width, height, depth, border, imageSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexSubImage3D, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " + "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::InternalFormat, format), + imageSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexSubImage3D(context, angle::EntryPoint::GLCompressedTexSubImage3D, + targetPacked, level, xoffset, yoffset, zoffset, width, + height, depth, format, imageSize, data)); + if (isCallValid) + { + context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, + height, depth, format, imageSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexSubImage3D, isCallValid, context, targetPacked, level, + xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CopyBufferSubData(GLenum readTarget, + GLenum writeTarget, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopyBufferSubData, + "context = %d, readTarget = %s, writeTarget = %s, readOffset = %llu, writeOffset = %llu, " + "size = %llu", + CID(context), GLenumToString(GLESEnum::CopyBufferSubDataTarget, readTarget), + GLenumToString(GLESEnum::CopyBufferSubDataTarget, writeTarget), + static_cast<unsigned long long>(readOffset), static_cast<unsigned long long>(writeOffset), + static_cast<unsigned long long>(size)); + + if (context) + { + BufferBinding readTargetPacked = PackParam<BufferBinding>(readTarget); + BufferBinding writeTargetPacked = PackParam<BufferBinding>(writeTarget); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCopyBufferSubData( + context, angle::EntryPoint::GLCopyBufferSubData, readTargetPacked, + writeTargetPacked, readOffset, writeOffset, size)); + if (isCallValid) + { + context->copyBufferSubData(readTargetPacked, writeTargetPacked, readOffset, writeOffset, + size); + } + ANGLE_CAPTURE_GL(CopyBufferSubData, isCallValid, context, readTargetPacked, + writeTargetPacked, readOffset, writeOffset, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CopyTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopyTexSubImage3D, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = " + "%d, y = %d, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, x, y, width, height); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCopyTexSubImage3D( + context, angle::EntryPoint::GLCopyTexSubImage3D, targetPacked, + level, xoffset, yoffset, zoffset, x, y, width, height)); + if (isCallValid) + { + context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width, + height); + } + ANGLE_CAPTURE_GL(CopyTexSubImage3D, isCallValid, context, targetPacked, level, xoffset, + yoffset, zoffset, x, y, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteQueries(GLsizei n, const GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteQueries, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context), + n, (uintptr_t)ids); + + if (context) + { + const QueryID *idsPacked = PackParam<const QueryID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteQueries(context, angle::EntryPoint::GLDeleteQueries, n, idsPacked)); + if (isCallValid) + { + context->deleteQueries(n, idsPacked); + } + ANGLE_CAPTURE_GL(DeleteQueries, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteSamplers(GLsizei count, const GLuint *samplers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteSamplers, "context = %d, count = %d, samplers = 0x%016" PRIxPTR "", + CID(context), count, (uintptr_t)samplers); + + if (context) + { + const SamplerID *samplersPacked = PackParam<const SamplerID *>(samplers); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDeleteSamplers(context, angle::EntryPoint::GLDeleteSamplers, + count, samplersPacked)); + if (isCallValid) + { + context->deleteSamplers(count, samplersPacked); + } + ANGLE_CAPTURE_GL(DeleteSamplers, isCallValid, context, count, samplersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteSync(GLsync sync) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteSync, "context = %d, sync = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)sync); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDeleteSync(context, angle::EntryPoint::GLDeleteSync, sync)); + if (isCallValid) + { + context->deleteSync(sync); + } + ANGLE_CAPTURE_GL(DeleteSync, isCallValid, context, sync); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteTransformFeedbacks(GLsizei n, const GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteTransformFeedbacks, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)ids); + + if (context) + { + const TransformFeedbackID *idsPacked = PackParam<const TransformFeedbackID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteTransformFeedbacks( + context, angle::EntryPoint::GLDeleteTransformFeedbacks, n, idsPacked)); + if (isCallValid) + { + context->deleteTransformFeedbacks(n, idsPacked); + } + ANGLE_CAPTURE_GL(DeleteTransformFeedbacks, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteVertexArrays(GLsizei n, const GLuint *arrays) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteVertexArrays, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)arrays); + + if (context) + { + const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDeleteVertexArrays( + context, angle::EntryPoint::GLDeleteVertexArrays, n, arraysPacked)); + if (isCallValid) + { + context->deleteVertexArrays(n, arraysPacked); + } + ANGLE_CAPTURE_GL(DeleteVertexArrays, isCallValid, context, n, arraysPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawArraysInstanced(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysInstanced, + "context = %d, mode = %s, first = %d, count = %d, instancecount = %d", CID(context), + GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instancecount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawArraysInstanced(context, angle::EntryPoint::GLDrawArraysInstanced, + modePacked, first, count, instancecount)); + if (isCallValid) + { + context->drawArraysInstanced(modePacked, first, count, instancecount); + } + ANGLE_CAPTURE_GL(DrawArraysInstanced, isCallValid, context, modePacked, first, count, + instancecount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawBuffers, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context), n, + (uintptr_t)bufs); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawBuffers(context, angle::EntryPoint::GLDrawBuffers, n, bufs)); + if (isCallValid) + { + context->drawBuffers(n, bufs); + } + ANGLE_CAPTURE_GL(DrawBuffers, isCallValid, context, n, bufs); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstanced(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstanced, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", instancecount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsInstanced(context, angle::EntryPoint::GLDrawElementsInstanced, + modePacked, count, typePacked, indices, instancecount)); + if (isCallValid) + { + context->drawElementsInstanced(modePacked, count, typePacked, indices, instancecount); + } + ANGLE_CAPTURE_GL(DrawElementsInstanced, isCallValid, context, modePacked, count, typePacked, + indices, instancecount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawRangeElements(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawRangeElements, + "context = %d, mode = %s, start = %u, end = %u, count = %d, type = %s, indices = " + "0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), start, end, 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() || + ValidateDrawRangeElements(context, angle::EntryPoint::GLDrawRangeElements, modePacked, + start, end, count, typePacked, indices)); + if (isCallValid) + { + context->drawRangeElements(modePacked, start, end, count, typePacked, indices); + } + ANGLE_CAPTURE_GL(DrawRangeElements, isCallValid, context, modePacked, start, end, count, + typePacked, indices); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EndQuery(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEndQuery, "context = %d, target = %s", CID(context), + GLenumToString(GLESEnum::QueryTarget, target)); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEndQuery(context, angle::EntryPoint::GLEndQuery, targetPacked)); + if (isCallValid) + { + context->endQuery(targetPacked); + } + ANGLE_CAPTURE_GL(EndQuery, isCallValid, context, targetPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EndTransformFeedback() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEndTransformFeedback, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEndTransformFeedback(context, angle::EntryPoint::GLEndTransformFeedback)); + if (isCallValid) + { + context->endTransformFeedback(); + } + ANGLE_CAPTURE_GL(EndTransformFeedback, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLsync GL_APIENTRY GL_FenceSync(GLenum condition, GLbitfield flags) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFenceSync, "context = %d, condition = %s, flags = %s", CID(context), + GLenumToString(GLESEnum::SyncCondition, condition), + GLbitfieldToString(GLESEnum::SyncBehaviorFlags, flags).c_str()); + + GLsync returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFenceSync(context, angle::EntryPoint::GLFenceSync, condition, flags)); + if (isCallValid) + { + returnValue = context->fenceSync(condition, flags); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLFenceSync, GLsync>(); + } + ANGLE_CAPTURE_GL(FenceSync, isCallValid, context, condition, flags, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLFenceSync, GLsync>(); + } + return returnValue; +} + +void GL_APIENTRY GL_FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFlushMappedBufferRange, + "context = %d, target = %s, offset = %llu, length = %llu", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length)); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFlushMappedBufferRange(context, angle::EntryPoint::GLFlushMappedBufferRange, + targetPacked, offset, length)); + if (isCallValid) + { + context->flushMappedBufferRange(targetPacked, offset, length); + } + ANGLE_CAPTURE_GL(FlushMappedBufferRange, isCallValid, context, targetPacked, offset, + length); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferTextureLayer(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint layer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTextureLayer, + "context = %d, target = %s, attachment = %s, texture = %u, level = %d, layer = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level, layer); + + if (context) + { + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferTextureLayer(context, angle::EntryPoint::GLFramebufferTextureLayer, + target, attachment, texturePacked, level, layer)); + if (isCallValid) + { + context->framebufferTextureLayer(target, attachment, texturePacked, level, layer); + } + ANGLE_CAPTURE_GL(FramebufferTextureLayer, isCallValid, context, target, attachment, + texturePacked, level, layer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenQueries(GLsizei n, GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenQueries, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context), n, + (uintptr_t)ids); + + if (context) + { + QueryID *idsPacked = PackParam<QueryID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenQueries(context, angle::EntryPoint::GLGenQueries, n, idsPacked)); + if (isCallValid) + { + context->genQueries(n, idsPacked); + } + ANGLE_CAPTURE_GL(GenQueries, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenSamplers(GLsizei count, GLuint *samplers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenSamplers, "context = %d, count = %d, samplers = 0x%016" PRIxPTR "", + CID(context), count, (uintptr_t)samplers); + + if (context) + { + SamplerID *samplersPacked = PackParam<SamplerID *>(samplers); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenSamplers(context, angle::EntryPoint::GLGenSamplers, count, samplersPacked)); + if (isCallValid) + { + context->genSamplers(count, samplersPacked); + } + ANGLE_CAPTURE_GL(GenSamplers, isCallValid, context, count, samplersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenTransformFeedbacks(GLsizei n, GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenTransformFeedbacks, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)ids); + + if (context) + { + TransformFeedbackID *idsPacked = PackParam<TransformFeedbackID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGenTransformFeedbacks( + context, angle::EntryPoint::GLGenTransformFeedbacks, n, idsPacked)); + if (isCallValid) + { + context->genTransformFeedbacks(n, idsPacked); + } + ANGLE_CAPTURE_GL(GenTransformFeedbacks, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenVertexArrays(GLsizei n, GLuint *arrays) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenVertexArrays, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)arrays); + + if (context) + { + VertexArrayID *arraysPacked = PackParam<VertexArrayID *>(arrays); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGenVertexArrays(context, angle::EntryPoint::GLGenVertexArrays, + n, arraysPacked)); + if (isCallValid) + { + context->genVertexArrays(n, arraysPacked); + } + ANGLE_CAPTURE_GL(GenVertexArrays, isCallValid, context, n, arraysPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetActiveUniformBlockName(GLuint program, + GLuint uniformBlockIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName) +{ + Context *context = GetValidGlobalContext(); + EVENT( + context, GLGetActiveUniformBlockName, + "context = %d, program = %u, uniformBlockIndex = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", uniformBlockName = 0x%016" PRIxPTR "", + CID(context), program, uniformBlockIndex, bufSize, (uintptr_t)length, + (uintptr_t)uniformBlockName); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetActiveUniformBlockName( + context, angle::EntryPoint::GLGetActiveUniformBlockName, programPacked, + uniformBlockIndexPacked, bufSize, length, uniformBlockName)); + if (isCallValid) + { + context->getActiveUniformBlockName(programPacked, uniformBlockIndexPacked, bufSize, + length, uniformBlockName); + } + ANGLE_CAPTURE_GL(GetActiveUniformBlockName, isCallValid, context, programPacked, + uniformBlockIndexPacked, bufSize, length, uniformBlockName); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetActiveUniformBlockiv(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetActiveUniformBlockiv, + "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, params = 0x%016" PRIxPTR + "", + CID(context), program, uniformBlockIndex, + GLenumToString(GLESEnum::UniformBlockPName, pname), (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetActiveUniformBlockiv( + context, angle::EntryPoint::GLGetActiveUniformBlockiv, + programPacked, uniformBlockIndexPacked, pname, params)); + if (isCallValid) + { + context->getActiveUniformBlockiv(programPacked, uniformBlockIndexPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetActiveUniformBlockiv, isCallValid, context, programPacked, + uniformBlockIndexPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetActiveUniformsiv(GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetActiveUniformsiv, + "context = %d, program = %u, uniformCount = %d, uniformIndices = 0x%016" PRIxPTR + ", pname = %s, params = 0x%016" PRIxPTR "", + CID(context), program, uniformCount, (uintptr_t)uniformIndices, + GLenumToString(GLESEnum::UniformPName, pname), (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetActiveUniformsiv( + context, angle::EntryPoint::GLGetActiveUniformsiv, programPacked, + uniformCount, uniformIndices, pname, params)); + if (isCallValid) + { + context->getActiveUniformsiv(programPacked, uniformCount, uniformIndices, pname, + params); + } + ANGLE_CAPTURE_GL(GetActiveUniformsiv, isCallValid, context, programPacked, uniformCount, + uniformIndices, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferParameteri64v, + "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() || + ValidateGetBufferParameteri64v(context, angle::EntryPoint::GLGetBufferParameteri64v, + targetPacked, pname, params)); + if (isCallValid) + { + context->getBufferParameteri64v(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetBufferParameteri64v, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBufferPointerv(GLenum target, GLenum pname, void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferPointerv, + "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() || + ValidateGetBufferPointerv(context, angle::EntryPoint::GLGetBufferPointerv, + targetPacked, pname, params)); + if (isCallValid) + { + context->getBufferPointerv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetBufferPointerv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLint GL_APIENTRY GL_GetFragDataLocation(GLuint program, const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFragDataLocation, "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() || + ValidateGetFragDataLocation(context, angle::EntryPoint::GLGetFragDataLocation, + programPacked, name)); + if (isCallValid) + { + returnValue = context->getFragDataLocation(programPacked, name); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataLocation, GLint>(); + } + ANGLE_CAPTURE_GL(GetFragDataLocation, isCallValid, context, programPacked, name, + returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataLocation, GLint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_GetInteger64i_v(GLenum target, GLuint index, GLint64 *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInteger64i_v, + "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::GetPName, target), index, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetInteger64i_v(context, angle::EntryPoint::GLGetInteger64i_v, + target, index, data)); + if (isCallValid) + { + context->getInteger64i_v(target, index, data); + } + ANGLE_CAPTURE_GL(GetInteger64i_v, isCallValid, context, target, index, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInteger64v(GLenum pname, GLint64 *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInteger64v, "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() || + ValidateGetInteger64v(context, angle::EntryPoint::GLGetInteger64v, pname, data)); + if (isCallValid) + { + context->getInteger64v(pname, data); + } + ANGLE_CAPTURE_GL(GetInteger64v, isCallValid, context, pname, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLint *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetIntegeri_v, + "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::GetPName, target), index, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetIntegeri_v(context, angle::EntryPoint::GLGetIntegeri_v, + target, index, data)); + if (isCallValid) + { + context->getIntegeri_v(target, index, data); + } + ANGLE_CAPTURE_GL(GetIntegeri_v, isCallValid, context, target, index, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInternalformativ(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInternalformativ, + "context = %d, target = %s, internalformat = %s, pname = %s, count = %d, params = " + "0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), + GLenumToString(GLESEnum::InternalFormat, internalformat), + GLenumToString(GLESEnum::InternalFormatPName, pname), count, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetInternalformativ(context, angle::EntryPoint::GLGetInternalformativ, target, + internalformat, pname, count, params)); + if (isCallValid) + { + context->getInternalformativ(target, internalformat, pname, count, params); + } + ANGLE_CAPTURE_GL(GetInternalformativ, isCallValid, context, target, internalformat, pname, + count, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramBinary(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramBinary, + "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "", + CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, + (uintptr_t)binary); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramBinary(context, angle::EntryPoint::GLGetProgramBinary, programPacked, + bufSize, length, binaryFormat, binary)); + if (isCallValid) + { + context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary); + } + ANGLE_CAPTURE_GL(GetProgramBinary, isCallValid, context, programPacked, bufSize, length, + binaryFormat, binary); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryObjectuiv, + "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryObjectuiv(context, angle::EntryPoint::GLGetQueryObjectuiv, idPacked, + pname, params)); + if (isCallValid) + { + context->getQueryObjectuiv(idPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectuiv, isCallValid, context, idPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryiv(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryiv, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::QueryTarget, target), + GLenumToString(GLESEnum::QueryParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryiv(context, angle::EntryPoint::GLGetQueryiv, + targetPacked, pname, params)); + if (isCallValid) + { + context->getQueryiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryiv, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterfv, + "context = %d, sampler = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetSamplerParameterfv(context, angle::EntryPoint::GLGetSamplerParameterfv, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterfv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterfv, isCallValid, context, samplerPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameteriv, + "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() || + ValidateGetSamplerParameteriv(context, angle::EntryPoint::GLGetSamplerParameteriv, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameteriv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameteriv, isCallValid, context, samplerPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetStringi, "context = %d, name = %s, index = %u", CID(context), + GLenumToString(GLESEnum::StringName, name), index); + + const GLubyte *returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetStringi(context, angle::EntryPoint::GLGetStringi, name, index)); + if (isCallValid) + { + returnValue = context->getStringi(name, index); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetStringi, const GLubyte *>(); + } + ANGLE_CAPTURE_GL(GetStringi, isCallValid, context, name, index, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetStringi, const GLubyte *>(); + } + return returnValue; +} + +void GL_APIENTRY +GL_GetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetSynciv, + "context = %d, sync = 0x%016" PRIxPTR ", pname = %s, count = %d, length = 0x%016" PRIxPTR + ", values = 0x%016" PRIxPTR "", + CID(context), (uintptr_t)sync, GLenumToString(GLESEnum::SyncParameterName, pname), count, + (uintptr_t)length, (uintptr_t)values); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || ValidateGetSynciv(context, angle::EntryPoint::GLGetSynciv, + sync, pname, count, length, values)); + if (isCallValid) + { + context->getSynciv(sync, pname, count, length, values); + } + ANGLE_CAPTURE_GL(GetSynciv, isCallValid, context, sync, pname, count, length, values); + } + else + {} +} + +void GL_APIENTRY GL_GetTransformFeedbackVarying(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTransformFeedbackVarying, + "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() || + ValidateGetTransformFeedbackVarying( + context, angle::EntryPoint::GLGetTransformFeedbackVarying, + programPacked, index, bufSize, length, size, type, name)); + if (isCallValid) + { + context->getTransformFeedbackVarying(programPacked, index, bufSize, length, size, type, + name); + } + ANGLE_CAPTURE_GL(GetTransformFeedbackVarying, isCallValid, context, programPacked, index, + bufSize, length, size, type, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_GetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformBlockIndex, + "context = %d, program = %u, uniformBlockName = 0x%016" PRIxPTR "", CID(context), program, + (uintptr_t)uniformBlockName); + + GLuint returnValue; + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetUniformBlockIndex(context, angle::EntryPoint::GLGetUniformBlockIndex, + programPacked, uniformBlockName)); + if (isCallValid) + { + returnValue = context->getUniformBlockIndex(programPacked, uniformBlockName); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetUniformBlockIndex, GLuint>(); + } + ANGLE_CAPTURE_GL(GetUniformBlockIndex, isCallValid, context, programPacked, + uniformBlockName, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetUniformBlockIndex, GLuint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_GetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformIndices, + "context = %d, program = %u, uniformCount = %d, uniformNames = 0x%016" PRIxPTR + ", uniformIndices = 0x%016" PRIxPTR "", + CID(context), program, uniformCount, (uintptr_t)uniformNames, (uintptr_t)uniformIndices); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetUniformIndices(context, angle::EntryPoint::GLGetUniformIndices, + programPacked, uniformCount, uniformNames, uniformIndices)); + if (isCallValid) + { + context->getUniformIndices(programPacked, uniformCount, uniformNames, uniformIndices); + } + ANGLE_CAPTURE_GL(GetUniformIndices, isCallValid, context, programPacked, uniformCount, + uniformNames, uniformIndices); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUniformuiv(GLuint program, GLint location, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformuiv, + "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() || + ValidateGetUniformuiv(context, angle::EntryPoint::GLGetUniformuiv, + programPacked, locationPacked, params)); + if (isCallValid) + { + context->getUniformuiv(programPacked, locationPacked, params); + } + ANGLE_CAPTURE_GL(GetUniformuiv, isCallValid, context, programPacked, locationPacked, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribIiv, + "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, + GLenumToString(GLESEnum::VertexAttribEnum, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetVertexAttribIiv(context, angle::EntryPoint::GLGetVertexAttribIiv, index, + pname, params)); + if (isCallValid) + { + context->getVertexAttribIiv(index, pname, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribIiv, isCallValid, context, index, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribIuiv, + "context = %d, index = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), index, + GLenumToString(GLESEnum::VertexAttribEnum, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetVertexAttribIuiv(context, angle::EntryPoint::GLGetVertexAttribIuiv, index, + pname, params)); + if (isCallValid) + { + context->getVertexAttribIuiv(index, pname, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribIuiv, isCallValid, context, index, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_InvalidateFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLInvalidateFramebuffer, + "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, + (uintptr_t)attachments); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateInvalidateFramebuffer(context, angle::EntryPoint::GLInvalidateFramebuffer, + target, numAttachments, attachments)); + if (isCallValid) + { + context->invalidateFramebuffer(target, numAttachments, attachments); + } + ANGLE_CAPTURE_GL(InvalidateFramebuffer, isCallValid, context, target, numAttachments, + attachments); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_InvalidateSubFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLInvalidateSubFramebuffer, + "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR + ", x = %d, y = %d, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, + (uintptr_t)attachments, x, y, width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateInvalidateSubFramebuffer( + context, angle::EntryPoint::GLInvalidateSubFramebuffer, target, + numAttachments, attachments, x, y, width, height)); + if (isCallValid) + { + context->invalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, + height); + } + ANGLE_CAPTURE_GL(InvalidateSubFramebuffer, isCallValid, context, target, numAttachments, + attachments, x, y, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsQuery(GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsQuery, "context = %d, id = %u", CID(context), id); + + GLboolean returnValue; + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateIsQuery(context, angle::EntryPoint::GLIsQuery, idPacked)); + if (isCallValid) + { + returnValue = context->isQuery(idPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQuery, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsQuery, isCallValid, context, idPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQuery, GLboolean>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_IsSampler(GLuint sampler) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsSampler, "context = %d, sampler = %u", CID(context), sampler); + + GLboolean returnValue; + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsSampler(context, angle::EntryPoint::GLIsSampler, samplerPacked)); + if (isCallValid) + { + returnValue = context->isSampler(samplerPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSampler, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsSampler, isCallValid, context, samplerPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSampler, GLboolean>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_IsSync(GLsync sync) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsSync, "context = %d, sync = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)sync); + + GLboolean returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateIsSync(context, angle::EntryPoint::GLIsSync, sync)); + if (isCallValid) + { + returnValue = context->isSync(sync); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSync, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsSync, isCallValid, context, sync, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSync, GLboolean>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_IsTransformFeedback(GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsTransformFeedback, "context = %d, id = %u", CID(context), id); + + GLboolean returnValue; + if (context) + { + TransformFeedbackID idPacked = PackParam<TransformFeedbackID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateIsTransformFeedback( + context, angle::EntryPoint::GLIsTransformFeedback, idPacked)); + if (isCallValid) + { + returnValue = context->isTransformFeedback(idPacked); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLIsTransformFeedback, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsTransformFeedback, isCallValid, context, idPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsTransformFeedback, GLboolean>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_IsVertexArray(GLuint array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsVertexArray, "context = %d, array = %u", CID(context), array); + + GLboolean returnValue; + if (context) + { + VertexArrayID arrayPacked = PackParam<VertexArrayID>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsVertexArray(context, angle::EntryPoint::GLIsVertexArray, arrayPacked)); + if (isCallValid) + { + returnValue = context->isVertexArray(arrayPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArray, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsVertexArray, isCallValid, context, arrayPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArray, GLboolean>(); + } + return returnValue; +} + +void *GL_APIENTRY GL_MapBufferRange(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMapBufferRange, + "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length), + GLbitfieldToString(GLESEnum::MapBufferAccessMask, access).c_str()); + + void *returnValue; + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMapBufferRange(context, angle::EntryPoint::GLMapBufferRange, + targetPacked, offset, length, access)); + if (isCallValid) + { + returnValue = context->mapBufferRange(targetPacked, offset, length, access); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRange, void *>(); + } + ANGLE_CAPTURE_GL(MapBufferRange, isCallValid, context, targetPacked, offset, length, access, + returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRange, void *>(); + } + return returnValue; +} + +void GL_APIENTRY GL_PauseTransformFeedback() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPauseTransformFeedback, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePauseTransformFeedback(context, angle::EntryPoint::GLPauseTransformFeedback)); + if (isCallValid) + { + context->pauseTransformFeedback(); + } + ANGLE_CAPTURE_GL(PauseTransformFeedback, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramBinary(GLuint program, + GLenum binaryFormat, + const void *binary, + GLsizei length) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramBinary, + "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d", + CID(context), program, GLenumToString(GLESEnum::AllEnums, binaryFormat), + (uintptr_t)binary, length); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramBinary(context, angle::EntryPoint::GLProgramBinary, + programPacked, binaryFormat, binary, length)); + if (isCallValid) + { + context->programBinary(programPacked, binaryFormat, binary, length); + } + ANGLE_CAPTURE_GL(ProgramBinary, isCallValid, context, programPacked, binaryFormat, binary, + length); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramParameteri(GLuint program, GLenum pname, GLint value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramParameteri, "context = %d, program = %u, pname = %s, value = %d", + CID(context), program, GLenumToString(GLESEnum::ProgramParameterPName, pname), value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramParameteri(context, angle::EntryPoint::GLProgramParameteri, + programPacked, pname, value)); + if (isCallValid) + { + context->programParameteri(programPacked, pname, value); + } + ANGLE_CAPTURE_GL(ProgramParameteri, isCallValid, context, programPacked, pname, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReadBuffer(GLenum src) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReadBuffer, "context = %d, src = %s", CID(context), + GLenumToString(GLESEnum::ReadBufferMode, src)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateReadBuffer(context, angle::EntryPoint::GLReadBuffer, src)); + if (isCallValid) + { + context->readBuffer(src); + } + ANGLE_CAPTURE_GL(ReadBuffer, isCallValid, context, src); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_RenderbufferStorageMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRenderbufferStorageMultisample, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRenderbufferStorageMultisample( + context, angle::EntryPoint::GLRenderbufferStorageMultisample, + target, samples, internalformat, width, height)); + if (isCallValid) + { + context->renderbufferStorageMultisample(target, samples, internalformat, width, height); + } + ANGLE_CAPTURE_GL(RenderbufferStorageMultisample, isCallValid, context, target, samples, + internalformat, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ResumeTransformFeedback() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLResumeTransformFeedback, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateResumeTransformFeedback( + context, angle::EntryPoint::GLResumeTransformFeedback)); + if (isCallValid) + { + context->resumeTransformFeedback(); + } + ANGLE_CAPTURE_GL(ResumeTransformFeedback, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterf, "context = %d, sampler = %u, pname = %s, param = %f", + CID(context), sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSamplerParameterf(context, angle::EntryPoint::GLSamplerParameterf, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterf(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterf, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterfv, + "context = %d, sampler = %u, pname = %s, param = 0x%016" PRIxPTR "", CID(context), + sampler, GLenumToString(GLESEnum::SamplerParameterF, pname), (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSamplerParameterfv(context, angle::EntryPoint::GLSamplerParameterfv, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterfv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterfv, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameteri(GLuint sampler, GLenum pname, GLint param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameteri, "context = %d, sampler = %u, pname = %s, param = %d", + CID(context), sampler, GLenumToString(GLESEnum::SamplerParameterI, pname), param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSamplerParameteri(context, angle::EntryPoint::GLSamplerParameteri, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameteri(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameteri, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameteriv, + "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() || + ValidateSamplerParameteriv(context, angle::EntryPoint::GLSamplerParameteriv, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameteriv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameteriv, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexImage3D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexImage3D, + "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " + "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat, + width, height, depth, 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() || + ValidateTexImage3D(context, angle::EntryPoint::GLTexImage3D, + targetPacked, level, internalformat, width, height, + depth, border, format, type, pixels)); + if (isCallValid) + { + context->texImage3D(targetPacked, level, internalformat, width, height, depth, border, + format, type, pixels); + } + ANGLE_CAPTURE_GL(TexImage3D, isCallValid, context, targetPacked, level, internalformat, + width, height, depth, border, format, type, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_TexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage2D, + "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage2D(context, angle::EntryPoint::GLTexStorage2D, targetPacked, levels, + internalformat, width, height)); + if (isCallValid) + { + context->texStorage2D(targetPacked, levels, internalformat, width, height); + } + ANGLE_CAPTURE_GL(TexStorage2D, isCallValid, context, targetPacked, levels, internalformat, + width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorage3D(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage3D, + "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage3D(context, angle::EntryPoint::GLTexStorage3D, targetPacked, levels, + internalformat, width, height, depth)); + if (isCallValid) + { + context->texStorage3D(targetPacked, levels, internalformat, width, height, depth); + } + ANGLE_CAPTURE_GL(TexStorage3D, isCallValid, context, targetPacked, levels, internalformat, + width, height, depth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexSubImage3D, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " + "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, 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() || + ValidateTexSubImage3D(context, angle::EntryPoint::GLTexSubImage3D, + targetPacked, level, xoffset, yoffset, zoffset, + width, height, depth, format, type, pixels)); + if (isCallValid) + { + context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height, + depth, format, type, pixels); + } + ANGLE_CAPTURE_GL(TexSubImage3D, isCallValid, context, targetPacked, level, xoffset, yoffset, + zoffset, width, height, depth, format, type, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TransformFeedbackVaryings(GLuint program, + GLsizei count, + const GLchar *const *varyings, + GLenum bufferMode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTransformFeedbackVaryings, + "context = %d, program = %u, count = %d, varyings = 0x%016" PRIxPTR ", bufferMode = %s", + CID(context), program, count, (uintptr_t)varyings, + GLenumToString(GLESEnum::TransformFeedbackBufferMode, bufferMode)); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTransformFeedbackVaryings( + context, angle::EntryPoint::GLTransformFeedbackVaryings, + programPacked, count, varyings, bufferMode)); + if (isCallValid) + { + context->transformFeedbackVaryings(programPacked, count, varyings, bufferMode); + } + ANGLE_CAPTURE_GL(TransformFeedbackVaryings, isCallValid, context, programPacked, count, + varyings, bufferMode); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform1ui(GLint location, GLuint v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform1ui, "context = %d, location = %d, v0 = %u", CID(context), location, + v0); + + if (context) + { + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateUniform1ui(context, angle::EntryPoint::GLUniform1ui, locationPacked, v0)); + if (isCallValid) + { + context->uniform1ui(locationPacked, v0); + } + ANGLE_CAPTURE_GL(Uniform1ui, isCallValid, context, locationPacked, v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform1uiv(GLint location, GLsizei count, const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform1uiv, + "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() || + ValidateUniform1uiv(context, angle::EntryPoint::GLUniform1uiv, + locationPacked, count, value)); + if (isCallValid) + { + context->uniform1uiv(locationPacked, count, value); + } + ANGLE_CAPTURE_GL(Uniform1uiv, isCallValid, context, locationPacked, count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform2ui(GLint location, GLuint v0, GLuint v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform2ui, "context = %d, location = %d, v0 = %u, v1 = %u", CID(context), + location, v0, v1); + + if (context) + { + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateUniform2ui(context, angle::EntryPoint::GLUniform2ui, locationPacked, v0, v1)); + if (isCallValid) + { + context->uniform2ui(locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(Uniform2ui, isCallValid, context, locationPacked, v0, v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform2uiv(GLint location, GLsizei count, const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform2uiv, + "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() || + ValidateUniform2uiv(context, angle::EntryPoint::GLUniform2uiv, + locationPacked, count, value)); + if (isCallValid) + { + context->uniform2uiv(locationPacked, count, value); + } + ANGLE_CAPTURE_GL(Uniform2uiv, isCallValid, context, locationPacked, count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform3ui, "context = %d, location = %d, v0 = %u, v1 = %u, v2 = %u", + CID(context), location, v0, v1, v2); + + if (context) + { + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateUniform3ui(context, angle::EntryPoint::GLUniform3ui, + locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->uniform3ui(locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(Uniform3ui, isCallValid, context, locationPacked, v0, v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform3uiv(GLint location, GLsizei count, const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform3uiv, + "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() || + ValidateUniform3uiv(context, angle::EntryPoint::GLUniform3uiv, + locationPacked, count, value)); + if (isCallValid) + { + context->uniform3uiv(locationPacked, count, value); + } + ANGLE_CAPTURE_GL(Uniform3uiv, isCallValid, context, locationPacked, count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform4ui, "context = %d, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u", + CID(context), location, v0, v1, v2, v3); + + if (context) + { + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateUniform4ui(context, angle::EntryPoint::GLUniform4ui, + locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->uniform4ui(locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(Uniform4ui, isCallValid, context, locationPacked, v0, v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_Uniform4uiv(GLint location, GLsizei count, const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniform4uiv, + "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() || + ValidateUniform4uiv(context, angle::EntryPoint::GLUniform4uiv, + locationPacked, count, value)); + if (isCallValid) + { + context->uniform4uiv(locationPacked, count, value); + } + ANGLE_CAPTURE_GL(Uniform4uiv, isCallValid, context, locationPacked, count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformBlockBinding(GLuint program, + GLuint uniformBlockIndex, + GLuint uniformBlockBinding) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformBlockBinding, + "context = %d, program = %u, uniformBlockIndex = %u, uniformBlockBinding = %u", + CID(context), program, uniformBlockIndex, uniformBlockBinding); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateUniformBlockBinding( + context, angle::EntryPoint::GLUniformBlockBinding, programPacked, + uniformBlockIndexPacked, uniformBlockBinding)); + if (isCallValid) + { + context->uniformBlockBinding(programPacked, uniformBlockIndexPacked, + uniformBlockBinding); + } + ANGLE_CAPTURE_GL(UniformBlockBinding, isCallValid, context, programPacked, + uniformBlockIndexPacked, uniformBlockBinding); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix2x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix2x3fv, + "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() || + ValidateUniformMatrix2x3fv(context, angle::EntryPoint::GLUniformMatrix2x3fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix2x3fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix2x3fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix2x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix2x4fv, + "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() || + ValidateUniformMatrix2x4fv(context, angle::EntryPoint::GLUniformMatrix2x4fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix2x4fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix2x4fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix3x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix3x2fv, + "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() || + ValidateUniformMatrix3x2fv(context, angle::EntryPoint::GLUniformMatrix3x2fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix3x2fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix3x2fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix3x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix3x4fv, + "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() || + ValidateUniformMatrix3x4fv(context, angle::EntryPoint::GLUniformMatrix3x4fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix3x4fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix3x4fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix4x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix4x2fv, + "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() || + ValidateUniformMatrix4x2fv(context, angle::EntryPoint::GLUniformMatrix4x2fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix4x2fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix4x2fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UniformMatrix4x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUniformMatrix4x3fv, + "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() || + ValidateUniformMatrix4x3fv(context, angle::EntryPoint::GLUniformMatrix4x3fv, + locationPacked, count, transpose, value)); + if (isCallValid) + { + context->uniformMatrix4x3fv(locationPacked, count, transpose, value); + } + ANGLE_CAPTURE_GL(UniformMatrix4x3fv, isCallValid, context, locationPacked, count, transpose, + value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_UnmapBuffer(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUnmapBuffer, "context = %d, target = %s", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target)); + + GLboolean returnValue; + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateUnmapBuffer(context, angle::EntryPoint::GLUnmapBuffer, targetPacked)); + if (isCallValid) + { + returnValue = context->unmapBuffer(targetPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBuffer, GLboolean>(); + } + ANGLE_CAPTURE_GL(UnmapBuffer, isCallValid, context, targetPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBuffer, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_VertexAttribDivisor(GLuint index, GLuint divisor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribDivisor, "context = %d, index = %u, divisor = %u", CID(context), + index, divisor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateVertexAttribDivisor( + context, angle::EntryPoint::GLVertexAttribDivisor, index, divisor)); + if (isCallValid) + { + context->vertexAttribDivisor(index, divisor); + } + ANGLE_CAPTURE_GL(VertexAttribDivisor, isCallValid, context, index, divisor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribI4i, "context = %d, index = %u, x = %d, y = %d, z = %d, w = %d", + CID(context), index, x, y, z, w); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateVertexAttribI4i(context, angle::EntryPoint::GLVertexAttribI4i, + index, x, y, z, w)); + if (isCallValid) + { + context->vertexAttribI4i(index, x, y, z, w); + } + ANGLE_CAPTURE_GL(VertexAttribI4i, isCallValid, context, index, x, y, z, w); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribI4iv(GLuint index, const GLint *v) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribI4iv, "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() || + ValidateVertexAttribI4iv(context, angle::EntryPoint::GLVertexAttribI4iv, index, v)); + if (isCallValid) + { + context->vertexAttribI4iv(index, v); + } + ANGLE_CAPTURE_GL(VertexAttribI4iv, isCallValid, context, index, v); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribI4ui, "context = %d, index = %u, x = %u, y = %u, z = %u, w = %u", + CID(context), index, x, y, z, w); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateVertexAttribI4ui(context, angle::EntryPoint::GLVertexAttribI4ui, + index, x, y, z, w)); + if (isCallValid) + { + context->vertexAttribI4ui(index, x, y, z, w); + } + ANGLE_CAPTURE_GL(VertexAttribI4ui, isCallValid, context, index, x, y, z, w); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribI4uiv(GLuint index, const GLuint *v) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribI4uiv, "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() || + ValidateVertexAttribI4uiv(context, angle::EntryPoint::GLVertexAttribI4uiv, index, v)); + if (isCallValid) + { + context->vertexAttribI4uiv(index, v); + } + ANGLE_CAPTURE_GL(VertexAttribI4uiv, isCallValid, context, index, v); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribIPointer, + "context = %d, index = %u, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR + "", + CID(context), index, size, GLenumToString(GLESEnum::VertexAttribIType, type), stride, + (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribIPointer(context, angle::EntryPoint::GLVertexAttribIPointer, index, + size, typePacked, stride, pointer)); + if (isCallValid) + { + context->vertexAttribIPointer(index, size, typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(VertexAttribIPointer, isCallValid, context, index, size, typePacked, + stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLWaitSync, "context = %d, sync = 0x%016" PRIxPTR ", flags = %s, timeout = %llu", + CID(context), (uintptr_t)sync, + GLbitfieldToString(GLESEnum::SyncBehaviorFlags, flags).c_str(), + static_cast<unsigned long long>(timeout)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateWaitSync(context, angle::EntryPoint::GLWaitSync, sync, flags, timeout)); + if (isCallValid) + { + context->waitSync(sync, flags, timeout); + } + ANGLE_CAPTURE_GL(WaitSync, isCallValid, context, sync, flags, timeout); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h new file mode 100644 index 0000000000..7660b8a427 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_0_autogen.h @@ -0,0 +1,299 @@ +// 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_0_autogen.h: +// Defines the GLES 3.0 entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_ + +#include <GLES3/gl3.h> +#include <export.h> + +extern "C" { +ANGLE_EXPORT void GL_APIENTRY GL_BeginQuery(GLenum target, GLuint id); +ANGLE_EXPORT void GL_APIENTRY GL_BeginTransformFeedback(GLenum primitiveMode); +ANGLE_EXPORT void GL_APIENTRY GL_BindBufferBase(GLenum target, GLuint index, GLuint buffer); +ANGLE_EXPORT void GL_APIENTRY +GL_BindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +ANGLE_EXPORT void GL_APIENTRY GL_BindSampler(GLuint unit, GLuint sampler); +ANGLE_EXPORT void GL_APIENTRY GL_BindTransformFeedback(GLenum target, GLuint id); +ANGLE_EXPORT void GL_APIENTRY GL_BindVertexArray(GLuint array); +ANGLE_EXPORT void GL_APIENTRY GL_BlitFramebuffer(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); +ANGLE_EXPORT void GL_APIENTRY GL_ClearBufferfi(GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil); +ANGLE_EXPORT void GL_APIENTRY GL_ClearBufferfv(GLenum buffer, + GLint drawbuffer, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ClearBufferuiv(GLenum buffer, + GLint drawbuffer, + const GLuint *value); +ANGLE_EXPORT GLenum GL_APIENTRY GL_ClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexImage3D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CopyBufferSubData(GLenum readTarget, + GLenum writeTarget, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size); +ANGLE_EXPORT void GL_APIENTRY GL_CopyTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteQueries(GLsizei n, const GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteSamplers(GLsizei count, const GLuint *samplers); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteSync(GLsync sync); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteTransformFeedbacks(GLsizei n, const GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteVertexArrays(GLsizei n, const GLuint *arrays); +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysInstanced(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount); +ANGLE_EXPORT void GL_APIENTRY GL_DrawBuffers(GLsizei n, const GLenum *bufs); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstanced(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount); +ANGLE_EXPORT void GL_APIENTRY GL_DrawRangeElements(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices); +ANGLE_EXPORT void GL_APIENTRY GL_EndQuery(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_EndTransformFeedback(); +ANGLE_EXPORT GLsync GL_APIENTRY GL_FenceSync(GLenum condition, GLbitfield flags); +ANGLE_EXPORT void GL_APIENTRY GL_FlushMappedBufferRange(GLenum target, + GLintptr offset, + GLsizeiptr length); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTextureLayer(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint layer); +ANGLE_EXPORT void GL_APIENTRY GL_GenQueries(GLsizei n, GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_GenSamplers(GLsizei count, GLuint *samplers); +ANGLE_EXPORT void GL_APIENTRY GL_GenTransformFeedbacks(GLsizei n, GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_GenVertexArrays(GLsizei n, GLuint *arrays); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveUniformBlockName(GLuint program, + GLuint uniformBlockIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveUniformBlockiv(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveUniformsiv(GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferParameteri64v(GLenum target, + GLenum pname, + GLint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferPointerv(GLenum target, GLenum pname, void **params); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetFragDataLocation(GLuint program, const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetInteger64i_v(GLenum target, GLuint index, GLint64 *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetInteger64v(GLenum pname, GLint64 *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetIntegeri_v(GLenum target, GLuint index, GLint *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetInternalformativ(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramBinary(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryiv(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterfv(GLuint sampler, + GLenum pname, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params); +ANGLE_EXPORT const GLubyte *GL_APIENTRY GL_GetStringi(GLenum name, GLuint index); +ANGLE_EXPORT void GL_APIENTRY +GL_GetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +ANGLE_EXPORT void GL_APIENTRY GL_GetTransformFeedbackVarying(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name); +ANGLE_EXPORT GLuint GL_APIENTRY GL_GetUniformBlockIndex(GLuint program, + const GLchar *uniformBlockName); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformuiv(GLuint program, GLint location, GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribIiv(GLuint index, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_InvalidateFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments); +ANGLE_EXPORT void GL_APIENTRY GL_InvalidateSubFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsQuery(GLuint id); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsSampler(GLuint sampler); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsSync(GLsync sync); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsTransformFeedback(GLuint id); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsVertexArray(GLuint array); +ANGLE_EXPORT void *GL_APIENTRY GL_MapBufferRange(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access); +ANGLE_EXPORT void GL_APIENTRY GL_PauseTransformFeedback(); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramBinary(GLuint program, + GLenum binaryFormat, + const void *binary, + GLsizei length); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramParameteri(GLuint program, GLenum pname, GLint value); +ANGLE_EXPORT void GL_APIENTRY GL_ReadBuffer(GLenum src); +ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorageMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_ResumeTransformFeedback(); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterf(GLuint sampler, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterfv(GLuint sampler, + GLenum pname, + const GLfloat *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameteri(GLuint sampler, GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameteriv(GLuint sampler, + GLenum pname, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_TexImage3D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage2D(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage3D(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth); +ANGLE_EXPORT void GL_APIENTRY GL_TexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TransformFeedbackVaryings(GLuint program, + GLsizei count, + const GLchar *const *varyings, + GLenum bufferMode); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1ui(GLint location, GLuint v0); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform1uiv(GLint location, GLsizei count, const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2ui(GLint location, GLuint v0, GLuint v1); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform2uiv(GLint location, GLsizei count, const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform3uiv(GLint location, GLsizei count, const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_Uniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +ANGLE_EXPORT void GL_APIENTRY GL_Uniform4uiv(GLint location, GLsizei count, const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformBlockBinding(GLuint program, + GLuint uniformBlockIndex, + GLuint uniformBlockBinding); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix2x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix2x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix3x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix3x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix4x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UniformMatrix4x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_UnmapBuffer(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribDivisor(GLuint index, GLuint divisor); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribI4iv(GLuint index, const GLint *v); +ANGLE_EXPORT void GL_APIENTRY +GL_VertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribI4uiv(GLuint index, const GLuint *v); +ANGLE_EXPORT void GL_APIENTRY +GL_VertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +ANGLE_EXPORT void GL_APIENTRY GL_WaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_3_0_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp new file mode 100644 index 0000000000..a1345d5a62 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.cpp @@ -0,0 +1,2098 @@ +// 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_1_autogen.cpp: +// Defines the GLES 3.1 entry points. + +#include "libGLESv2/entry_points_gles_3_1_autogen.h" + +#include "common/entry_points_enum_autogen.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/capture/capture_gles_3_1_autogen.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationES31.h" +#include "libGLESv2/global_state.h" + +using namespace gl; + +extern "C" { +void GL_APIENTRY GL_ActiveShaderProgram(GLuint pipeline, GLuint program) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLActiveShaderProgram, "context = %d, pipeline = %u, program = %u", CID(context), + pipeline, program); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateActiveShaderProgram(context, angle::EntryPoint::GLActiveShaderProgram, + pipelinePacked, programPacked)); + if (isCallValid) + { + context->activeShaderProgram(pipelinePacked, programPacked); + } + ANGLE_CAPTURE_GL(ActiveShaderProgram, isCallValid, context, pipelinePacked, programPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindImageTexture(GLuint unit, + GLuint texture, + GLint level, + GLboolean layered, + GLint layer, + GLenum access, + GLenum format) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindImageTexture, + "context = %d, unit = %u, texture = %u, level = %d, layered = %s, layer = %d, access = " + "%s, format = %s", + CID(context), unit, texture, level, GLbooleanToString(layered), layer, + GLenumToString(GLESEnum::BufferAccessARB, access), + GLenumToString(GLESEnum::InternalFormat, format)); + + if (context) + { + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindImageTexture(context, angle::EntryPoint::GLBindImageTexture, unit, + texturePacked, level, layered, layer, access, format)); + if (isCallValid) + { + context->bindImageTexture(unit, texturePacked, level, layered, layer, access, format); + } + ANGLE_CAPTURE_GL(BindImageTexture, isCallValid, context, unit, texturePacked, level, + layered, layer, access, format); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindProgramPipeline(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindProgramPipeline( + context, angle::EntryPoint::GLBindProgramPipeline, pipelinePacked)); + if (isCallValid) + { + context->bindProgramPipeline(pipelinePacked); + } + ANGLE_CAPTURE_GL(BindProgramPipeline, isCallValid, context, pipelinePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindVertexBuffer(GLuint bindingindex, + GLuint buffer, + GLintptr offset, + GLsizei stride) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, 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 = PackParam<BufferID>(buffer); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindVertexBuffer(context, angle::EntryPoint::GLBindVertexBuffer, + bindingindex, bufferPacked, offset, stride)); + if (isCallValid) + { + context->bindVertexBuffer(bindingindex, bufferPacked, offset, stride); + } + ANGLE_CAPTURE_GL(BindVertexBuffer, isCallValid, context, bindingindex, bufferPacked, offset, + stride); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCreateShaderProgramv, + "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings); + + GLuint returnValue; + if (context) + { + ShaderType typePacked = PackParam<ShaderType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCreateShaderProgramv(context, angle::EntryPoint::GLCreateShaderProgramv, + typePacked, count, strings)); + if (isCallValid) + { + returnValue = context->createShaderProgramv(typePacked, count, strings); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>(); + } + ANGLE_CAPTURE_GL(CreateShaderProgramv, isCallValid, context, typePacked, count, strings, + returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramv, GLuint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_DeleteProgramPipelines(GLsizei n, const GLuint *pipelines) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)pipelines); + + if (context) + { + const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteProgramPipelines(context, angle::EntryPoint::GLDeleteProgramPipelines, n, + pipelinesPacked)); + if (isCallValid) + { + context->deleteProgramPipelines(n, pipelinesPacked); + } + ANGLE_CAPTURE_GL(DeleteProgramPipelines, isCallValid, context, n, pipelinesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, 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) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDispatchCompute(context, angle::EntryPoint::GLDispatchCompute, + num_groups_x, num_groups_y, num_groups_z)); + if (isCallValid) + { + context->dispatchCompute(num_groups_x, num_groups_y, num_groups_z); + } + ANGLE_CAPTURE_GL(DispatchCompute, isCallValid, context, num_groups_x, num_groups_y, + num_groups_z); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DispatchComputeIndirect(GLintptr indirect) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDispatchComputeIndirect, "context = %d, indirect = %llu", CID(context), + static_cast<unsigned long long>(indirect)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDispatchComputeIndirect( + context, angle::EntryPoint::GLDispatchComputeIndirect, indirect)); + if (isCallValid) + { + context->dispatchComputeIndirect(indirect); + } + ANGLE_CAPTURE_GL(DispatchComputeIndirect, isCallValid, context, indirect); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawArraysIndirect(GLenum mode, const void *indirect) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysIndirect, "context = %d, mode = %s, indirect = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawArraysIndirect(context, angle::EntryPoint::GLDrawArraysIndirect, + modePacked, indirect)); + if (isCallValid) + { + context->drawArraysIndirect(modePacked, indirect); + } + ANGLE_CAPTURE_GL(DrawArraysIndirect, isCallValid, context, modePacked, indirect); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsIndirect, + "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::PrimitiveType, mode), + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsIndirect(context, angle::EntryPoint::GLDrawElementsIndirect, + modePacked, typePacked, indirect)); + if (isCallValid) + { + context->drawElementsIndirect(modePacked, typePacked, indirect); + } + ANGLE_CAPTURE_GL(DrawElementsIndirect, isCallValid, context, modePacked, typePacked, + indirect); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferParameteri, "context = %d, target = %s, pname = %s, param = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferParameterName, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferParameteri(context, angle::EntryPoint::GLFramebufferParameteri, + target, pname, param)); + if (isCallValid) + { + context->framebufferParameteri(target, pname, param); + } + ANGLE_CAPTURE_GL(FramebufferParameteri, isCallValid, context, target, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenProgramPipelines(GLsizei n, GLuint *pipelines) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenProgramPipelines, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)pipelines); + + if (context) + { + ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenProgramPipelines(context, angle::EntryPoint::GLGenProgramPipelines, n, + pipelinesPacked)); + if (isCallValid) + { + context->genProgramPipelines(n, pipelinesPacked); + } + ANGLE_CAPTURE_GL(GenProgramPipelines, isCallValid, context, n, pipelinesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBooleani_v(GLenum target, GLuint index, GLboolean *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBooleani_v, + "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), index, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetBooleani_v(context, angle::EntryPoint::GLGetBooleani_v, + target, index, data)); + if (isCallValid) + { + context->getBooleani_v(target, index, data); + } + ANGLE_CAPTURE_GL(GetBooleani_v, isCallValid, context, target, index, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFramebufferParameteriv, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetFramebufferParameteriv( + context, angle::EntryPoint::GLGetFramebufferParameteriv, target, pname, params)); + if (isCallValid) + { + context->getFramebufferParameteriv(target, pname, params); + } + ANGLE_CAPTURE_GL(GetFramebufferParameteriv, isCallValid, context, target, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMultisamplefv, + "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetMultisamplefv(context, angle::EntryPoint::GLGetMultisamplefv, + pname, index, val)); + if (isCallValid) + { + context->getMultisamplefv(pname, index, val); + } + ANGLE_CAPTURE_GL(GetMultisamplefv, isCallValid, context, pname, index, val); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramInterfaceiv(GLuint program, + GLenum programInterface, + GLenum pname, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramInterfaceiv, + "context = %d, program = %u, programInterface = %s, pname = %s, params = 0x%016" PRIxPTR + "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + GLenumToString(GLESEnum::ProgramInterfacePName, pname), (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramInterfaceiv(context, angle::EntryPoint::GLGetProgramInterfaceiv, + programPacked, programInterface, pname, params)); + if (isCallValid) + { + context->getProgramInterfaceiv(programPacked, programInterface, pname, params); + } + ANGLE_CAPTURE_GL(GetProgramInterfaceiv, isCallValid, context, programPacked, + programInterface, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramPipelineInfoLog(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramPipelineInfoLog, + "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", infoLog = 0x%016" PRIxPTR "", + CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramPipelineInfoLog( + context, angle::EntryPoint::GLGetProgramPipelineInfoLog, + pipelinePacked, bufSize, length, infoLog)); + if (isCallValid) + { + context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog); + } + ANGLE_CAPTURE_GL(GetProgramPipelineInfoLog, isCallValid, context, pipelinePacked, bufSize, + length, infoLog); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramPipelineiv, + "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramPipelineiv(context, angle::EntryPoint::GLGetProgramPipelineiv, + pipelinePacked, pname, params)); + if (isCallValid) + { + context->getProgramPipelineiv(pipelinePacked, pname, params); + } + ANGLE_CAPTURE_GL(GetProgramPipelineiv, isCallValid, context, pipelinePacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_GetProgramResourceIndex(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramResourceIndex, + "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + (uintptr_t)name); + + GLuint returnValue; + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramResourceIndex(context, angle::EntryPoint::GLGetProgramResourceIndex, + programPacked, programInterface, name)); + if (isCallValid) + { + returnValue = context->getProgramResourceIndex(programPacked, programInterface, name); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>(); + } + ANGLE_CAPTURE_GL(GetProgramResourceIndex, isCallValid, context, programPacked, + programInterface, name, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceIndex, GLuint>(); + } + return returnValue; +} + +GLint GL_APIENTRY GL_GetProgramResourceLocation(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramResourceLocation, + "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + (uintptr_t)name); + + GLint returnValue; + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramResourceLocation( + context, angle::EntryPoint::GLGetProgramResourceLocation, + programPacked, programInterface, name)); + if (isCallValid) + { + returnValue = + context->getProgramResourceLocation(programPacked, programInterface, name); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>(); + } + ANGLE_CAPTURE_GL(GetProgramResourceLocation, isCallValid, context, programPacked, + programInterface, name, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocation, GLint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_GetProgramResourceName(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramResourceName, + "context = %d, program = %u, programInterface = %s, index = %u, bufSize = %d, length = " + "0x%016" PRIxPTR ", name = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + index, bufSize, (uintptr_t)length, (uintptr_t)name); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramResourceName( + context, angle::EntryPoint::GLGetProgramResourceName, programPacked, + programInterface, index, bufSize, length, name)); + if (isCallValid) + { + context->getProgramResourceName(programPacked, programInterface, index, bufSize, length, + name); + } + ANGLE_CAPTURE_GL(GetProgramResourceName, isCallValid, context, programPacked, + programInterface, index, bufSize, length, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramResourceiv(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramResourceiv, + "context = %d, program = %u, programInterface = %s, index = %u, propCount = %d, props = " + "0x%016" PRIxPTR ", count = %d, length = 0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + index, propCount, (uintptr_t)props, count, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramResourceiv( + context, angle::EntryPoint::GLGetProgramResourceiv, programPacked, + programInterface, index, propCount, props, count, length, params)); + if (isCallValid) + { + context->getProgramResourceiv(programPacked, programInterface, index, propCount, props, + count, length, params); + } + ANGLE_CAPTURE_GL(GetProgramResourceiv, isCallValid, context, programPacked, + programInterface, index, propCount, props, count, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target, + GLint level, + GLenum pname, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameterfv, + "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetTexLevelParameterfv(context, angle::EntryPoint::GLGetTexLevelParameterfv, + targetPacked, level, pname, params)); + if (isCallValid) + { + context->getTexLevelParameterfv(targetPacked, level, pname, params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameterfv, isCallValid, context, targetPacked, level, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameteriv, + "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetTexLevelParameteriv(context, angle::EntryPoint::GLGetTexLevelParameteriv, + targetPacked, level, pname, params)); + if (isCallValid) + { + context->getTexLevelParameteriv(targetPacked, level, pname, params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameteriv, isCallValid, context, targetPacked, level, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsProgramPipeline(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsProgramPipeline, "context = %d, pipeline = %u", CID(context), pipeline); + + GLboolean returnValue; + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateIsProgramPipeline( + context, angle::EntryPoint::GLIsProgramPipeline, pipelinePacked)); + if (isCallValid) + { + returnValue = context->isProgramPipeline(pipelinePacked); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsProgramPipeline, isCallValid, context, pipelinePacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipeline, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMemoryBarrier, "context = %d, barriers = %s", CID(context), + GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMemoryBarrier(context, angle::EntryPoint::GLMemoryBarrier, barriers)); + if (isCallValid) + { + context->memoryBarrier(barriers); + } + ANGLE_CAPTURE_GL(MemoryBarrier, isCallValid, context, barriers); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMemoryBarrierByRegion, "context = %d, barriers = %s", CID(context), + GLbitfieldToString(GLESEnum::MemoryBarrierMask, barriers).c_str()); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMemoryBarrierByRegion( + context, angle::EntryPoint::GLMemoryBarrierByRegion, barriers)); + if (isCallValid) + { + context->memoryBarrierByRegion(barriers); + } + ANGLE_CAPTURE_GL(MemoryBarrierByRegion, isCallValid, context, barriers); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1f(GLuint program, GLint location, GLfloat v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1f, "context = %d, program = %u, location = %d, v0 = %f", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform1f(context, angle::EntryPoint::GLProgramUniform1f, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1f(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1f, isCallValid, context, programPacked, locationPacked, v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1fv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1fv(context, angle::EntryPoint::GLProgramUniform1fv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1fv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1i(GLuint program, GLint location, GLint v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1i, "context = %d, program = %u, location = %d, v0 = %d", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform1i(context, angle::EntryPoint::GLProgramUniform1i, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1i(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1i, isCallValid, context, programPacked, locationPacked, v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1iv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1iv(context, angle::EntryPoint::GLProgramUniform1iv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1iv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1ui(GLuint program, GLint location, GLuint v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1ui, "context = %d, program = %u, location = %d, v0 = %u", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1ui(context, angle::EntryPoint::GLProgramUniform1ui, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1ui(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1ui, isCallValid, context, programPacked, locationPacked, + v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1uiv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1uiv(context, angle::EntryPoint::GLProgramUniform1uiv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1uiv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2f, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform2f(context, angle::EntryPoint::GLProgramUniform2f, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2f(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2f, isCallValid, context, programPacked, locationPacked, v0, + v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2fv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2fv(context, angle::EntryPoint::GLProgramUniform2fv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2fv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2i, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform2i(context, angle::EntryPoint::GLProgramUniform2i, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2i(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2i, isCallValid, context, programPacked, locationPacked, v0, + v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2iv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2iv(context, angle::EntryPoint::GLProgramUniform2iv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2iv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2ui, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2ui(context, angle::EntryPoint::GLProgramUniform2ui, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2ui(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2ui, isCallValid, context, programPacked, locationPacked, v0, + v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2uiv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2uiv(context, angle::EntryPoint::GLProgramUniform2uiv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2uiv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3f, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform3f(context, angle::EntryPoint::GLProgramUniform3f, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3f(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3f, isCallValid, context, programPacked, locationPacked, v0, + v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3fv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3fv(context, angle::EntryPoint::GLProgramUniform3fv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3fv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3i, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniform3i(context, angle::EntryPoint::GLProgramUniform3i, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3i(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3i, isCallValid, context, programPacked, locationPacked, v0, + v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3iv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3iv(context, angle::EntryPoint::GLProgramUniform3iv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3iv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3ui, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3ui(context, angle::EntryPoint::GLProgramUniform3ui, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3ui(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3ui, isCallValid, context, programPacked, locationPacked, v0, + v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3uiv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3uiv(context, angle::EntryPoint::GLProgramUniform3uiv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3uiv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4f, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4f(context, angle::EntryPoint::GLProgramUniform4f, programPacked, + locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4f, isCallValid, context, programPacked, locationPacked, v0, + v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4fv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4fv(context, angle::EntryPoint::GLProgramUniform4fv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4fv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4i, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4i(context, angle::EntryPoint::GLProgramUniform4i, programPacked, + locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4i, isCallValid, context, programPacked, locationPacked, v0, + v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4iv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4iv(context, angle::EntryPoint::GLProgramUniform4iv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4iv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4ui, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4ui(context, angle::EntryPoint::GLProgramUniform4ui, + programPacked, locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4ui, isCallValid, context, programPacked, locationPacked, v0, + v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4uiv, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4uiv(context, angle::EntryPoint::GLProgramUniform4uiv, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4uiv, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2fv( + context, angle::EntryPoint::GLProgramUniformMatrix2fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2x3fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2x3fv( + context, angle::EntryPoint::GLProgramUniformMatrix2x3fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2x3fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2x4fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2x4fv( + context, angle::EntryPoint::GLProgramUniformMatrix2x4fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2x4fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3fv( + context, angle::EntryPoint::GLProgramUniformMatrix3fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3x2fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3x2fv( + context, angle::EntryPoint::GLProgramUniformMatrix3x2fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3x2fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3x4fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3x4fv( + context, angle::EntryPoint::GLProgramUniformMatrix3x4fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3x4fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4fv( + context, angle::EntryPoint::GLProgramUniformMatrix4fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4x2fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4x2fv( + context, angle::EntryPoint::GLProgramUniformMatrix4x2fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4x2fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4x3fv, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4x3fv( + context, angle::EntryPoint::GLProgramUniformMatrix4x3fv, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4x3fv, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSampleMaski, "context = %d, maskNumber = %u, mask = %s", CID(context), + maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str()); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSampleMaski(context, angle::EntryPoint::GLSampleMaski, maskNumber, mask)); + if (isCallValid) + { + context->sampleMaski(maskNumber, mask); + } + ANGLE_CAPTURE_GL(SampleMaski, isCallValid, context, maskNumber, mask); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage2DMultisample, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " + "fixedsamplelocations = %s", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, + GLbooleanToString(fixedsamplelocations)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexStorage2DMultisample( + context, angle::EntryPoint::GLTexStorage2DMultisample, targetPacked, + samples, internalformat, width, height, fixedsamplelocations)); + if (isCallValid) + { + context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height, + fixedsamplelocations); + } + ANGLE_CAPTURE_GL(TexStorage2DMultisample, isCallValid, context, targetPacked, samples, + internalformat, width, height, fixedsamplelocations); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUseProgramStages, "context = %d, pipeline = %u, stages = %s, program = %u", + CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(), + program); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateUseProgramStages(context, angle::EntryPoint::GLUseProgramStages, + pipelinePacked, stages, programPacked)); + if (isCallValid) + { + context->useProgramStages(pipelinePacked, stages, programPacked); + } + ANGLE_CAPTURE_GL(UseProgramStages, isCallValid, context, pipelinePacked, stages, + programPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ValidateProgramPipeline(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLValidateProgramPipeline, "context = %d, pipeline = %u", CID(context), + pipeline); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateValidateProgramPipeline(context, angle::EntryPoint::GLValidateProgramPipeline, + pipelinePacked)); + if (isCallValid) + { + context->validateProgramPipeline(pipelinePacked); + } + ANGLE_CAPTURE_GL(ValidateProgramPipeline, isCallValid, context, pipelinePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribBinding(GLuint attribindex, GLuint bindingindex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribBinding, "context = %d, attribindex = %u, bindingindex = %u", + CID(context), attribindex, bindingindex); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribBinding(context, angle::EntryPoint::GLVertexAttribBinding, + attribindex, bindingindex)); + if (isCallValid) + { + context->vertexAttribBinding(attribindex, bindingindex); + } + ANGLE_CAPTURE_GL(VertexAttribBinding, isCallValid, context, attribindex, bindingindex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribFormat(GLuint attribindex, + GLint size, + GLenum type, + GLboolean normalized, + GLuint relativeoffset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribFormat, + "context = %d, attribindex = %u, size = %d, type = %s, normalized = %s, relativeoffset = " + "%u", + CID(context), attribindex, size, GLenumToString(GLESEnum::VertexAttribType, type), + GLbooleanToString(normalized), relativeoffset); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribFormat(context, angle::EntryPoint::GLVertexAttribFormat, + attribindex, size, typePacked, normalized, relativeoffset)); + if (isCallValid) + { + context->vertexAttribFormat(attribindex, size, typePacked, normalized, relativeoffset); + } + ANGLE_CAPTURE_GL(VertexAttribFormat, isCallValid, context, attribindex, size, typePacked, + normalized, relativeoffset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribIFormat(GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribIFormat, + "context = %d, attribindex = %u, size = %d, type = %s, relativeoffset = %u", CID(context), + attribindex, size, GLenumToString(GLESEnum::VertexAttribIType, type), relativeoffset); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribIFormat(context, angle::EntryPoint::GLVertexAttribIFormat, + attribindex, size, typePacked, relativeoffset)); + if (isCallValid) + { + context->vertexAttribIFormat(attribindex, size, typePacked, relativeoffset); + } + ANGLE_CAPTURE_GL(VertexAttribIFormat, isCallValid, context, attribindex, size, typePacked, + relativeoffset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexBindingDivisor(GLuint bindingindex, GLuint divisor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexBindingDivisor, "context = %d, bindingindex = %u, divisor = %u", + CID(context), bindingindex, divisor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexBindingDivisor(context, angle::EntryPoint::GLVertexBindingDivisor, + bindingindex, divisor)); + if (isCallValid) + { + context->vertexBindingDivisor(bindingindex, divisor); + } + ANGLE_CAPTURE_GL(VertexBindingDivisor, isCallValid, context, bindingindex, divisor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h new file mode 100644 index 0000000000..8af020ef14 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_1_autogen.h @@ -0,0 +1,235 @@ +// 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_1_autogen.h: +// Defines the GLES 3.1 entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_ + +#include <GLES3/gl31.h> +#include <export.h> +#include "common/platform.h" + +extern "C" { +ANGLE_EXPORT void GL_APIENTRY GL_ActiveShaderProgram(GLuint pipeline, GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_BindImageTexture(GLuint unit, + GLuint texture, + GLint level, + GLboolean layered, + GLint layer, + GLenum access, + GLenum format); +ANGLE_EXPORT void GL_APIENTRY GL_BindProgramPipeline(GLuint pipeline); +ANGLE_EXPORT void GL_APIENTRY GL_BindVertexBuffer(GLuint bindingindex, + GLuint buffer, + GLintptr offset, + GLsizei stride); +ANGLE_EXPORT GLuint GL_APIENTRY GL_CreateShaderProgramv(GLenum type, + GLsizei count, + const GLchar *const *strings); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteProgramPipelines(GLsizei n, const GLuint *pipelines); +ANGLE_EXPORT void GL_APIENTRY GL_DispatchCompute(GLuint num_groups_x, + GLuint num_groups_y, + GLuint num_groups_z); +ANGLE_EXPORT void GL_APIENTRY GL_DispatchComputeIndirect(GLintptr indirect); +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysIndirect(GLenum mode, const void *indirect); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsIndirect(GLenum mode, + GLenum type, + const void *indirect); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferParameteri(GLenum target, GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_GenProgramPipelines(GLsizei n, GLuint *pipelines); +ANGLE_EXPORT void GL_APIENTRY GL_GetBooleani_v(GLenum target, GLuint index, GLboolean *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferParameteriv(GLenum target, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetMultisamplefv(GLenum pname, GLuint index, GLfloat *val); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramInterfaceiv(GLuint program, + GLenum programInterface, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramPipelineInfoLog(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params); +ANGLE_EXPORT GLuint GL_APIENTRY GL_GetProgramResourceIndex(GLuint program, + GLenum programInterface, + const GLchar *name); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetProgramResourceLocation(GLuint program, + GLenum programInterface, + const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramResourceName(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramResourceiv(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterfv(GLenum target, + GLint level, + GLenum pname, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameteriv(GLenum target, + GLint level, + GLenum pname, + GLint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsProgramPipeline(GLuint pipeline); +ANGLE_EXPORT void GL_APIENTRY GL_MemoryBarrier(GLbitfield barriers); +ANGLE_EXPORT void GL_APIENTRY GL_MemoryBarrierByRegion(GLbitfield barriers); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1f(GLuint program, GLint location, GLfloat v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1i(GLuint program, GLint location, GLint v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1ui(GLuint program, GLint location, GLuint v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2f(GLuint program, + GLint location, + GLfloat v0, + GLfloat v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2i(GLuint program, + GLint location, + GLint v0, + GLint v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2ui(GLuint program, + GLint location, + GLuint v0, + GLuint v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_SampleMaski(GLuint maskNumber, GLbitfield mask); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage2DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +ANGLE_EXPORT void GL_APIENTRY GL_UseProgramStages(GLuint pipeline, + GLbitfield stages, + GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_ValidateProgramPipeline(GLuint pipeline); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribBinding(GLuint attribindex, GLuint bindingindex); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribFormat(GLuint attribindex, + GLint size, + GLenum type, + GLboolean normalized, + GLuint relativeoffset); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribIFormat(GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset); +ANGLE_EXPORT void GL_APIENTRY GL_VertexBindingDivisor(GLuint bindingindex, GLuint divisor); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_3_1_AUTOGEN_H_ 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" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.h new file mode 100644 index 0000000000..02fd24d436 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_3_2_autogen.h @@ -0,0 +1,172 @@ +// 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.h: +// Defines the GLES 3.2 entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_3_2_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_3_2_AUTOGEN_H_ + +#include <GLES3/gl32.h> +#include <export.h> + +extern "C" { +ANGLE_EXPORT void GL_APIENTRY GL_BlendBarrier(); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationSeparatei(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationi(GLuint buf, GLenum mode); +ANGLE_EXPORT void GL_APIENTRY +GL_BlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFunci(GLuint buf, GLenum src, GLenum dst); +ANGLE_EXPORT void GL_APIENTRY +GL_ColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +ANGLE_EXPORT 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); +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageCallback(GLDEBUGPROC callback, const void *userParam); +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageControl(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled); +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageInsert(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf); +ANGLE_EXPORT void GL_APIENTRY GL_Disablei(GLenum target, GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawRangeElementsBaseVertex(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_Enablei(GLenum target, GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexture(GLenum target, + GLenum attachment, + GLuint texture, + GLint level); +ANGLE_EXPORT GLuint GL_APIENTRY GL_GetDebugMessageLog(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog); +ANGLE_EXPORT GLenum GL_APIENTRY GL_GetGraphicsResetStatus(); +ANGLE_EXPORT void GL_APIENTRY +GL_GetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_GetObjectPtrLabel(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_GetPointerv(GLenum pname, void **params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIiv(GLuint sampler, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIuiv(GLuint sampler, + GLenum pname, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIiv(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformfv(GLuint program, + GLint location, + GLsizei bufSize, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformiv(GLuint program, + GLint location, + GLsizei bufSize, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformuiv(GLuint program, + GLint location, + GLsizei bufSize, + GLuint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsEnabledi(GLenum target, GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_MinSampleShading(GLfloat value); +ANGLE_EXPORT void GL_APIENTRY GL_ObjectLabel(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_ObjectPtrLabel(const void *ptr, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_PatchParameteri(GLenum pname, GLint value); +ANGLE_EXPORT void GL_APIENTRY GL_PopDebugGroup(); +ANGLE_EXPORT void GL_APIENTRY GL_PrimitiveBoundingBox(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); +ANGLE_EXPORT void GL_APIENTRY GL_PushDebugGroup(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message); +ANGLE_EXPORT void GL_APIENTRY GL_ReadnPixels(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIiv(GLuint sampler, + GLenum pname, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIuiv(GLuint sampler, + GLenum pname, + const GLuint *param); +ANGLE_EXPORT void GL_APIENTRY GL_TexBuffer(GLenum target, GLenum internalformat, GLuint buffer); +ANGLE_EXPORT void GL_APIENTRY GL_TexBufferRange(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIiv(GLenum target, GLenum pname, const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIuiv(GLenum target, + GLenum pname, + const GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage3DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_3_2_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp new file mode 100644 index 0000000000..ae88df708c --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.cpp @@ -0,0 +1,11984 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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_ext_autogen.cpp: +// Defines the GLES extension entry points. + +#include "libGLESv2/entry_points_gles_ext_autogen.h" + +#include "common/entry_points_enum_autogen.h" +#include "libANGLE/Context.h" +#include "libANGLE/Context.inl.h" +#include "libANGLE/capture/capture_gles_ext_autogen.h" +#include "libANGLE/capture/gl_enum_utils.h" +#include "libANGLE/entry_points_utils.h" +#include "libANGLE/validationESEXT.h" +#include "libGLESv2/global_state.h" + +using namespace gl; + +#include "libANGLE/capture/capture_gles_1_0_autogen.h" +#include "libANGLE/capture/capture_gles_2_0_autogen.h" +#include "libANGLE/capture/capture_gles_3_0_autogen.h" +#include "libANGLE/capture/capture_gles_3_1_autogen.h" +#include "libANGLE/capture/capture_gles_3_2_autogen.h" +#include "libANGLE/validationES1.h" +#include "libANGLE/validationES2.h" +#include "libANGLE/validationES3.h" +#include "libANGLE/validationES31.h" +#include "libANGLE/validationES32.h" + +using namespace gl; + +extern "C" { + +// GL_AMD_performance_monitor +void GL_APIENTRY GL_BeginPerfMonitorAMD(GLuint monitor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBeginPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBeginPerfMonitorAMD( + context, angle::EntryPoint::GLBeginPerfMonitorAMD, monitor)); + if (isCallValid) + { + context->beginPerfMonitor(monitor); + } + ANGLE_CAPTURE_GL(BeginPerfMonitorAMD, isCallValid, context, monitor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeletePerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)monitors); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDeletePerfMonitorsAMD( + context, angle::EntryPoint::GLDeletePerfMonitorsAMD, n, monitors)); + if (isCallValid) + { + context->deletePerfMonitors(n, monitors); + } + ANGLE_CAPTURE_GL(DeletePerfMonitorsAMD, isCallValid, context, n, monitors); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EndPerfMonitorAMD(GLuint monitor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEndPerfMonitorAMD, "context = %d, monitor = %u", CID(context), monitor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEndPerfMonitorAMD(context, angle::EntryPoint::GLEndPerfMonitorAMD, monitor)); + if (isCallValid) + { + context->endPerfMonitor(monitor); + } + ANGLE_CAPTURE_GL(EndPerfMonitorAMD, isCallValid, context, monitor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenPerfMonitorsAMD, "context = %d, n = %d, monitors = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)monitors); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGenPerfMonitorsAMD( + context, angle::EntryPoint::GLGenPerfMonitorsAMD, n, monitors)); + if (isCallValid) + { + context->genPerfMonitors(n, monitors); + } + ANGLE_CAPTURE_GL(GenPerfMonitorsAMD, isCallValid, context, n, monitors); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorCounterDataAMD(GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorCounterDataAMD, + "context = %d, monitor = %u, pname = %s, dataSize = %d, data = 0x%016" PRIxPTR + ", bytesWritten = 0x%016" PRIxPTR "", + CID(context), monitor, GLenumToString(GLESEnum::AllEnums, pname), dataSize, + (uintptr_t)data, (uintptr_t)bytesWritten); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPerfMonitorCounterDataAMD( + context, angle::EntryPoint::GLGetPerfMonitorCounterDataAMD, monitor, + pname, dataSize, data, bytesWritten)); + if (isCallValid) + { + context->getPerfMonitorCounterData(monitor, pname, dataSize, data, bytesWritten); + } + ANGLE_CAPTURE_GL(GetPerfMonitorCounterDataAMD, isCallValid, context, monitor, pname, + dataSize, data, bytesWritten); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorCounterInfoAMD(GLuint group, + GLuint counter, + GLenum pname, + void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorCounterInfoAMD, + "context = %d, group = %u, counter = %u, pname = %s, data = 0x%016" PRIxPTR "", + CID(context), group, counter, GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPerfMonitorCounterInfoAMD( + context, angle::EntryPoint::GLGetPerfMonitorCounterInfoAMD, group, + counter, pname, data)); + if (isCallValid) + { + context->getPerfMonitorCounterInfo(group, counter, pname, data); + } + ANGLE_CAPTURE_GL(GetPerfMonitorCounterInfoAMD, isCallValid, context, group, counter, pname, + data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorCounterStringAMD(GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorCounterStringAMD, + "context = %d, group = %u, counter = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", counterString = 0x%016" PRIxPTR "", + CID(context), group, counter, bufSize, (uintptr_t)length, (uintptr_t)counterString); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPerfMonitorCounterStringAMD( + context, angle::EntryPoint::GLGetPerfMonitorCounterStringAMD, group, + counter, bufSize, length, counterString)); + if (isCallValid) + { + context->getPerfMonitorCounterString(group, counter, bufSize, length, counterString); + } + ANGLE_CAPTURE_GL(GetPerfMonitorCounterStringAMD, isCallValid, context, group, counter, + bufSize, length, counterString); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorCountersAMD(GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorCountersAMD, + "context = %d, group = %u, numCounters = 0x%016" PRIxPTR + ", maxActiveCounters = 0x%016" PRIxPTR ", counterSize = %d, counters = 0x%016" PRIxPTR "", + CID(context), group, (uintptr_t)numCounters, (uintptr_t)maxActiveCounters, counterSize, + (uintptr_t)counters); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPerfMonitorCountersAMD( + context, angle::EntryPoint::GLGetPerfMonitorCountersAMD, group, + numCounters, maxActiveCounters, counterSize, counters)); + if (isCallValid) + { + context->getPerfMonitorCounters(group, numCounters, maxActiveCounters, counterSize, + counters); + } + ANGLE_CAPTURE_GL(GetPerfMonitorCountersAMD, isCallValid, context, group, numCounters, + maxActiveCounters, counterSize, counters); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorGroupStringAMD(GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorGroupStringAMD, + "context = %d, group = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", groupString = 0x%016" PRIxPTR "", + CID(context), group, bufSize, (uintptr_t)length, (uintptr_t)groupString); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPerfMonitorGroupStringAMD( + context, angle::EntryPoint::GLGetPerfMonitorGroupStringAMD, group, + bufSize, length, groupString)); + if (isCallValid) + { + context->getPerfMonitorGroupString(group, bufSize, length, groupString); + } + ANGLE_CAPTURE_GL(GetPerfMonitorGroupStringAMD, isCallValid, context, group, bufSize, length, + groupString); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPerfMonitorGroupsAMD, + "context = %d, numGroups = 0x%016" PRIxPTR ", groupsSize = %d, groups = 0x%016" PRIxPTR + "", + CID(context), (uintptr_t)numGroups, groupsSize, (uintptr_t)groups); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetPerfMonitorGroupsAMD(context, angle::EntryPoint::GLGetPerfMonitorGroupsAMD, + numGroups, groupsSize, groups)); + if (isCallValid) + { + context->getPerfMonitorGroups(numGroups, groupsSize, groups); + } + ANGLE_CAPTURE_GL(GetPerfMonitorGroupsAMD, isCallValid, context, numGroups, groupsSize, + groups); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SelectPerfMonitorCountersAMD(GLuint monitor, + GLboolean enable, + GLuint group, + GLint numCounters, + GLuint *counterList) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSelectPerfMonitorCountersAMD, + "context = %d, monitor = %u, enable = %s, group = %u, numCounters = %d, counterList = " + "0x%016" PRIxPTR "", + CID(context), monitor, GLbooleanToString(enable), group, numCounters, + (uintptr_t)counterList); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSelectPerfMonitorCountersAMD( + context, angle::EntryPoint::GLSelectPerfMonitorCountersAMD, monitor, + enable, group, numCounters, counterList)); + if (isCallValid) + { + context->selectPerfMonitorCounters(monitor, enable, group, numCounters, counterList); + } + ANGLE_CAPTURE_GL(SelectPerfMonitorCountersAMD, isCallValid, context, monitor, enable, group, + numCounters, counterList); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANDROID_extension_pack_es31a + +// GL_ANGLE_base_vertex_base_instance +void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysInstancedBaseInstanceANGLE, + "context = %d, mode = %s, first = %d, count = %d, instanceCount = %d, baseInstance = %u", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instanceCount, + baseInstance); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawArraysInstancedBaseInstanceANGLE( + context, angle::EntryPoint::GLDrawArraysInstancedBaseInstanceANGLE, + modePacked, first, count, instanceCount, baseInstance)); + if (isCallValid) + { + context->drawArraysInstancedBaseInstanceANGLE(modePacked, first, count, instanceCount, + baseInstance); + } + ANGLE_CAPTURE_GL(DrawArraysInstancedBaseInstanceANGLE, isCallValid, context, modePacked, + first, count, instanceCount, baseInstance); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceANGLE, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", instanceCount = %d, baseVertex = %d, baseInstance = %u", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instanceCount, + baseVertex, baseInstance); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsInstancedBaseVertexBaseInstanceANGLE( + context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceANGLE, + modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance)); + if (isCallValid) + { + context->drawElementsInstancedBaseVertexBaseInstanceANGLE( + modePacked, count, typePacked, indices, instanceCount, baseVertex, baseInstance); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, context, + modePacked, count, typePacked, indices, instanceCount, baseVertex, + baseInstance); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawArraysInstancedBaseInstanceANGLE, + "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR + ", instanceCounts = 0x%016" PRIxPTR ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, + (uintptr_t)counts, (uintptr_t)instanceCounts, (uintptr_t)baseInstances, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMultiDrawArraysInstancedBaseInstanceANGLE( + context, angle::EntryPoint::GLMultiDrawArraysInstancedBaseInstanceANGLE, + modePacked, firsts, counts, instanceCounts, baseInstances, drawcount)); + if (isCallValid) + { + context->multiDrawArraysInstancedBaseInstance(modePacked, firsts, counts, + instanceCounts, baseInstances, drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawArraysInstancedBaseInstanceANGLE, isCallValid, context, + modePacked, firsts, counts, instanceCounts, baseInstances, drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, + "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR + ", instanceCounts = 0x%016" PRIxPTR ", baseVertices = 0x%016" PRIxPTR + ", baseInstances = 0x%016" PRIxPTR ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, + (uintptr_t)instanceCounts, (uintptr_t)baseVertices, (uintptr_t)baseInstances, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE( + context, + angle::EntryPoint::GLMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, + modePacked, counts, typePacked, indices, instanceCounts, baseVertices, + baseInstances, drawcount)); + if (isCallValid) + { + context->multiDrawElementsInstancedBaseVertexBaseInstance( + modePacked, counts, typePacked, indices, instanceCounts, baseVertices, + baseInstances, drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE, isCallValid, + context, modePacked, counts, typePacked, indices, instanceCounts, + baseVertices, baseInstances, drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_copy_texture_3d +void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopyTexture3DANGLE, + "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " + "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = " + "%s, unpackUnmultiplyAlpha = %s", + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType), + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); + + if (context) + { + TextureID sourceIdPacked = PackParam<TextureID>(sourceId); + TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget); + TextureID destIdPacked = PackParam<TextureID>(destId); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCopyTexture3DANGLE(context, angle::EntryPoint::GLCopyTexture3DANGLE, + sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, + destLevel, internalFormat, destType, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + if (isCallValid) + { + context->copyTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, + destLevel, internalFormat, destType, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + ANGLE_CAPTURE_GL(CopyTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, internalFormat, destType, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLint z, + GLint width, + GLint height, + GLint depth, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopySubTexture3DANGLE, + "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " + "= %d, xoffset = %d, yoffset = %d, zoffset = %d, x = %d, y = %d, z = %d, width = %d, " + "height = %d, depth = %d, unpackFlipY = %s, unpackPremultiplyAlpha = %s, " + "unpackUnmultiplyAlpha = %s", + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, depth, + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); + + if (context) + { + TextureID sourceIdPacked = PackParam<TextureID>(sourceId); + TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget); + TextureID destIdPacked = PackParam<TextureID>(destId); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCopySubTexture3DANGLE( + context, angle::EntryPoint::GLCopySubTexture3DANGLE, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, z, + width, height, depth, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + if (isCallValid) + { + context->copySubTexture3D(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, + destLevel, xoffset, yoffset, zoffset, x, y, z, width, height, + depth, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha); + } + ANGLE_CAPTURE_GL(CopySubTexture3DANGLE, isCallValid, context, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, zoffset, x, y, + z, width, height, depth, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_depth_texture + +// GL_ANGLE_framebuffer_blit +void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlitFramebufferANGLE, + "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " + "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", + CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBlitFramebufferANGLE( + context, angle::EntryPoint::GLBlitFramebufferANGLE, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)); + if (isCallValid) + { + context->blitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); + } + ANGLE_CAPTURE_GL(BlitFramebufferANGLE, isCallValid, context, srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, mask, filter); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_framebuffer_multisample +void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRenderbufferStorageMultisampleANGLE, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRenderbufferStorageMultisampleANGLE( + context, angle::EntryPoint::GLRenderbufferStorageMultisampleANGLE, + target, samples, internalformat, width, height)); + if (isCallValid) + { + context->renderbufferStorageMultisample(target, samples, internalformat, width, height); + } + ANGLE_CAPTURE_GL(RenderbufferStorageMultisampleANGLE, isCallValid, context, target, samples, + internalformat, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_get_image +void GL_APIENTRY +GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexImageANGLE, + "context = %d, target = %s, level = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR + "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + 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() || + ValidateGetTexImageANGLE(context, angle::EntryPoint::GLGetTexImageANGLE, + targetPacked, level, format, type, pixels)); + if (isCallValid) + { + context->getTexImage(targetPacked, level, format, type, pixels); + } + ANGLE_CAPTURE_GL(GetTexImageANGLE, isCallValid, context, targetPacked, level, format, type, + pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetCompressedTexImageANGLE(GLenum target, GLint level, void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetCompressedTexImageANGLE, + "context = %d, target = %s, level = %d, pixels = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureTarget, target), level, (uintptr_t)pixels); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetCompressedTexImageANGLE( + context, angle::EntryPoint::GLGetCompressedTexImageANGLE, + targetPacked, level, pixels)); + if (isCallValid) + { + context->getCompressedTexImage(targetPacked, level, pixels); + } + ANGLE_CAPTURE_GL(GetCompressedTexImageANGLE, isCallValid, context, targetPacked, level, + pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target, + GLenum format, + GLenum type, + void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetRenderbufferImageANGLE, + "context = %d, target = %s, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), + GLenumToString(GLESEnum::PixelFormat, format), GLenumToString(GLESEnum::PixelType, type), + (uintptr_t)pixels); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetRenderbufferImageANGLE( + context, angle::EntryPoint::GLGetRenderbufferImageANGLE, target, + format, type, pixels)); + if (isCallValid) + { + context->getRenderbufferImage(target, format, type, pixels); + } + ANGLE_CAPTURE_GL(GetRenderbufferImageANGLE, isCallValid, context, target, format, type, + pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_get_tex_level_parameter +void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target, + GLint level, + GLenum pname, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameterivANGLE, + "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::GetTextureParameter, pname), (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexLevelParameterivANGLE( + context, angle::EntryPoint::GLGetTexLevelParameterivANGLE, + targetPacked, level, pname, params)); + if (isCallValid) + { + context->getTexLevelParameteriv(targetPacked, level, pname, params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameterivANGLE, isCallValid, context, targetPacked, level, + pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target, + GLint level, + GLenum pname, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameterfvANGLE, + "context = %d, target = %s, level = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexLevelParameterfvANGLE( + context, angle::EntryPoint::GLGetTexLevelParameterfvANGLE, + targetPacked, level, pname, params)); + if (isCallValid) + { + context->getTexLevelParameterfv(targetPacked, level, pname, params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameterfvANGLE, isCallValid, context, targetPacked, level, + pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_instanced_arrays +void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei primcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysInstancedANGLE, + "context = %d, mode = %s, first = %d, count = %d, primcount = %d", CID(context), + GLenumToString(GLESEnum::PrimitiveType, mode), first, count, primcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawArraysInstancedANGLE( + context, angle::EntryPoint::GLDrawArraysInstancedANGLE, modePacked, + first, count, primcount)); + if (isCallValid) + { + context->drawArraysInstanced(modePacked, first, count, primcount); + } + ANGLE_CAPTURE_GL(DrawArraysInstancedANGLE, isCallValid, context, modePacked, first, count, + primcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedANGLE, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", primcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, primcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawElementsInstancedANGLE( + context, angle::EntryPoint::GLDrawElementsInstancedANGLE, + modePacked, count, typePacked, indices, primcount)); + if (isCallValid) + { + context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedANGLE, isCallValid, context, modePacked, count, + typePacked, indices, primcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribDivisorANGLE(GLuint index, GLuint divisor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribDivisorANGLE, "context = %d, index = %u, divisor = %u", + CID(context), index, divisor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribDivisorANGLE( + context, angle::EntryPoint::GLVertexAttribDivisorANGLE, index, divisor)); + if (isCallValid) + { + context->vertexAttribDivisor(index, divisor); + } + ANGLE_CAPTURE_GL(VertexAttribDivisorANGLE, isCallValid, context, index, divisor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_logic_op +void GL_APIENTRY GL_LogicOpANGLE(GLenum opcode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLogicOpANGLE, "context = %d, opcode = %s", CID(context), + GLenumToString(GLESEnum::LogicOp, opcode)); + + if (context) + { + LogicalOperation opcodePacked = PackParam<LogicalOperation>(opcode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLogicOpANGLE(context, angle::EntryPoint::GLLogicOpANGLE, opcodePacked)); + if (isCallValid) + { + context->logicOpANGLE(opcodePacked); + } + ANGLE_CAPTURE_GL(LogicOpANGLE, isCallValid, context, opcodePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_memory_object_flags +void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMemFlags2DANGLE, + "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " + "memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, imageCreateInfoPNext = " + "0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, memory, + static_cast<unsigned long long>(offset), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), + (uintptr_t)imageCreateInfoPNext); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexStorageMemFlags2DANGLE( + context, angle::EntryPoint::GLTexStorageMemFlags2DANGLE, + targetPacked, levels, internalFormat, width, height, memoryPacked, + offset, createFlags, usageFlags, imageCreateInfoPNext)); + if (isCallValid) + { + context->texStorageMemFlags2D(targetPacked, levels, internalFormat, width, height, + memoryPacked, offset, createFlags, usageFlags, + imageCreateInfoPNext); + } + ANGLE_CAPTURE_GL(TexStorageMemFlags2DANGLE, isCallValid, context, targetPacked, levels, + internalFormat, width, height, memoryPacked, offset, createFlags, + usageFlags, imageCreateInfoPNext); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMemFlags2DMultisampleANGLE, + "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " + "fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, usageFlags = " + "%s, imageCreateInfoPNext = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, + GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), + (uintptr_t)imageCreateInfoPNext); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMemFlags2DMultisampleANGLE( + context, angle::EntryPoint::GLTexStorageMemFlags2DMultisampleANGLE, targetPacked, + samples, internalFormat, width, height, fixedSampleLocations, memoryPacked, offset, + createFlags, usageFlags, imageCreateInfoPNext)); + if (isCallValid) + { + context->texStorageMemFlags2DMultisample( + targetPacked, samples, internalFormat, width, height, fixedSampleLocations, + memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext); + } + ANGLE_CAPTURE_GL(TexStorageMemFlags2DMultisampleANGLE, isCallValid, context, targetPacked, + samples, internalFormat, width, height, fixedSampleLocations, memoryPacked, + offset, createFlags, usageFlags, imageCreateInfoPNext); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMemFlags3DANGLE, + "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " + "depth = %d, memory = %u, offset = %llu, createFlags = %s, usageFlags = %s, " + "imageCreateInfoPNext = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth, memory, + static_cast<unsigned long long>(offset), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), + (uintptr_t)imageCreateInfoPNext); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMemFlags3DANGLE( + context, angle::EntryPoint::GLTexStorageMemFlags3DANGLE, targetPacked, levels, + internalFormat, width, height, depth, memoryPacked, offset, createFlags, + usageFlags, imageCreateInfoPNext)); + if (isCallValid) + { + context->texStorageMemFlags3D(targetPacked, levels, internalFormat, width, height, + depth, memoryPacked, offset, createFlags, usageFlags, + imageCreateInfoPNext); + } + ANGLE_CAPTURE_GL(TexStorageMemFlags3DANGLE, isCallValid, context, targetPacked, levels, + internalFormat, width, height, depth, memoryPacked, offset, createFlags, + usageFlags, imageCreateInfoPNext); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMemFlags3DMultisampleANGLE, + "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " + "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu, createFlags = %s, " + "usageFlags = %s, imageCreateInfoPNext = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::AllEnums, internalFormat), width, height, depth, + GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset), + GLbitfieldToString(GLESEnum::AllEnums, createFlags).c_str(), + GLbitfieldToString(GLESEnum::AllEnums, usageFlags).c_str(), + (uintptr_t)imageCreateInfoPNext); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMemFlags3DMultisampleANGLE( + context, angle::EntryPoint::GLTexStorageMemFlags3DMultisampleANGLE, targetPacked, + samples, internalFormat, width, height, depth, fixedSampleLocations, memoryPacked, + offset, createFlags, usageFlags, imageCreateInfoPNext)); + if (isCallValid) + { + context->texStorageMemFlags3DMultisample( + targetPacked, samples, internalFormat, width, height, depth, fixedSampleLocations, + memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext); + } + ANGLE_CAPTURE_GL(TexStorageMemFlags3DMultisampleANGLE, isCallValid, context, targetPacked, + samples, internalFormat, width, height, depth, fixedSampleLocations, + memoryPacked, offset, createFlags, usageFlags, imageCreateInfoPNext); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_memory_object_fuchsia +void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory, + GLuint64 size, + GLenum handleType, + GLuint handle) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLImportMemoryZirconHandleANGLE, + "context = %d, memory = %u, size = %llu, handleType = %s, handle = %u", CID(context), + memory, static_cast<unsigned long long>(size), + GLenumToString(GLESEnum::ExternalHandleType, handleType), handle); + + if (context) + { + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + HandleType handleTypePacked = PackParam<HandleType>(handleType); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateImportMemoryZirconHandleANGLE( + context, angle::EntryPoint::GLImportMemoryZirconHandleANGLE, + memoryPacked, size, handleTypePacked, handle)); + if (isCallValid) + { + context->importMemoryZirconHandle(memoryPacked, size, handleTypePacked, handle); + } + ANGLE_CAPTURE_GL(ImportMemoryZirconHandleANGLE, isCallValid, context, memoryPacked, size, + handleTypePacked, handle); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_multi_draw +void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawArraysANGLE, + "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR + ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, + (uintptr_t)counts, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMultiDrawArraysANGLE(context, angle::EntryPoint::GLMultiDrawArraysANGLE, + modePacked, firsts, counts, drawcount)); + if (isCallValid) + { + context->multiDrawArrays(modePacked, firsts, counts, drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawArraysANGLE, isCallValid, context, modePacked, firsts, counts, + drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawArraysInstancedANGLE, + "context = %d, mode = %s, firsts = 0x%016" PRIxPTR ", counts = 0x%016" PRIxPTR + ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)firsts, + (uintptr_t)counts, (uintptr_t)instanceCounts, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiDrawArraysInstancedANGLE( + context, angle::EntryPoint::GLMultiDrawArraysInstancedANGLE, + modePacked, firsts, counts, instanceCounts, drawcount)); + if (isCallValid) + { + context->multiDrawArraysInstanced(modePacked, firsts, counts, instanceCounts, + drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawArraysInstancedANGLE, isCallValid, context, modePacked, firsts, + counts, instanceCounts, drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawElementsANGLE, + "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR + ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMultiDrawElementsANGLE(context, angle::EntryPoint::GLMultiDrawElementsANGLE, + modePacked, counts, typePacked, indices, drawcount)); + if (isCallValid) + { + context->multiDrawElements(modePacked, counts, typePacked, indices, drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawElementsANGLE, isCallValid, context, modePacked, counts, + typePacked, indices, drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawElementsInstancedANGLE, + "context = %d, mode = %s, counts = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR + ", instanceCounts = 0x%016" PRIxPTR ", drawcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)counts, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, + (uintptr_t)instanceCounts, drawcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMultiDrawElementsInstancedANGLE( + context, angle::EntryPoint::GLMultiDrawElementsInstancedANGLE, modePacked, counts, + typePacked, indices, instanceCounts, drawcount)); + if (isCallValid) + { + context->multiDrawElementsInstanced(modePacked, counts, typePacked, indices, + instanceCounts, drawcount); + } + ANGLE_CAPTURE_GL(MultiDrawElementsInstancedANGLE, isCallValid, context, modePacked, counts, + typePacked, indices, instanceCounts, drawcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_pack_reverse_row_order + +// GL_ANGLE_program_binary + +// GL_ANGLE_provoking_vertex +void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProvokingVertexANGLE, "context = %d, mode = %s", CID(context), + GLenumToString(GLESEnum::VertexProvokingMode, mode)); + + if (context) + { + ProvokingVertexConvention modePacked = PackParam<ProvokingVertexConvention>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProvokingVertexANGLE( + context, angle::EntryPoint::GLProvokingVertexANGLE, modePacked)); + if (isCallValid) + { + context->provokingVertex(modePacked); + } + ANGLE_CAPTURE_GL(ProvokingVertexANGLE, isCallValid, context, modePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_request_extension +void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRequestExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)name); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRequestExtensionANGLE( + context, angle::EntryPoint::GLRequestExtensionANGLE, name)); + if (isCallValid) + { + context->requestExtension(name); + } + ANGLE_CAPTURE_GL(RequestExtensionANGLE, isCallValid, context, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDisableExtensionANGLE, "context = %d, name = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)name); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDisableExtensionANGLE( + context, angle::EntryPoint::GLDisableExtensionANGLE, name)); + if (isCallValid) + { + context->disableExtension(name); + } + ANGLE_CAPTURE_GL(DisableExtensionANGLE, isCallValid, context, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_robust_client_memory +void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBooleanvRobustANGLE, + "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetBooleanvRobustANGLE(context, angle::EntryPoint::GLGetBooleanvRobustANGLE, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getBooleanvRobust(pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetBooleanvRobustANGLE, isCallValid, context, pname, bufSize, length, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferParameterivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetBufferParameterivRobustANGLE( + context, angle::EntryPoint::GLGetBufferParameterivRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getBufferParameterivRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetBufferParameterivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFloatvRobustANGLE, + "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetFloatvRobustANGLE(context, angle::EntryPoint::GLGetFloatvRobustANGLE, pname, + bufSize, length, params)); + if (isCallValid) + { + context->getFloatvRobust(pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetFloatvRobustANGLE, isCallValid, context, pname, bufSize, length, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFramebufferAttachmentParameterivRobustANGLE, + "context = %d, target = %s, attachment = %s, pname = %s, bufSize = %d, length = " + "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, attachment), GLenumToString(GLESEnum::AllEnums, pname), + bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetFramebufferAttachmentParameterivRobustANGLE( + context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivRobustANGLE, + target, attachment, pname, bufSize, length, params)); + if (isCallValid) + { + context->getFramebufferAttachmentParameterivRobust(target, attachment, pname, bufSize, + length, params); + } + ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameterivRobustANGLE, isCallValid, context, + target, attachment, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetIntegervRobustANGLE, + "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetIntegervRobustANGLE(context, angle::EntryPoint::GLGetIntegervRobustANGLE, + pname, bufSize, length, data)); + if (isCallValid) + { + context->getIntegervRobust(pname, bufSize, length, data); + } + ANGLE_CAPTURE_GL(GetIntegervRobustANGLE, isCallValid, context, pname, bufSize, length, + data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetProgramivRobustANGLE, + "context = %d, program = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramivRobustANGLE(context, angle::EntryPoint::GLGetProgramivRobustANGLE, + programPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getProgramivRobust(programPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetProgramivRobustANGLE, isCallValid, context, programPacked, pname, + bufSize, length, params); + } + else + {} +} + +void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetRenderbufferParameterivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetRenderbufferParameterivRobustANGLE( + context, angle::EntryPoint::GLGetRenderbufferParameterivRobustANGLE, + target, pname, bufSize, length, params)); + if (isCallValid) + { + context->getRenderbufferParameterivRobust(target, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetRenderbufferParameterivRobustANGLE, isCallValid, context, target, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetShaderivRobustANGLE, + "context = %d, shader = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), shader, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID shaderPacked = PackParam<ShaderProgramID>(shader); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetShaderivRobustANGLE(context, angle::EntryPoint::GLGetShaderivRobustANGLE, + shaderPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getShaderivRobust(shaderPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetShaderivRobustANGLE, isCallValid, context, shaderPacked, pname, bufSize, + length, params); + } + else + {} +} + +void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterfvRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexParameterfvRobustANGLE( + context, angle::EntryPoint::GLGetTexParameterfvRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexParameterfvRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetTexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexParameterivRobustANGLE( + context, angle::EntryPoint::GLGetTexParameterivRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexParameterivRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetTexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformfvRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetUniformfvRobustANGLE( + context, angle::EntryPoint::GLGetUniformfvRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getUniformfvRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetUniformfvRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformivRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetUniformivRobustANGLE( + context, angle::EntryPoint::GLGetUniformivRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getUniformivRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetUniformivRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribfvRobustANGLE, + "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetVertexAttribfvRobustANGLE( + context, angle::EntryPoint::GLGetVertexAttribfvRobustANGLE, index, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getVertexAttribfvRobust(index, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribfvRobustANGLE, isCallValid, context, index, pname, bufSize, + length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribivRobustANGLE, + "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetVertexAttribivRobustANGLE( + context, angle::EntryPoint::GLGetVertexAttribivRobustANGLE, index, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getVertexAttribivRobust(index, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribivRobustANGLE, isCallValid, context, index, pname, bufSize, + length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribPointervRobustANGLE, + "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", pointer = 0x%016" PRIxPTR "", + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)pointer); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetVertexAttribPointervRobustANGLE( + context, angle::EntryPoint::GLGetVertexAttribPointervRobustANGLE, + index, pname, bufSize, length, pointer)); + if (isCallValid) + { + context->getVertexAttribPointervRobust(index, pname, bufSize, length, pointer); + } + ANGLE_CAPTURE_GL(GetVertexAttribPointervRobustANGLE, isCallValid, context, index, pname, + bufSize, length, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReadPixelsRobustANGLE, + "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " + "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR + ", pixels = 0x%016" PRIxPTR "", + CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns, + (uintptr_t)rows, (uintptr_t)pixels); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateReadPixelsRobustANGLE( + context, angle::EntryPoint::GLReadPixelsRobustANGLE, x, y, width, + height, format, type, bufSize, length, columns, rows, pixels)); + if (isCallValid) + { + context->readPixelsRobust(x, y, width, height, format, type, bufSize, length, columns, + rows, pixels); + } + ANGLE_CAPTURE_GL(ReadPixelsRobustANGLE, isCallValid, context, x, y, width, height, format, + type, bufSize, length, columns, rows, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexImage2DRobustANGLE, + "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " + "border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width, + height, border, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexImage2DRobustANGLE(context, angle::EntryPoint::GLTexImage2DRobustANGLE, + targetPacked, level, internalformat, width, height, + border, format, type, bufSize, pixels)); + if (isCallValid) + { + context->texImage2DRobust(targetPacked, level, internalformat, width, height, border, + format, type, bufSize, pixels); + } + ANGLE_CAPTURE_GL(TexImage2DRobustANGLE, isCallValid, context, targetPacked, level, + internalformat, width, height, border, format, type, bufSize, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterfvRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexParameterfvRobustANGLE( + context, angle::EntryPoint::GLTexParameterfvRobustANGLE, + targetPacked, pname, bufSize, params)); + if (isCallValid) + { + context->texParameterfvRobust(targetPacked, pname, bufSize, params); + } + ANGLE_CAPTURE_GL(TexParameterfvRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexParameterivRobustANGLE( + context, angle::EntryPoint::GLTexParameterivRobustANGLE, + targetPacked, pname, bufSize, params)); + if (isCallValid) + { + context->texParameterivRobust(targetPacked, pname, bufSize, params); + } + ANGLE_CAPTURE_GL(TexParameterivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexSubImage2DRobustANGLE, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " + "%d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width, + height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexSubImage2DRobustANGLE( + context, angle::EntryPoint::GLTexSubImage2DRobustANGLE, targetPacked, level, + xoffset, yoffset, width, height, format, type, bufSize, pixels)); + if (isCallValid) + { + context->texSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, height, + format, type, bufSize, pixels); + } + ANGLE_CAPTURE_GL(TexSubImage2DRobustANGLE, isCallValid, context, targetPacked, level, + xoffset, yoffset, width, height, format, type, bufSize, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexImage3DRobustANGLE, + "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " + "depth = %d, border = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR + "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, internalformat, width, + height, depth, border, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexImage3DRobustANGLE(context, angle::EntryPoint::GLTexImage3DRobustANGLE, + targetPacked, level, internalformat, width, height, + depth, border, format, type, bufSize, pixels)); + if (isCallValid) + { + context->texImage3DRobust(targetPacked, level, internalformat, width, height, depth, + border, format, type, bufSize, pixels); + } + ANGLE_CAPTURE_GL(TexImage3DRobustANGLE, isCallValid, context, targetPacked, level, + internalformat, width, height, depth, border, format, type, bufSize, + pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT( + context, GLTexSubImage3DRobustANGLE, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width = " + "%d, height = %d, depth = %d, format = %s, type = %s, bufSize = %d, pixels = 0x%016" PRIxPTR + "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, zoffset, + width, height, depth, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)pixels); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexSubImage3DRobustANGLE( + context, angle::EntryPoint::GLTexSubImage3DRobustANGLE, targetPacked, level, + xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels)); + if (isCallValid) + { + context->texSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, width, + height, depth, format, type, bufSize, pixels); + } + ANGLE_CAPTURE_GL(TexSubImage3DRobustANGLE, isCallValid, context, targetPacked, level, + xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, + pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexImage2DRobustANGLE, + "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " + "border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, border, imageSize, + dataSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexImage2DRobustANGLE( + context, angle::EntryPoint::GLCompressedTexImage2DRobustANGLE, targetPacked, level, + internalformat, width, height, border, imageSize, dataSize, data)); + if (isCallValid) + { + context->compressedTexImage2DRobust(targetPacked, level, internalformat, width, height, + border, imageSize, dataSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexImage2DRobustANGLE, isCallValid, context, targetPacked, level, + internalformat, width, height, border, imageSize, dataSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLsizei xoffset, + GLsizei yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexSubImage2DRobustANGLE, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, width = %d, height = " + "%d, format = %s, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, width, + height, GLenumToString(GLESEnum::AllEnums, format), imageSize, dataSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexSubImage2DRobustANGLE( + context, angle::EntryPoint::GLCompressedTexSubImage2DRobustANGLE, targetPacked, + level, xoffset, yoffset, width, height, format, imageSize, dataSize, data)); + if (isCallValid) + { + context->compressedTexSubImage2DRobust(targetPacked, level, xoffset, yoffset, width, + height, format, imageSize, dataSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexSubImage2DRobustANGLE, isCallValid, context, targetPacked, + level, xoffset, yoffset, width, height, format, imageSize, dataSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexImage3DRobustANGLE, + "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d, border = %d, imageSize = %d, dataSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, depth, border, + imageSize, dataSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexImage3DRobustANGLE( + context, angle::EntryPoint::GLCompressedTexImage3DRobustANGLE, targetPacked, level, + internalformat, width, height, depth, border, imageSize, dataSize, data)); + if (isCallValid) + { + context->compressedTexImage3DRobust(targetPacked, level, internalformat, width, height, + depth, border, imageSize, dataSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexImage3DRobustANGLE, isCallValid, context, targetPacked, level, + internalformat, width, height, depth, border, imageSize, dataSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexSubImage3DRobustANGLE, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " + "= %d, height = %d, depth = %d, format = %s, imageSize = %d, dataSize = %d, data = " + "0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::AllEnums, format), imageSize, + dataSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCompressedTexSubImage3DRobustANGLE( + context, angle::EntryPoint::GLCompressedTexSubImage3DRobustANGLE, + targetPacked, level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, dataSize, data)); + if (isCallValid) + { + context->compressedTexSubImage3DRobust(targetPacked, level, xoffset, yoffset, zoffset, + width, height, depth, format, imageSize, + dataSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexSubImage3DRobustANGLE, isCallValid, context, targetPacked, + level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, + dataSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryivRobustANGLE(context, angle::EntryPoint::GLGetQueryivRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getQueryivRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetQueryivRobustANGLE, isCallValid, context, targetPacked, pname, bufSize, + length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryObjectuivRobustANGLE, + "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryObjectuivRobustANGLE( + context, angle::EntryPoint::GLGetQueryObjectuivRobustANGLE, + idPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getQueryObjectuivRobust(idPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectuivRobustANGLE, isCallValid, context, idPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferPointervRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetBufferPointervRobustANGLE( + context, angle::EntryPoint::GLGetBufferPointervRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getBufferPointervRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetBufferPointervRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetIntegeri_vRobustANGLE, + "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, + (uintptr_t)length, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetIntegeri_vRobustANGLE( + context, angle::EntryPoint::GLGetIntegeri_vRobustANGLE, target, + index, bufSize, length, data)); + if (isCallValid) + { + context->getIntegeri_vRobust(target, index, bufSize, length, data); + } + ANGLE_CAPTURE_GL(GetIntegeri_vRobustANGLE, isCallValid, context, target, index, bufSize, + length, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInternalformativRobustANGLE, + "context = %d, target = %s, internalformat = %s, pname = %s, bufSize = %d, length = " + "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, internalformat), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetInternalformativRobustANGLE( + context, angle::EntryPoint::GLGetInternalformativRobustANGLE, + target, internalformat, pname, bufSize, length, params)); + if (isCallValid) + { + context->getInternalformativRobust(target, internalformat, pname, bufSize, length, + params); + } + ANGLE_CAPTURE_GL(GetInternalformativRobustANGLE, isCallValid, context, target, + internalformat, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribIivRobustANGLE, + "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetVertexAttribIivRobustANGLE( + context, angle::EntryPoint::GLGetVertexAttribIivRobustANGLE, index, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getVertexAttribIivRobust(index, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribIivRobustANGLE, isCallValid, context, index, pname, bufSize, + length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetVertexAttribIuivRobustANGLE, + "context = %d, index = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), index, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetVertexAttribIuivRobustANGLE( + context, angle::EntryPoint::GLGetVertexAttribIuivRobustANGLE, index, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getVertexAttribIuivRobust(index, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetVertexAttribIuivRobustANGLE, isCallValid, context, index, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUniformuivRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetUniformuivRobustANGLE( + context, angle::EntryPoint::GLGetUniformuivRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getUniformuivRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetUniformuivRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetActiveUniformBlockivRobustANGLE, + "context = %d, program = %u, uniformBlockIndex = %u, pname = %s, bufSize = %d, length = " + "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), program, uniformBlockIndex, GLenumToString(GLESEnum::AllEnums, pname), + bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformBlockIndex uniformBlockIndexPacked = PackParam<UniformBlockIndex>(uniformBlockIndex); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetActiveUniformBlockivRobustANGLE( + context, angle::EntryPoint::GLGetActiveUniformBlockivRobustANGLE, programPacked, + uniformBlockIndexPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getActiveUniformBlockivRobust(programPacked, uniformBlockIndexPacked, pname, + bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetActiveUniformBlockivRobustANGLE, isCallValid, context, programPacked, + uniformBlockIndexPacked, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInteger64vRobustANGLE, + "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetInteger64vRobustANGLE( + context, angle::EntryPoint::GLGetInteger64vRobustANGLE, pname, + bufSize, length, data)); + if (isCallValid) + { + context->getInteger64vRobust(pname, bufSize, length, data); + } + ANGLE_CAPTURE_GL(GetInteger64vRobustANGLE, isCallValid, context, pname, bufSize, length, + data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInteger64i_vRobustANGLE, + "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, + (uintptr_t)length, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetInteger64i_vRobustANGLE( + context, angle::EntryPoint::GLGetInteger64i_vRobustANGLE, target, + index, bufSize, length, data)); + if (isCallValid) + { + context->getInteger64i_vRobust(target, index, bufSize, length, data); + } + ANGLE_CAPTURE_GL(GetInteger64i_vRobustANGLE, isCallValid, context, target, index, bufSize, + length, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferParameteri64vRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetBufferParameteri64vRobustANGLE( + context, angle::EntryPoint::GLGetBufferParameteri64vRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getBufferParameteri64vRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetBufferParameteri64vRobustANGLE, isCallValid, context, targetPacked, + pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterivRobustANGLE(GLuint sampler, + GLuint pname, + GLsizei bufSize, + const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterivRobustANGLE, + "context = %d, sampler = %u, pname = %u, bufSize = %d, param = 0x%016" PRIxPTR "", + CID(context), sampler, pname, bufSize, (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSamplerParameterivRobustANGLE( + context, angle::EntryPoint::GLSamplerParameterivRobustANGLE, + samplerPacked, pname, bufSize, param)); + if (isCallValid) + { + context->samplerParameterivRobust(samplerPacked, pname, bufSize, param); + } + ANGLE_CAPTURE_GL(SamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, pname, + bufSize, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLfloat *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterfvRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSamplerParameterfvRobustANGLE( + context, angle::EntryPoint::GLSamplerParameterfvRobustANGLE, + samplerPacked, pname, bufSize, param)); + if (isCallValid) + { + context->samplerParameterfvRobust(samplerPacked, pname, bufSize, param); + } + ANGLE_CAPTURE_GL(SamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, pname, + bufSize, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterivRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetSamplerParameterivRobustANGLE( + context, angle::EntryPoint::GLGetSamplerParameterivRobustANGLE, + samplerPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getSamplerParameterivRobust(samplerPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterivRobustANGLE, isCallValid, context, samplerPacked, + pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterfvRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetSamplerParameterfvRobustANGLE( + context, angle::EntryPoint::GLGetSamplerParameterfvRobustANGLE, + samplerPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getSamplerParameterfvRobust(samplerPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterfvRobustANGLE, isCallValid, context, samplerPacked, + pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFramebufferParameterivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetFramebufferParameterivRobustANGLE( + context, angle::EntryPoint::GLGetFramebufferParameterivRobustANGLE, + target, pname, bufSize, length, params)); + if (isCallValid) + { + context->getFramebufferParameterivRobust(target, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetFramebufferParameterivRobustANGLE, isCallValid, context, target, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramInterfaceivRobustANGLE, + "context = %d, program = %u, programInterface = %s, pname = %s, bufSize = %d, length = " + "0x%016" PRIxPTR ", params = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::AllEnums, programInterface), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramInterfaceivRobustANGLE( + context, angle::EntryPoint::GLGetProgramInterfaceivRobustANGLE, + programPacked, programInterface, pname, bufSize, length, params)); + if (isCallValid) + { + context->getProgramInterfaceivRobust(programPacked, programInterface, pname, bufSize, + length, params); + } + ANGLE_CAPTURE_GL(GetProgramInterfaceivRobustANGLE, isCallValid, context, programPacked, + programInterface, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBooleani_vRobustANGLE, + "context = %d, target = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), index, bufSize, + (uintptr_t)length, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetBooleani_vRobustANGLE( + context, angle::EntryPoint::GLGetBooleani_vRobustANGLE, target, + index, bufSize, length, data)); + if (isCallValid) + { + context->getBooleani_vRobust(target, index, bufSize, length, data); + } + ANGLE_CAPTURE_GL(GetBooleani_vRobustANGLE, isCallValid, context, target, index, bufSize, + length, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMultisamplefvRobustANGLE, + "context = %d, pname = %s, index = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", val = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), index, bufSize, + (uintptr_t)length, (uintptr_t)val); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetMultisamplefvRobustANGLE( + context, angle::EntryPoint::GLGetMultisamplefvRobustANGLE, pname, + index, bufSize, length, val)); + if (isCallValid) + { + context->getMultisamplefvRobust(pname, index, bufSize, length, val); + } + ANGLE_CAPTURE_GL(GetMultisamplefvRobustANGLE, isCallValid, context, pname, index, bufSize, + length, val); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameterivRobustANGLE, + "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexLevelParameterivRobustANGLE( + context, angle::EntryPoint::GLGetTexLevelParameterivRobustANGLE, + targetPacked, level, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexLevelParameterivRobust(targetPacked, level, pname, bufSize, length, + params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameterivRobustANGLE, isCallValid, context, targetPacked, + level, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexLevelParameterfvRobustANGLE, + "context = %d, target = %s, level = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexLevelParameterfvRobustANGLE( + context, angle::EntryPoint::GLGetTexLevelParameterfvRobustANGLE, + targetPacked, level, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexLevelParameterfvRobust(targetPacked, level, pname, bufSize, length, + params); + } + ANGLE_CAPTURE_GL(GetTexLevelParameterfvRobustANGLE, isCallValid, context, targetPacked, + level, pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPointervRobustANGLERobustANGLE, + "context = %d, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetPointervRobustANGLERobustANGLE( + context, angle::EntryPoint::GLGetPointervRobustANGLERobustANGLE, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getPointervRobustANGLERobust(pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetPointervRobustANGLERobustANGLE, isCallValid, context, pname, bufSize, + length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReadnPixelsRobustANGLE, + "context = %d, x = %d, y = %d, width = %d, height = %d, format = %s, type = %s, bufSize " + "= %d, length = 0x%016" PRIxPTR ", columns = 0x%016" PRIxPTR ", rows = 0x%016" PRIxPTR + ", data = 0x%016" PRIxPTR "", + CID(context), x, y, width, height, GLenumToString(GLESEnum::AllEnums, format), + GLenumToString(GLESEnum::AllEnums, type), bufSize, (uintptr_t)length, (uintptr_t)columns, + (uintptr_t)rows, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateReadnPixelsRobustANGLE( + context, angle::EntryPoint::GLReadnPixelsRobustANGLE, x, y, width, + height, format, type, bufSize, length, columns, rows, data)); + if (isCallValid) + { + context->readnPixelsRobust(x, y, width, height, format, type, bufSize, length, columns, + rows, data); + } + ANGLE_CAPTURE_GL(ReadnPixelsRobustANGLE, isCallValid, context, x, y, width, height, format, + type, bufSize, length, columns, rows, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformfvRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformfvRobustANGLE( + context, angle::EntryPoint::GLGetnUniformfvRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getnUniformfvRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetnUniformfvRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformivRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformivRobustANGLE( + context, angle::EntryPoint::GLGetnUniformivRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getnUniformivRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetnUniformivRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformuivRobustANGLE, + "context = %d, program = %u, location = %d, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), program, location, bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetnUniformuivRobustANGLE( + context, angle::EntryPoint::GLGetnUniformuivRobustANGLE, + programPacked, locationPacked, bufSize, length, params)); + if (isCallValid) + { + context->getnUniformuivRobust(programPacked, locationPacked, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetnUniformuivRobustANGLE, isCallValid, context, programPacked, + locationPacked, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexParameterIivRobustANGLE( + context, angle::EntryPoint::GLTexParameterIivRobustANGLE, + targetPacked, pname, bufSize, params)); + if (isCallValid) + { + context->texParameterIivRobust(targetPacked, pname, bufSize, params); + } + ANGLE_CAPTURE_GL(TexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIuivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexParameterIuivRobustANGLE( + context, angle::EntryPoint::GLTexParameterIuivRobustANGLE, + targetPacked, pname, bufSize, params)); + if (isCallValid) + { + context->texParameterIuivRobust(targetPacked, pname, bufSize, params); + } + ANGLE_CAPTURE_GL(TexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexParameterIivRobustANGLE( + context, angle::EntryPoint::GLGetTexParameterIivRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexParameterIivRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIuivRobustANGLE, + "context = %d, target = %s, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, (uintptr_t)params); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexParameterIuivRobustANGLE( + context, angle::EntryPoint::GLGetTexParameterIuivRobustANGLE, + targetPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getTexParameterIuivRobust(targetPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIuivRobustANGLE, isCallValid, context, targetPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIivRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSamplerParameterIivRobustANGLE( + context, angle::EntryPoint::GLSamplerParameterIivRobustANGLE, + samplerPacked, pname, bufSize, param)); + if (isCallValid) + { + context->samplerParameterIivRobust(samplerPacked, pname, bufSize, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, pname, + bufSize, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLuint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIuivRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, param = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)param); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSamplerParameterIuivRobustANGLE( + context, angle::EntryPoint::GLSamplerParameterIuivRobustANGLE, + samplerPacked, pname, bufSize, param)); + if (isCallValid) + { + context->samplerParameterIuivRobust(samplerPacked, pname, bufSize, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, + pname, bufSize, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIivRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetSamplerParameterIivRobustANGLE( + context, angle::EntryPoint::GLGetSamplerParameterIivRobustANGLE, + samplerPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getSamplerParameterIivRobust(samplerPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIivRobustANGLE, isCallValid, context, samplerPacked, + pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIuivRobustANGLE, + "context = %d, sampler = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), sampler, GLenumToString(GLESEnum::AllEnums, pname), bufSize, + (uintptr_t)length, (uintptr_t)params); + + if (context) + { + SamplerID samplerPacked = PackParam<SamplerID>(sampler); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetSamplerParameterIuivRobustANGLE( + context, angle::EntryPoint::GLGetSamplerParameterIuivRobustANGLE, + samplerPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getSamplerParameterIuivRobust(samplerPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIuivRobustANGLE, isCallValid, context, samplerPacked, + pname, bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetQueryObjectivRobustANGLE, + "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryObjectivRobustANGLE( + context, angle::EntryPoint::GLGetQueryObjectivRobustANGLE, idPacked, + pname, bufSize, length, params)); + if (isCallValid) + { + context->getQueryObjectivRobust(idPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectivRobustANGLE, isCallValid, context, idPacked, pname, + bufSize, length, params); + } + else + {} +} + +void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetQueryObjecti64vRobustANGLE, + "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryObjecti64vRobustANGLE( + context, angle::EntryPoint::GLGetQueryObjecti64vRobustANGLE, + idPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getQueryObjecti64vRobust(idPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetQueryObjecti64vRobustANGLE, isCallValid, context, idPacked, pname, + bufSize, length, params); + } + else + {} +} + +void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryObjectui64vRobustANGLE, + "context = %d, id = %u, pname = %s, bufSize = %d, length = 0x%016" PRIxPTR + ", params = 0x%016" PRIxPTR "", + CID(context), id, GLenumToString(GLESEnum::AllEnums, pname), bufSize, (uintptr_t)length, + (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryObjectui64vRobustANGLE( + context, angle::EntryPoint::GLGetQueryObjectui64vRobustANGLE, + idPacked, pname, bufSize, length, params)); + if (isCallValid) + { + context->getQueryObjectui64vRobust(idPacked, pname, bufSize, length, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectui64vRobustANGLE, isCallValid, context, idPacked, pname, + bufSize, length, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_robust_resource_initialization + +// GL_ANGLE_semaphore_fuchsia +void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore, + GLenum handleType, + GLuint handle) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLImportSemaphoreZirconHandleANGLE, + "context = %d, semaphore = %u, handleType = %s, handle = %u", CID(context), semaphore, + GLenumToString(GLESEnum::ExternalHandleType, handleType), handle); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + HandleType handleTypePacked = PackParam<HandleType>(handleType); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateImportSemaphoreZirconHandleANGLE( + context, angle::EntryPoint::GLImportSemaphoreZirconHandleANGLE, + semaphorePacked, handleTypePacked, handle)); + if (isCallValid) + { + context->importSemaphoreZirconHandle(semaphorePacked, handleTypePacked, handle); + } + ANGLE_CAPTURE_GL(ImportSemaphoreZirconHandleANGLE, isCallValid, context, semaphorePacked, + handleTypePacked, handle); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_shader_pixel_local_storage +void GL_APIENTRY GL_FramebufferMemorylessPixelLocalStorageANGLE(GLint plane, GLenum internalformat) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferMemorylessPixelLocalStorageANGLE, + "context = %d, plane = %d, internalformat = %s", CID(context), plane, + GLenumToString(GLESEnum::AllEnums, internalformat)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferMemorylessPixelLocalStorageANGLE( + context, angle::EntryPoint::GLFramebufferMemorylessPixelLocalStorageANGLE, plane, + internalformat)); + if (isCallValid) + { + context->framebufferMemorylessPixelLocalStorage(plane, internalformat); + } + ANGLE_CAPTURE_GL(FramebufferMemorylessPixelLocalStorageANGLE, isCallValid, context, plane, + internalformat); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferTexturePixelLocalStorageANGLE(GLint plane, + GLuint backingtexture, + GLint level, + GLint layer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTexturePixelLocalStorageANGLE, + "context = %d, plane = %d, backingtexture = %u, level = %d, layer = %d", CID(context), + plane, backingtexture, level, layer); + + if (context) + { + TextureID backingtexturePacked = PackParam<TextureID>(backingtexture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferTexturePixelLocalStorageANGLE( + context, angle::EntryPoint::GLFramebufferTexturePixelLocalStorageANGLE, plane, + backingtexturePacked, level, layer)); + if (isCallValid) + { + context->framebufferTexturePixelLocalStorage(plane, backingtexturePacked, level, layer); + } + ANGLE_CAPTURE_GL(FramebufferTexturePixelLocalStorageANGLE, isCallValid, context, plane, + backingtexturePacked, level, layer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BeginPixelLocalStorageANGLE(GLsizei planes, + const GLenum *loadops, + const void *cleardata) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBeginPixelLocalStorageANGLE, + "context = %d, planes = %d, loadops = 0x%016" PRIxPTR ", cleardata = 0x%016" PRIxPTR "", + CID(context), planes, (uintptr_t)loadops, (uintptr_t)cleardata); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBeginPixelLocalStorageANGLE( + context, angle::EntryPoint::GLBeginPixelLocalStorageANGLE, planes, + loadops, cleardata)); + if (isCallValid) + { + context->beginPixelLocalStorage(planes, loadops, cleardata); + } + ANGLE_CAPTURE_GL(BeginPixelLocalStorageANGLE, isCallValid, context, planes, loadops, + cleardata); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EndPixelLocalStorageANGLE() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEndPixelLocalStorageANGLE, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEndPixelLocalStorageANGLE( + context, angle::EntryPoint::GLEndPixelLocalStorageANGLE)); + if (isCallValid) + { + context->endPixelLocalStorage(); + } + ANGLE_CAPTURE_GL(EndPixelLocalStorageANGLE, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PixelLocalStorageBarrierANGLE() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPixelLocalStorageBarrierANGLE, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePixelLocalStorageBarrierANGLE( + context, angle::EntryPoint::GLPixelLocalStorageBarrierANGLE)); + if (isCallValid) + { + context->pixelLocalStorageBarrier(); + } + ANGLE_CAPTURE_GL(PixelLocalStorageBarrierANGLE, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_texture_compression_dxt3 + +// GL_ANGLE_texture_compression_dxt5 + +// GL_ANGLE_texture_external_update +void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexImage2DExternalANGLE, + "context = %d, target = %s, level = %d, internalformat = %d, width = %d, height = %d, " + "border = %d, format = %s, type = %s", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, internalformat, + width, height, border, GLenumToString(GLESEnum::PixelFormat, format), + GLenumToString(GLESEnum::PixelType, type)); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexImage2DExternalANGLE( + context, angle::EntryPoint::GLTexImage2DExternalANGLE, targetPacked, + level, internalformat, width, height, border, format, type)); + if (isCallValid) + { + context->texImage2DExternal(targetPacked, level, internalformat, width, height, border, + format, type); + } + ANGLE_CAPTURE_GL(TexImage2DExternalANGLE, isCallValid, context, targetPacked, level, + internalformat, width, height, border, format, type); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLInvalidateTextureANGLE, "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() || + ValidateInvalidateTextureANGLE(context, angle::EntryPoint::GLInvalidateTextureANGLE, + targetPacked)); + if (isCallValid) + { + context->invalidateTexture(targetPacked); + } + ANGLE_CAPTURE_GL(InvalidateTextureANGLE, isCallValid, context, targetPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_texture_multisample +void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage2DMultisampleANGLE, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d, " + "fixedsamplelocations = %s", + CID(context), GLenumToString(GLESEnum::AllEnums, target), samples, + GLenumToString(GLESEnum::AllEnums, internalformat), width, height, + GLbooleanToString(fixedsamplelocations)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage2DMultisampleANGLE( + context, angle::EntryPoint::GLTexStorage2DMultisampleANGLE, targetPacked, samples, + internalformat, width, height, fixedsamplelocations)); + if (isCallValid) + { + context->texStorage2DMultisample(targetPacked, samples, internalformat, width, height, + fixedsamplelocations); + } + ANGLE_CAPTURE_GL(TexStorage2DMultisampleANGLE, isCallValid, context, targetPacked, samples, + internalformat, width, height, fixedsamplelocations); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMultisamplefvANGLE, + "context = %d, pname = %s, index = %u, val = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, pname), index, (uintptr_t)val); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetMultisamplefvANGLE(context, angle::EntryPoint::GLGetMultisamplefvANGLE, + pname, index, val)); + if (isCallValid) + { + context->getMultisamplefv(pname, index, val); + } + ANGLE_CAPTURE_GL(GetMultisamplefvANGLE, isCallValid, context, pname, index, val); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSampleMaskiANGLE, "context = %d, maskNumber = %u, mask = %s", CID(context), + maskNumber, GLbitfieldToString(GLESEnum::AllEnums, mask).c_str()); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSampleMaskiANGLE(context, angle::EntryPoint::GLSampleMaskiANGLE, + maskNumber, mask)); + if (isCallValid) + { + context->sampleMaski(maskNumber, mask); + } + ANGLE_CAPTURE_GL(SampleMaskiANGLE, isCallValid, context, maskNumber, mask); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GetTexLevelParameterfvANGLE is already defined. + +// GetTexLevelParameterivANGLE is already defined. + +// GL_ANGLE_texture_usage + +// GL_ANGLE_translated_shader_source +void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *source) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTranslatedShaderSourceANGLE, + "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() || + ValidateGetTranslatedShaderSourceANGLE( + context, angle::EntryPoint::GLGetTranslatedShaderSourceANGLE, + shaderPacked, bufSize, length, source)); + if (isCallValid) + { + context->getTranslatedShaderSource(shaderPacked, bufSize, length, source); + } + ANGLE_CAPTURE_GL(GetTranslatedShaderSourceANGLE, isCallValid, context, shaderPacked, + bufSize, length, source); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_ANGLE_vulkan_image +void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures, + const GLuint *textures, + const GLenum *layouts) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLAcquireTexturesANGLE, + "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR + "", + CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts); + + if (context) + { + const TextureID *texturesPacked = PackParam<const TextureID *>(textures); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateAcquireTexturesANGLE(context, angle::EntryPoint::GLAcquireTexturesANGLE, + numTextures, texturesPacked, layouts)); + if (isCallValid) + { + context->acquireTextures(numTextures, texturesPacked, layouts); + } + ANGLE_CAPTURE_GL(AcquireTexturesANGLE, isCallValid, context, numTextures, texturesPacked, + layouts); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReleaseTexturesANGLE(GLuint numTextures, + const GLuint *textures, + GLenum *layouts) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReleaseTexturesANGLE, + "context = %d, numTextures = %u, textures = 0x%016" PRIxPTR ", layouts = 0x%016" PRIxPTR + "", + CID(context), numTextures, (uintptr_t)textures, (uintptr_t)layouts); + + if (context) + { + const TextureID *texturesPacked = PackParam<const TextureID *>(textures); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateReleaseTexturesANGLE(context, angle::EntryPoint::GLReleaseTexturesANGLE, + numTextures, texturesPacked, layouts)); + if (isCallValid) + { + context->releaseTextures(numTextures, texturesPacked, layouts); + } + ANGLE_CAPTURE_GL(ReleaseTexturesANGLE, isCallValid, context, numTextures, texturesPacked, + layouts); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_APPLE_clip_distance + +// GL_ARB_sync +// ClientWaitSync is already defined. + +// DeleteSync is already defined. + +// FenceSync is already defined. + +// GetInteger64v is already defined. + +// GetSynciv is already defined. + +// IsSync is already defined. + +// WaitSync is already defined. + +// GL_CHROMIUM_bind_uniform_location +void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindUniformLocationCHROMIUM, + "context = %d, program = %u, location = %d, name = 0x%016" PRIxPTR "", CID(context), + program, location, (uintptr_t)name); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindUniformLocationCHROMIUM( + context, angle::EntryPoint::GLBindUniformLocationCHROMIUM, + programPacked, locationPacked, name)); + if (isCallValid) + { + context->bindUniformLocation(programPacked, locationPacked, name); + } + ANGLE_CAPTURE_GL(BindUniformLocationCHROMIUM, isCallValid, context, programPacked, + locationPacked, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_CHROMIUM_copy_compressed_texture +void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedCopyTextureCHROMIUM, "context = %d, sourceId = %u, destId = %u", + CID(context), sourceId, destId); + + if (context) + { + TextureID sourceIdPacked = PackParam<TextureID>(sourceId); + TextureID destIdPacked = PackParam<TextureID>(destId); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCompressedCopyTextureCHROMIUM( + context, angle::EntryPoint::GLCompressedCopyTextureCHROMIUM, + sourceIdPacked, destIdPacked)); + if (isCallValid) + { + context->compressedCopyTexture(sourceIdPacked, destIdPacked); + } + ANGLE_CAPTURE_GL(CompressedCopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, + destIdPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_CHROMIUM_copy_texture +void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopyTextureCHROMIUM, + "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " + "= %d, internalFormat = %d, destType = %s, unpackFlipY = %s, unpackPremultiplyAlpha = " + "%s, unpackUnmultiplyAlpha = %s", + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, internalFormat, GLenumToString(GLESEnum::AllEnums, destType), + GLbooleanToString(unpackFlipY), GLbooleanToString(unpackPremultiplyAlpha), + GLbooleanToString(unpackUnmultiplyAlpha)); + + if (context) + { + TextureID sourceIdPacked = PackParam<TextureID>(sourceId); + TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget); + TextureID destIdPacked = PackParam<TextureID>(destId); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCopyTextureCHROMIUM( + context, angle::EntryPoint::GLCopyTextureCHROMIUM, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, internalFormat, destType, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + if (isCallValid) + { + context->copyTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, + destLevel, internalFormat, destType, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + ANGLE_CAPTURE_GL(CopyTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, internalFormat, destType, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLint width, + GLint height, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopySubTextureCHROMIUM, + "context = %d, sourceId = %u, sourceLevel = %d, destTarget = %s, destId = %u, destLevel " + "= %d, xoffset = %d, yoffset = %d, x = %d, y = %d, width = %d, height = %d, unpackFlipY " + "= %s, unpackPremultiplyAlpha = %s, unpackUnmultiplyAlpha = %s", + CID(context), sourceId, sourceLevel, GLenumToString(GLESEnum::AllEnums, destTarget), + destId, destLevel, xoffset, yoffset, x, y, width, height, GLbooleanToString(unpackFlipY), + GLbooleanToString(unpackPremultiplyAlpha), GLbooleanToString(unpackUnmultiplyAlpha)); + + if (context) + { + TextureID sourceIdPacked = PackParam<TextureID>(sourceId); + TextureTarget destTargetPacked = PackParam<TextureTarget>(destTarget); + TextureID destIdPacked = PackParam<TextureID>(destId); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCopySubTextureCHROMIUM( + context, angle::EntryPoint::GLCopySubTextureCHROMIUM, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width, height, + unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha)); + if (isCallValid) + { + context->copySubTexture(sourceIdPacked, sourceLevel, destTargetPacked, destIdPacked, + destLevel, xoffset, yoffset, x, y, width, height, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + ANGLE_CAPTURE_GL(CopySubTextureCHROMIUM, isCallValid, context, sourceIdPacked, sourceLevel, + destTargetPacked, destIdPacked, destLevel, xoffset, yoffset, x, y, width, + height, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_CHROMIUM_framebuffer_mixed_samples +void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCoverageModulationCHROMIUM, "context = %d, components = %s", CID(context), + GLenumToString(GLESEnum::AllEnums, components)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCoverageModulationCHROMIUM( + context, angle::EntryPoint::GLCoverageModulationCHROMIUM, components)); + if (isCallValid) + { + context->coverageModulation(components); + } + ANGLE_CAPTURE_GL(CoverageModulationCHROMIUM, isCallValid, context, components); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_CHROMIUM_lose_context +void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLoseContextCHROMIUM, "context = %d, current = %s, other = %s", CID(context), + GLenumToString(GLESEnum::GraphicsResetStatus, current), + GLenumToString(GLESEnum::GraphicsResetStatus, other)); + + if (context) + { + GraphicsResetStatus currentPacked = PackParam<GraphicsResetStatus>(current); + GraphicsResetStatus otherPacked = PackParam<GraphicsResetStatus>(other); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateLoseContextCHROMIUM(context, angle::EntryPoint::GLLoseContextCHROMIUM, + currentPacked, otherPacked)); + if (isCallValid) + { + context->loseContext(currentPacked, otherPacked); + } + ANGLE_CAPTURE_GL(LoseContextCHROMIUM, isCallValid, context, currentPacked, otherPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_EGL_image_array + +// GL_EXT_EGL_image_storage +void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target, + GLeglImageOES image, + const GLint *attrib_list) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEGLImageTargetTexStorageEXT, + "context = %d, target = %s, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image, + (uintptr_t)attrib_list); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEGLImageTargetTexStorageEXT( + context, angle::EntryPoint::GLEGLImageTargetTexStorageEXT, target, + image, attrib_list)); + if (isCallValid) + { + context->eGLImageTargetTexStorage(target, image, attrib_list); + } + ANGLE_CAPTURE_GL(EGLImageTargetTexStorageEXT, isCallValid, context, target, image, + attrib_list); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EGLImageTargetTextureStorageEXT(GLuint texture, + GLeglImageOES image, + const GLint *attrib_list) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEGLImageTargetTextureStorageEXT, + "context = %d, texture = %u, image = 0x%016" PRIxPTR ", attrib_list = 0x%016" PRIxPTR "", + CID(context), texture, (uintptr_t)image, (uintptr_t)attrib_list); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEGLImageTargetTextureStorageEXT( + context, angle::EntryPoint::GLEGLImageTargetTextureStorageEXT, + texture, image, attrib_list)); + if (isCallValid) + { + context->eGLImageTargetTextureStorage(texture, image, attrib_list); + } + ANGLE_CAPTURE_GL(EGLImageTargetTextureStorageEXT, isCallValid, context, texture, image, + attrib_list); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_YUV_target + +// GL_EXT_base_instance +void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceEXT(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysInstancedBaseInstanceEXT, + "context = %d, mode = %s, first = %d, count = %d, instancecount = %d, baseinstance = %u", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), first, count, instancecount, + baseinstance); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawArraysInstancedBaseInstanceEXT( + context, angle::EntryPoint::GLDrawArraysInstancedBaseInstanceEXT, + modePacked, first, count, instancecount, baseinstance)); + if (isCallValid) + { + context->drawArraysInstancedBaseInstance(modePacked, first, count, instancecount, + baseinstance); + } + ANGLE_CAPTURE_GL(DrawArraysInstancedBaseInstanceEXT, isCallValid, context, modePacked, + first, count, instancecount, baseinstance); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLuint baseinstance) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseInstanceEXT, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", instancecount = %d, baseinstance = %u", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::PrimitiveType, type), (uintptr_t)indices, instancecount, + baseinstance); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsInstancedBaseInstanceEXT( + context, angle::EntryPoint::GLDrawElementsInstancedBaseInstanceEXT, modePacked, + count, typePacked, indices, instancecount, baseinstance)); + if (isCallValid) + { + context->drawElementsInstancedBaseInstance(modePacked, count, typePacked, indices, + instancecount, baseinstance); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseInstanceEXT, isCallValid, context, modePacked, + count, typePacked, indices, instancecount, baseinstance); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseVertexBaseInstanceEXT, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", instancecount = %d, basevertex = %d, baseinstance = %u", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, instancecount, + basevertex, baseinstance); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawElementsInstancedBaseVertexBaseInstanceEXT( + context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexBaseInstanceEXT, + modePacked, count, typePacked, indices, instancecount, basevertex, baseinstance)); + if (isCallValid) + { + context->drawElementsInstancedBaseVertexBaseInstance( + modePacked, count, typePacked, indices, instancecount, basevertex, baseinstance); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexBaseInstanceEXT, isCallValid, context, + modePacked, count, typePacked, indices, instancecount, basevertex, + baseinstance); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_blend_func_extended +void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindFragDataLocationEXT, + "context = %d, program = %u, color = %u, name = 0x%016" PRIxPTR "", CID(context), program, + color, (uintptr_t)name); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindFragDataLocationEXT(context, angle::EntryPoint::GLBindFragDataLocationEXT, + programPacked, color, name)); + if (isCallValid) + { + context->bindFragDataLocation(programPacked, color, name); + } + ANGLE_CAPTURE_GL(BindFragDataLocationEXT, isCallValid, context, programPacked, color, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program, + GLuint colorNumber, + GLuint index, + const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindFragDataLocationIndexedEXT, + "context = %d, program = %u, colorNumber = %u, index = %u, name = 0x%016" PRIxPTR "", + CID(context), program, colorNumber, index, (uintptr_t)name); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindFragDataLocationIndexedEXT( + context, angle::EntryPoint::GLBindFragDataLocationIndexedEXT, + programPacked, colorNumber, index, name)); + if (isCallValid) + { + context->bindFragDataLocationIndexed(programPacked, colorNumber, index, name); + } + ANGLE_CAPTURE_GL(BindFragDataLocationIndexedEXT, isCallValid, context, programPacked, + colorNumber, index, name); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLint GL_APIENTRY GL_GetFragDataIndexEXT(GLuint program, const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFragDataIndexEXT, "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() || + ValidateGetFragDataIndexEXT(context, angle::EntryPoint::GLGetFragDataIndexEXT, + programPacked, name)); + if (isCallValid) + { + returnValue = context->getFragDataIndex(programPacked, name); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>(); + } + ANGLE_CAPTURE_GL(GetFragDataIndexEXT, isCallValid, context, programPacked, name, + returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetFragDataIndexEXT, GLint>(); + } + return returnValue; +} + +GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramResourceLocationIndexEXT, + "context = %d, program = %u, programInterface = %s, name = 0x%016" PRIxPTR "", + CID(context), program, GLenumToString(GLESEnum::ProgramInterface, programInterface), + (uintptr_t)name); + + GLint returnValue; + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramResourceLocationIndexEXT( + context, angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, + programPacked, programInterface, name)); + if (isCallValid) + { + returnValue = + context->getProgramResourceLocationIndex(programPacked, programInterface, name); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, + GLint>(); + } + ANGLE_CAPTURE_GL(GetProgramResourceLocationIndexEXT, isCallValid, context, programPacked, + programInterface, name, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetProgramResourceLocationIndexEXT, GLint>(); + } + return returnValue; +} + +// GL_EXT_blend_minmax + +// GL_EXT_buffer_storage +void GL_APIENTRY GL_BufferStorageEXT(GLenum target, + GLsizeiptr size, + const void *data, + GLbitfield flags) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBufferStorageEXT, + "context = %d, target = %s, size = %llu, data = 0x%016" PRIxPTR ", flags = %s", + CID(context), GLenumToString(GLESEnum::BufferStorageTarget, target), + static_cast<unsigned long long>(size), (uintptr_t)data, + GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBufferStorageEXT(context, angle::EntryPoint::GLBufferStorageEXT, + targetPacked, size, data, flags)); + if (isCallValid) + { + context->bufferStorage(targetPacked, size, data, flags); + } + ANGLE_CAPTURE_GL(BufferStorageEXT, isCallValid, context, targetPacked, size, data, flags); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_clip_control +void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLClipControlEXT, "context = %d, origin = %s, depth = %s", CID(context), + GLenumToString(GLESEnum::AllEnums, origin), GLenumToString(GLESEnum::AllEnums, depth)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateClipControlEXT(context, angle::EntryPoint::GLClipControlEXT, origin, depth)); + if (isCallValid) + { + context->clipControl(origin, depth); + } + ANGLE_CAPTURE_GL(ClipControlEXT, isCallValid, context, origin, depth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_clip_cull_distance + +// GL_EXT_color_buffer_float + +// GL_EXT_color_buffer_half_float + +// GL_EXT_copy_image +void GL_APIENTRY GL_CopyImageSubDataEXT(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, GLCopyImageSubDataEXT, + "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::CopyBufferSubDataTarget, srcTarget), + srcLevel, srcX, srcY, srcZ, dstName, + GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCopyImageSubDataEXT( + context, angle::EntryPoint::GLCopyImageSubDataEXT, 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(CopyImageSubDataEXT, isCallValid, context, srcName, srcTarget, srcLevel, + srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, + srcHeight, srcDepth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_debug_label +void GL_APIENTRY +GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetObjectLabelEXT, + "context = %d, type = %s, object = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", label = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, type), object, bufSize, + (uintptr_t)length, (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetObjectLabelEXT(context, angle::EntryPoint::GLGetObjectLabelEXT, type, + object, bufSize, length, label)); + if (isCallValid) + { + context->getObjectLabel(type, object, bufSize, length, label); + } + ANGLE_CAPTURE_GL(GetObjectLabelEXT, isCallValid, context, type, object, bufSize, length, + label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLabelObjectEXT, + "context = %d, type = %s, object = %u, length = %d, label = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, type), object, length, (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLabelObjectEXT(context, angle::EntryPoint::GLLabelObjectEXT, + type, object, length, label)); + if (isCallValid) + { + context->labelObject(type, object, length, label); + } + ANGLE_CAPTURE_GL(LabelObjectEXT, isCallValid, context, type, object, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_debug_marker +void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker) +{ + Context *context = GetValidGlobalContext(); + // Don't run the EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + // EVENT(context, GLInsertEventMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR + // "", CID(context), length, (uintptr_t)marker); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateInsertEventMarkerEXT(context, angle::EntryPoint::GLInsertEventMarkerEXT, + length, marker)); + if (isCallValid) + { + context->insertEventMarker(length, marker); + } + ANGLE_CAPTURE_GL(InsertEventMarkerEXT, isCallValid, context, length, marker); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PopGroupMarkerEXT() +{ + Context *context = GetValidGlobalContext(); + // Don't run the EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + // EVENT(context, GLPopGroupMarkerEXT, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePopGroupMarkerEXT(context, angle::EntryPoint::GLPopGroupMarkerEXT)); + if (isCallValid) + { + context->popGroupMarker(); + } + ANGLE_CAPTURE_GL(PopGroupMarkerEXT, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker) +{ + Context *context = GetValidGlobalContext(); + // Don't run the EVENT() macro on the EXT_debug_marker entry points. + // It can interfere with the debug events being set by the caller. + // EVENT(context, GLPushGroupMarkerEXT, "context = %d, length = %d, marker = 0x%016" PRIxPTR "", + // CID(context), length, (uintptr_t)marker); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePushGroupMarkerEXT( + context, angle::EntryPoint::GLPushGroupMarkerEXT, length, marker)); + if (isCallValid) + { + context->pushGroupMarker(length, marker); + } + ANGLE_CAPTURE_GL(PushGroupMarkerEXT, isCallValid, context, length, marker); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_discard_framebuffer +void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target, + GLsizei numAttachments, + const GLenum *attachments) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDiscardFramebufferEXT, + "context = %d, target = %s, numAttachments = %d, attachments = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), numAttachments, + (uintptr_t)attachments); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDiscardFramebufferEXT(context, angle::EntryPoint::GLDiscardFramebufferEXT, + target, numAttachments, attachments)); + if (isCallValid) + { + context->discardFramebuffer(target, numAttachments, attachments); + } + ANGLE_CAPTURE_GL(DiscardFramebufferEXT, isCallValid, context, target, numAttachments, + attachments); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_disjoint_timer_query +void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBeginQueryEXT, "context = %d, target = %s, id = %u", CID(context), + GLenumToString(GLESEnum::QueryTarget, target), id); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBeginQueryEXT(context, angle::EntryPoint::GLBeginQueryEXT, + targetPacked, idPacked)); + if (isCallValid) + { + context->beginQuery(targetPacked, idPacked); + } + ANGLE_CAPTURE_GL(BeginQueryEXT, isCallValid, context, targetPacked, idPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteQueriesEXT(GLsizei n, const GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)ids); + + if (context) + { + const QueryID *idsPacked = PackParam<const QueryID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDeleteQueriesEXT(context, angle::EntryPoint::GLDeleteQueriesEXT, + n, idsPacked)); + if (isCallValid) + { + context->deleteQueries(n, idsPacked); + } + ANGLE_CAPTURE_GL(DeleteQueriesEXT, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EndQueryEXT(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEndQueryEXT, "context = %d, target = %s", CID(context), + GLenumToString(GLESEnum::QueryTarget, target)); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEndQueryEXT(context, angle::EntryPoint::GLEndQueryEXT, targetPacked)); + if (isCallValid) + { + context->endQuery(targetPacked); + } + ANGLE_CAPTURE_GL(EndQueryEXT, isCallValid, context, targetPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenQueriesEXT(GLsizei n, GLuint *ids) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenQueriesEXT, "context = %d, n = %d, ids = 0x%016" PRIxPTR "", CID(context), + n, (uintptr_t)ids); + + if (context) + { + QueryID *idsPacked = PackParam<QueryID *>(ids); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenQueriesEXT(context, angle::EntryPoint::GLGenQueriesEXT, n, idsPacked)); + if (isCallValid) + { + context->genQueries(n, idsPacked); + } + ANGLE_CAPTURE_GL(GenQueriesEXT, isCallValid, context, n, idsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetInteger64vEXT, "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() || + ValidateGetInteger64vEXT(context, angle::EntryPoint::GLGetInteger64vEXT, pname, data)); + if (isCallValid) + { + context->getInteger64v(pname, data); + } + ANGLE_CAPTURE_GL(GetInteger64vEXT, isCallValid, context, pname, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetQueryObjecti64vEXT, + "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryObjecti64vEXT(context, angle::EntryPoint::GLGetQueryObjecti64vEXT, + idPacked, pname, params)); + if (isCallValid) + { + context->getQueryObjecti64v(idPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryObjecti64vEXT, isCallValid, context, idPacked, pname, params); + } + else + {} +} + +void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params) +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetQueryObjectivEXT, + "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryObjectivEXT(context, angle::EntryPoint::GLGetQueryObjectivEXT, + idPacked, pname, params)); + if (isCallValid) + { + context->getQueryObjectiv(idPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectivEXT, isCallValid, context, idPacked, pname, params); + } + else + {} +} + +void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryObjectui64vEXT, + "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryObjectui64vEXT(context, angle::EntryPoint::GLGetQueryObjectui64vEXT, + idPacked, pname, params)); + if (isCallValid) + { + context->getQueryObjectui64v(idPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectui64vEXT, isCallValid, context, idPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryObjectuivEXT, + "context = %d, id = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), id, + GLenumToString(GLESEnum::QueryObjectParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetQueryObjectuivEXT(context, angle::EntryPoint::GLGetQueryObjectuivEXT, + idPacked, pname, params)); + if (isCallValid) + { + context->getQueryObjectuiv(idPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryObjectuivEXT, isCallValid, context, idPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetQueryivEXT, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::QueryTarget, target), + GLenumToString(GLESEnum::QueryParameterName, pname), (uintptr_t)params); + + if (context) + { + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetQueryivEXT(context, angle::EntryPoint::GLGetQueryivEXT, + targetPacked, pname, params)); + if (isCallValid) + { + context->getQueryiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetQueryivEXT, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsQueryEXT(GLuint id) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsQueryEXT, "context = %d, id = %u", CID(context), id); + + GLboolean returnValue; + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateIsQueryEXT(context, angle::EntryPoint::GLIsQueryEXT, idPacked)); + if (isCallValid) + { + returnValue = context->isQuery(idPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsQueryEXT, isCallValid, context, idPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsQueryEXT, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLQueryCounterEXT, "context = %d, id = %u, target = %s", CID(context), id, + GLenumToString(GLESEnum::QueryCounterTarget, target)); + + if (context) + { + QueryID idPacked = PackParam<QueryID>(id); + QueryType targetPacked = PackParam<QueryType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateQueryCounterEXT(context, angle::EntryPoint::GLQueryCounterEXT, + idPacked, targetPacked)); + if (isCallValid) + { + context->queryCounter(idPacked, targetPacked); + } + ANGLE_CAPTURE_GL(QueryCounterEXT, isCallValid, context, idPacked, targetPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_draw_buffers +void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawBuffersEXT, "context = %d, n = %d, bufs = 0x%016" PRIxPTR "", CID(context), + n, (uintptr_t)bufs); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawBuffersEXT(context, angle::EntryPoint::GLDrawBuffersEXT, n, bufs)); + if (isCallValid) + { + context->drawBuffers(n, bufs); + } + ANGLE_CAPTURE_GL(DrawBuffersEXT, isCallValid, context, n, bufs); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_draw_buffers_indexed +void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationSeparateiEXT, + "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() || + ValidateBlendEquationSeparateiEXT( + context, angle::EntryPoint::GLBlendEquationSeparateiEXT, buf, modeRGB, modeAlpha)); + if (isCallValid) + { + context->blendEquationSeparatei(buf, modeRGB, modeAlpha); + } + ANGLE_CAPTURE_GL(BlendEquationSeparateiEXT, isCallValid, context, buf, modeRGB, modeAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationiEXT, "context = %d, buf = %u, mode = %s", CID(context), buf, + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendEquationiEXT(context, angle::EntryPoint::GLBlendEquationiEXT, buf, mode)); + if (isCallValid) + { + context->blendEquationi(buf, mode); + } + ANGLE_CAPTURE_GL(BlendEquationiEXT, isCallValid, context, buf, mode); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_BlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFuncSeparateiEXT, + "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() || + ValidateBlendFuncSeparateiEXT(context, angle::EntryPoint::GLBlendFuncSeparateiEXT, buf, + srcRGB, dstRGB, srcAlpha, dstAlpha)); + if (isCallValid) + { + context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); + } + ANGLE_CAPTURE_GL(BlendFuncSeparateiEXT, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha, + dstAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFunciEXT, "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() || + ValidateBlendFunciEXT(context, angle::EntryPoint::GLBlendFunciEXT, buf, src, dst)); + if (isCallValid) + { + context->blendFunci(buf, src, dst); + } + ANGLE_CAPTURE_GL(BlendFunciEXT, isCallValid, context, buf, src, dst); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColorMaskiEXT, "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() || + ValidateColorMaskiEXT(context, angle::EntryPoint::GLColorMaskiEXT, index, r, g, b, a)); + if (isCallValid) + { + context->colorMaski(index, r, g, b, a); + } + ANGLE_CAPTURE_GL(ColorMaskiEXT, isCallValid, context, index, r, g, b, a); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDisableiEXT, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDisableiEXT(context, angle::EntryPoint::GLDisableiEXT, target, index)); + if (isCallValid) + { + context->disablei(target, index); + } + ANGLE_CAPTURE_GL(DisableiEXT, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEnableiEXT, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEnableiEXT(context, angle::EntryPoint::GLEnableiEXT, target, index)); + if (isCallValid) + { + context->enablei(target, index); + } + ANGLE_CAPTURE_GL(EnableiEXT, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsEnablediEXT, "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() || + ValidateIsEnablediEXT(context, angle::EntryPoint::GLIsEnablediEXT, target, index)); + if (isCallValid) + { + returnValue = context->isEnabledi(target, index); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsEnablediEXT, isCallValid, context, target, index, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediEXT, GLboolean>(); + } + return returnValue; +} + +// GL_EXT_draw_elements_base_vertex +void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsBaseVertexEXT, + "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() || + ValidateDrawElementsBaseVertexEXT( + context, angle::EntryPoint::GLDrawElementsBaseVertexEXT, modePacked, + count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsBaseVertexEXT, isCallValid, context, modePacked, count, + typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseVertexEXT, + "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() || + ValidateDrawElementsInstancedBaseVertexEXT( + context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexEXT, + modePacked, count, typePacked, indices, instancecount, basevertex)); + if (isCallValid) + { + context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices, + instancecount, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexEXT, isCallValid, context, modePacked, + count, typePacked, indices, instancecount, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawRangeElementsBaseVertexEXT, + "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() || + ValidateDrawRangeElementsBaseVertexEXT( + context, angle::EntryPoint::GLDrawRangeElementsBaseVertexEXT, + modePacked, start, end, count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices, + basevertex); + } + ANGLE_CAPTURE_GL(DrawRangeElementsBaseVertexEXT, isCallValid, context, modePacked, start, + end, count, typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode, + const GLsizei *count, + GLenum type, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawElementsBaseVertexEXT, + "context = %d, mode = %s, count = 0x%016" PRIxPTR ", type = %s, indices = 0x%016" PRIxPTR + ", drawcount = %d, basevertex = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, drawcount, + (uintptr_t)basevertex); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiDrawElementsBaseVertexEXT( + context, angle::EntryPoint::GLMultiDrawElementsBaseVertexEXT, + modePacked, count, typePacked, indices, drawcount, basevertex)); + if (isCallValid) + { + context->multiDrawElementsBaseVertex(modePacked, count, typePacked, indices, drawcount, + basevertex); + } + ANGLE_CAPTURE_GL(MultiDrawElementsBaseVertexEXT, isCallValid, context, modePacked, count, + typePacked, indices, drawcount, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_external_buffer +void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBufferStorageExternalEXT, + "context = %d, target = %s, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR + ", flags = %s", + CID(context), GLenumToString(GLESEnum::AllEnums, target), + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(size), + (uintptr_t)clientBuffer, GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBufferStorageExternalEXT( + context, angle::EntryPoint::GLBufferStorageExternalEXT, + targetPacked, offset, size, clientBuffer, flags)); + if (isCallValid) + { + context->bufferStorageExternal(targetPacked, offset, size, clientBuffer, flags); + } + ANGLE_CAPTURE_GL(BufferStorageExternalEXT, isCallValid, context, targetPacked, offset, size, + clientBuffer, flags); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLNamedBufferStorageExternalEXT, + "context = %d, buffer = %u, offset = %llu, size = %llu, clientBuffer = 0x%016" PRIxPTR + ", flags = %s", + CID(context), buffer, static_cast<unsigned long long>(offset), + static_cast<unsigned long long>(size), (uintptr_t)clientBuffer, + GLbitfieldToString(GLESEnum::BufferStorageMask, flags).c_str()); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateNamedBufferStorageExternalEXT( + context, angle::EntryPoint::GLNamedBufferStorageExternalEXT, buffer, + offset, size, clientBuffer, flags)); + if (isCallValid) + { + context->namedBufferStorageExternal(buffer, offset, size, clientBuffer, flags); + } + ANGLE_CAPTURE_GL(NamedBufferStorageExternalEXT, isCallValid, context, buffer, offset, size, + clientBuffer, flags); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_float_blend + +// GL_EXT_geometry_shader +void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target, + GLenum attachment, + GLuint texture, + GLint level) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTextureEXT, + "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() || + ValidateFramebufferTextureEXT(context, angle::EntryPoint::GLFramebufferTextureEXT, + target, attachment, texturePacked, level)); + if (isCallValid) + { + context->framebufferTexture(target, attachment, texturePacked, level); + } + ANGLE_CAPTURE_GL(FramebufferTextureEXT, isCallValid, context, target, attachment, + texturePacked, level); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_gpu_shader5 + +// GL_EXT_instanced_arrays +void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode, + GLint start, + GLsizei count, + GLsizei primcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawArraysInstancedEXT, + "context = %d, mode = %s, start = %d, count = %d, primcount = %d", CID(context), + GLenumToString(GLESEnum::PrimitiveType, mode), start, count, primcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawArraysInstancedEXT(context, angle::EntryPoint::GLDrawArraysInstancedEXT, + modePacked, start, count, primcount)); + if (isCallValid) + { + context->drawArraysInstanced(modePacked, start, count, primcount); + } + ANGLE_CAPTURE_GL(DrawArraysInstancedEXT, isCallValid, context, modePacked, start, count, + primcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedEXT, + "context = %d, mode = %s, count = %d, type = %s, indices = 0x%016" PRIxPTR + ", primcount = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), count, + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indices, primcount); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawElementsInstancedEXT( + context, angle::EntryPoint::GLDrawElementsInstancedEXT, modePacked, + count, typePacked, indices, primcount)); + if (isCallValid) + { + context->drawElementsInstanced(modePacked, count, typePacked, indices, primcount); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedEXT, isCallValid, context, modePacked, count, + typePacked, indices, primcount); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_VertexAttribDivisorEXT(GLuint index, GLuint divisor) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLVertexAttribDivisorEXT, "context = %d, index = %u, divisor = %u", CID(context), + index, divisor); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateVertexAttribDivisorEXT(context, angle::EntryPoint::GLVertexAttribDivisorEXT, + index, divisor)); + if (isCallValid) + { + context->vertexAttribDivisor(index, divisor); + } + ANGLE_CAPTURE_GL(VertexAttribDivisorEXT, isCallValid, context, index, divisor); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_map_buffer_range +void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFlushMappedBufferRangeEXT, + "context = %d, target = %s, offset = %llu, length = %llu", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length)); + + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFlushMappedBufferRangeEXT( + context, angle::EntryPoint::GLFlushMappedBufferRangeEXT, + targetPacked, offset, length)); + if (isCallValid) + { + context->flushMappedBufferRange(targetPacked, offset, length); + } + ANGLE_CAPTURE_GL(FlushMappedBufferRangeEXT, isCallValid, context, targetPacked, offset, + length); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMapBufferRangeEXT, + "context = %d, target = %s, offset = %llu, length = %llu, access = %s", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), + static_cast<unsigned long long>(offset), static_cast<unsigned long long>(length), + GLbitfieldToString(GLESEnum::MapBufferAccessMask, access).c_str()); + + void *returnValue; + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMapBufferRangeEXT(context, angle::EntryPoint::GLMapBufferRangeEXT, + targetPacked, offset, length, access)); + if (isCallValid) + { + returnValue = context->mapBufferRange(targetPacked, offset, length, access); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>(); + } + ANGLE_CAPTURE_GL(MapBufferRangeEXT, isCallValid, context, targetPacked, offset, length, + access, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferRangeEXT, void *>(); + } + return returnValue; +} + +// GL_EXT_memory_object +void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target, + GLsizeiptr size, + GLuint memory, + GLuint64 offset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBufferStorageMemEXT, + "context = %d, target = %s, size = %llu, memory = %u, offset = %llu", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), static_cast<unsigned long long>(size), + memory, static_cast<unsigned long long>(offset)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBufferStorageMemEXT(context, angle::EntryPoint::GLBufferStorageMemEXT, + targetPacked, size, memoryPacked, offset)); + if (isCallValid) + { + context->bufferStorageMem(targetPacked, size, memoryPacked, offset); + } + ANGLE_CAPTURE_GL(BufferStorageMemEXT, isCallValid, context, targetPacked, size, + memoryPacked, offset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCreateMemoryObjectsEXT, + "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n, + (uintptr_t)memoryObjects); + + if (context) + { + MemoryObjectID *memoryObjectsPacked = PackParam<MemoryObjectID *>(memoryObjects); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCreateMemoryObjectsEXT(context, angle::EntryPoint::GLCreateMemoryObjectsEXT, n, + memoryObjectsPacked)); + if (isCallValid) + { + context->createMemoryObjects(n, memoryObjectsPacked); + } + ANGLE_CAPTURE_GL(CreateMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteMemoryObjectsEXT, + "context = %d, n = %d, memoryObjects = 0x%016" PRIxPTR "", CID(context), n, + (uintptr_t)memoryObjects); + + if (context) + { + const MemoryObjectID *memoryObjectsPacked = + PackParam<const MemoryObjectID *>(memoryObjects); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteMemoryObjectsEXT(context, angle::EntryPoint::GLDeleteMemoryObjectsEXT, n, + memoryObjectsPacked)); + if (isCallValid) + { + context->deleteMemoryObjects(n, memoryObjectsPacked); + } + ANGLE_CAPTURE_GL(DeleteMemoryObjectsEXT, isCallValid, context, n, memoryObjectsPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetMemoryObjectParameterivEXT, + "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname), + (uintptr_t)params); + + if (context) + { + MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetMemoryObjectParameterivEXT( + context, angle::EntryPoint::GLGetMemoryObjectParameterivEXT, + memoryObjectPacked, pname, params)); + if (isCallValid) + { + context->getMemoryObjectParameteriv(memoryObjectPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetMemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, + pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUnsignedBytevEXT, "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() || + ValidateGetUnsignedBytevEXT( + context, angle::EntryPoint::GLGetUnsignedBytevEXT, pname, data)); + if (isCallValid) + { + context->getUnsignedBytev(pname, data); + } + ANGLE_CAPTURE_GL(GetUnsignedBytevEXT, isCallValid, context, pname, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetUnsignedBytei_vEXT, + "context = %d, target = %s, index = %u, data = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, target), index, (uintptr_t)data); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetUnsignedBytei_vEXT(context, angle::EntryPoint::GLGetUnsignedBytei_vEXT, + target, index, data)); + if (isCallValid) + { + context->getUnsignedBytei_v(target, index, data); + } + ANGLE_CAPTURE_GL(GetUnsignedBytei_vEXT, isCallValid, context, target, index, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsMemoryObjectEXT(GLuint memoryObject) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsMemoryObjectEXT, "context = %d, memoryObject = %u", CID(context), + memoryObject); + + GLboolean returnValue; + if (context) + { + MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsMemoryObjectEXT(context, angle::EntryPoint::GLIsMemoryObjectEXT, + memoryObjectPacked)); + if (isCallValid) + { + returnValue = context->isMemoryObject(memoryObjectPacked); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsMemoryObjectEXT, isCallValid, context, memoryObjectPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsMemoryObjectEXT, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject, + GLenum pname, + const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMemoryObjectParameterivEXT, + "context = %d, memoryObject = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + memoryObject, GLenumToString(GLESEnum::MemoryObjectParameterName, pname), + (uintptr_t)params); + + if (context) + { + MemoryObjectID memoryObjectPacked = PackParam<MemoryObjectID>(memoryObject); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMemoryObjectParameterivEXT( + context, angle::EntryPoint::GLMemoryObjectParameterivEXT, + memoryObjectPacked, pname, params)); + if (isCallValid) + { + context->memoryObjectParameteriv(memoryObjectPacked, pname, params); + } + ANGLE_CAPTURE_GL(MemoryObjectParameterivEXT, isCallValid, context, memoryObjectPacked, + pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMem2DEXT, + "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " + "memory = %u, offset = %llu", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, memory, + static_cast<unsigned long long>(offset)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexStorageMem2DEXT( + context, angle::EntryPoint::GLTexStorageMem2DEXT, targetPacked, + levels, internalFormat, width, height, memoryPacked, offset)); + if (isCallValid) + { + context->texStorageMem2D(targetPacked, levels, internalFormat, width, height, + memoryPacked, offset); + } + ANGLE_CAPTURE_GL(TexStorageMem2DEXT, isCallValid, context, targetPacked, levels, + internalFormat, width, height, memoryPacked, offset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMem2DMultisampleEXT, + "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " + "fixedSampleLocations = %s, memory = %u, offset = %llu", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, + GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMem2DMultisampleEXT( + context, angle::EntryPoint::GLTexStorageMem2DMultisampleEXT, targetPacked, samples, + internalFormat, width, height, fixedSampleLocations, memoryPacked, offset)); + if (isCallValid) + { + context->texStorageMem2DMultisample(targetPacked, samples, internalFormat, width, + height, fixedSampleLocations, memoryPacked, offset); + } + ANGLE_CAPTURE_GL(TexStorageMem2DMultisampleEXT, isCallValid, context, targetPacked, samples, + internalFormat, width, height, fixedSampleLocations, memoryPacked, offset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMem3DEXT, + "context = %d, target = %s, levels = %d, internalFormat = %s, width = %d, height = %d, " + "depth = %d, memory = %u, offset = %llu", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth, + memory, static_cast<unsigned long long>(offset)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMem3DEXT(context, angle::EntryPoint::GLTexStorageMem3DEXT, + targetPacked, levels, internalFormat, width, height, depth, + memoryPacked, offset)); + if (isCallValid) + { + context->texStorageMem3D(targetPacked, levels, internalFormat, width, height, depth, + memoryPacked, offset); + } + ANGLE_CAPTURE_GL(TexStorageMem3DEXT, isCallValid, context, targetPacked, levels, + internalFormat, width, height, depth, memoryPacked, offset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorageMem3DMultisampleEXT, + "context = %d, target = %s, samples = %d, internalFormat = %s, width = %d, height = %d, " + "depth = %d, fixedSampleLocations = %s, memory = %u, offset = %llu", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), samples, + GLenumToString(GLESEnum::SizedInternalFormat, internalFormat), width, height, depth, + GLbooleanToString(fixedSampleLocations), memory, static_cast<unsigned long long>(offset)); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorageMem3DMultisampleEXT( + context, angle::EntryPoint::GLTexStorageMem3DMultisampleEXT, targetPacked, samples, + internalFormat, width, height, depth, fixedSampleLocations, memoryPacked, offset)); + if (isCallValid) + { + context->texStorageMem3DMultisample(targetPacked, samples, internalFormat, width, + height, depth, fixedSampleLocations, memoryPacked, + offset); + } + ANGLE_CAPTURE_GL(TexStorageMem3DMultisampleEXT, isCallValid, context, targetPacked, samples, + internalFormat, width, height, depth, fixedSampleLocations, memoryPacked, + offset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_memory_object_fd +void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLImportMemoryFdEXT, + "context = %d, memory = %u, size = %llu, handleType = %s, fd = %d", CID(context), memory, + static_cast<unsigned long long>(size), + GLenumToString(GLESEnum::ExternalHandleType, handleType), fd); + + if (context) + { + MemoryObjectID memoryPacked = PackParam<MemoryObjectID>(memory); + HandleType handleTypePacked = PackParam<HandleType>(handleType); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateImportMemoryFdEXT(context, angle::EntryPoint::GLImportMemoryFdEXT, + memoryPacked, size, handleTypePacked, fd)); + if (isCallValid) + { + context->importMemoryFd(memoryPacked, size, handleTypePacked, fd); + } + ANGLE_CAPTURE_GL(ImportMemoryFdEXT, isCallValid, context, memoryPacked, size, + handleTypePacked, fd); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_multi_draw_indirect +void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawArraysIndirectEXT, + "context = %d, mode = %s, indirect = 0x%016" PRIxPTR ", drawcount = %d, stride = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), (uintptr_t)indirect, + drawcount, stride); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiDrawArraysIndirectEXT( + context, angle::EntryPoint::GLMultiDrawArraysIndirectEXT, + modePacked, indirect, drawcount, stride)); + if (isCallValid) + { + context->multiDrawArraysIndirect(modePacked, indirect, drawcount, stride); + } + ANGLE_CAPTURE_GL(MultiDrawArraysIndirectEXT, isCallValid, context, modePacked, indirect, + drawcount, stride); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode, + GLenum type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMultiDrawElementsIndirectEXT, + "context = %d, mode = %s, type = %s, indirect = 0x%016" PRIxPTR + ", drawcount = %d, stride = %d", + CID(context), GLenumToString(GLESEnum::PrimitiveType, mode), + GLenumToString(GLESEnum::DrawElementsType, type), (uintptr_t)indirect, drawcount, stride); + + if (context) + { + PrimitiveMode modePacked = PackParam<PrimitiveMode>(mode); + DrawElementsType typePacked = PackParam<DrawElementsType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMultiDrawElementsIndirectEXT( + context, angle::EntryPoint::GLMultiDrawElementsIndirectEXT, + modePacked, typePacked, indirect, drawcount, stride)); + if (isCallValid) + { + context->multiDrawElementsIndirect(modePacked, typePacked, indirect, drawcount, stride); + } + ANGLE_CAPTURE_GL(MultiDrawElementsIndirectEXT, isCallValid, context, modePacked, typePacked, + indirect, drawcount, stride); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_multisampled_render_to_texture +void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLsizei samples) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTexture2DMultisampleEXT, + "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, " + "samples = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, samples); + + if (context) + { + TextureTarget textargetPacked = PackParam<TextureTarget>(textarget); + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferTexture2DMultisampleEXT( + context, angle::EntryPoint::GLFramebufferTexture2DMultisampleEXT, target, + attachment, textargetPacked, texturePacked, level, samples)); + if (isCallValid) + { + context->framebufferTexture2DMultisample(target, attachment, textargetPacked, + texturePacked, level, samples); + } + ANGLE_CAPTURE_GL(FramebufferTexture2DMultisampleEXT, isCallValid, context, target, + attachment, textargetPacked, texturePacked, level, samples); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRenderbufferStorageMultisampleEXT, + "context = %d, target = %s, samples = %d, internalformat = %s, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::RenderbufferTarget, target), samples, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateRenderbufferStorageMultisampleEXT( + context, angle::EntryPoint::GLRenderbufferStorageMultisampleEXT, + target, samples, internalformat, width, height)); + if (isCallValid) + { + context->renderbufferStorageMultisampleEXT(target, samples, internalformat, width, + height); + } + ANGLE_CAPTURE_GL(RenderbufferStorageMultisampleEXT, isCallValid, context, target, samples, + internalformat, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_multisampled_render_to_texture2 + +// GL_EXT_occlusion_query_boolean +// BeginQueryEXT is already defined. + +// DeleteQueriesEXT is already defined. + +// EndQueryEXT is already defined. + +// GenQueriesEXT is already defined. + +// GetQueryObjectuivEXT is already defined. + +// GetQueryivEXT is already defined. + +// IsQueryEXT is already defined. + +// GL_EXT_primitive_bounding_box +void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPrimitiveBoundingBoxEXT, + "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() || + ValidatePrimitiveBoundingBoxEXT(context, angle::EntryPoint::GLPrimitiveBoundingBoxEXT, + minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)); + if (isCallValid) + { + context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + } + ANGLE_CAPTURE_GL(PrimitiveBoundingBoxEXT, isCallValid, context, minX, minY, minZ, minW, + maxX, maxY, maxZ, maxW); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_protected_textures + +// GL_EXT_pvrtc_sRGB + +// GL_EXT_read_format_bgra + +// GL_EXT_robustness +GLenum GL_APIENTRY GL_GetGraphicsResetStatusEXT() +{ + Context *context = GetGlobalContext(); + EVENT(context, GLGetGraphicsResetStatusEXT, "context = %d", CID(context)); + + GLenum returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetGraphicsResetStatusEXT( + context, angle::EntryPoint::GLGetGraphicsResetStatusEXT)); + if (isCallValid) + { + returnValue = context->getGraphicsResetStatus(); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>(); + } + ANGLE_CAPTURE_GL(GetGraphicsResetStatusEXT, isCallValid, context, returnValue); + } + else + { + + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLGetGraphicsResetStatusEXT, GLenum>(); + } + return returnValue; +} + +void GL_APIENTRY GL_GetnUniformfvEXT(GLuint program, + GLint location, + GLsizei bufSize, + GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformfvEXT, + "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() || + ValidateGetnUniformfvEXT(context, angle::EntryPoint::GLGetnUniformfvEXT, programPacked, + locationPacked, bufSize, params)); + if (isCallValid) + { + context->getnUniformfv(programPacked, locationPacked, bufSize, params); + } + ANGLE_CAPTURE_GL(GetnUniformfvEXT, isCallValid, context, programPacked, locationPacked, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetnUniformivEXT, + "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() || + ValidateGetnUniformivEXT(context, angle::EntryPoint::GLGetnUniformivEXT, programPacked, + locationPacked, bufSize, params)); + if (isCallValid) + { + context->getnUniformiv(programPacked, locationPacked, bufSize, params); + } + ANGLE_CAPTURE_GL(GetnUniformivEXT, isCallValid, context, programPacked, locationPacked, + bufSize, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ReadnPixelsEXT(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLReadnPixelsEXT, + "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() || + ValidateReadnPixelsEXT(context, angle::EntryPoint::GLReadnPixelsEXT, x, + y, width, height, format, type, bufSize, data)); + if (isCallValid) + { + context->readnPixels(x, y, width, height, format, type, bufSize, data); + } + ANGLE_CAPTURE_GL(ReadnPixelsEXT, isCallValid, context, x, y, width, height, format, type, + bufSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_sRGB + +// GL_EXT_sRGB_write_control + +// GL_EXT_semaphore +void GL_APIENTRY GL_DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)semaphores); + + if (context) + { + const SemaphoreID *semaphoresPacked = PackParam<const SemaphoreID *>(semaphores); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteSemaphoresEXT(context, angle::EntryPoint::GLDeleteSemaphoresEXT, n, + semaphoresPacked)); + if (isCallValid) + { + context->deleteSemaphores(n, semaphoresPacked); + } + ANGLE_CAPTURE_GL(DeleteSemaphoresEXT, isCallValid, context, n, semaphoresPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenSemaphoresEXT(GLsizei n, GLuint *semaphores) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenSemaphoresEXT, "context = %d, n = %d, semaphores = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)semaphores); + + if (context) + { + SemaphoreID *semaphoresPacked = PackParam<SemaphoreID *>(semaphores); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGenSemaphoresEXT(context, angle::EntryPoint::GLGenSemaphoresEXT, + n, semaphoresPacked)); + if (isCallValid) + { + context->genSemaphores(n, semaphoresPacked); + } + ANGLE_CAPTURE_GL(GenSemaphoresEXT, isCallValid, context, n, semaphoresPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSemaphoreParameterui64vEXT, + "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetSemaphoreParameterui64vEXT( + context, angle::EntryPoint::GLGetSemaphoreParameterui64vEXT, + semaphorePacked, pname, params)); + if (isCallValid) + { + context->getSemaphoreParameterui64v(semaphorePacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, + pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsSemaphoreEXT(GLuint semaphore) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsSemaphoreEXT, "context = %d, semaphore = %u", CID(context), semaphore); + + GLboolean returnValue; + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsSemaphoreEXT(context, angle::EntryPoint::GLIsSemaphoreEXT, semaphorePacked)); + if (isCallValid) + { + returnValue = context->isSemaphore(semaphorePacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsSemaphoreEXT, isCallValid, context, semaphorePacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsSemaphoreEXT, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore, + GLenum pname, + const GLuint64 *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSemaphoreParameterui64vEXT, + "context = %d, semaphore = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + semaphore, GLenumToString(GLESEnum::SemaphoreParameterName, pname), (uintptr_t)params); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateSemaphoreParameterui64vEXT( + context, angle::EntryPoint::GLSemaphoreParameterui64vEXT, + semaphorePacked, pname, params)); + if (isCallValid) + { + context->semaphoreParameterui64v(semaphorePacked, pname, params); + } + ANGLE_CAPTURE_GL(SemaphoreParameterui64vEXT, isCallValid, context, semaphorePacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *dstLayouts) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSignalSemaphoreEXT, + "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR + ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", dstLayouts = 0x%016" PRIxPTR "", + CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, + (uintptr_t)textures, (uintptr_t)dstLayouts); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + const BufferID *buffersPacked = PackParam<const BufferID *>(buffers); + const TextureID *texturesPacked = PackParam<const TextureID *>(textures); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSignalSemaphoreEXT(context, angle::EntryPoint::GLSignalSemaphoreEXT, + semaphorePacked, numBufferBarriers, buffersPacked, + numTextureBarriers, texturesPacked, dstLayouts)); + if (isCallValid) + { + context->signalSemaphore(semaphorePacked, numBufferBarriers, buffersPacked, + numTextureBarriers, texturesPacked, dstLayouts); + } + ANGLE_CAPTURE_GL(SignalSemaphoreEXT, isCallValid, context, semaphorePacked, + numBufferBarriers, buffersPacked, numTextureBarriers, texturesPacked, + dstLayouts); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *srcLayouts) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLWaitSemaphoreEXT, + "context = %d, semaphore = %u, numBufferBarriers = %u, buffers = 0x%016" PRIxPTR + ", numTextureBarriers = %u, textures = 0x%016" PRIxPTR ", srcLayouts = 0x%016" PRIxPTR "", + CID(context), semaphore, numBufferBarriers, (uintptr_t)buffers, numTextureBarriers, + (uintptr_t)textures, (uintptr_t)srcLayouts); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + const BufferID *buffersPacked = PackParam<const BufferID *>(buffers); + const TextureID *texturesPacked = PackParam<const TextureID *>(textures); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateWaitSemaphoreEXT(context, angle::EntryPoint::GLWaitSemaphoreEXT, + semaphorePacked, numBufferBarriers, buffersPacked, + numTextureBarriers, texturesPacked, srcLayouts)); + if (isCallValid) + { + context->waitSemaphore(semaphorePacked, numBufferBarriers, buffersPacked, + numTextureBarriers, texturesPacked, srcLayouts); + } + ANGLE_CAPTURE_GL(WaitSemaphoreEXT, isCallValid, context, semaphorePacked, numBufferBarriers, + buffersPacked, numTextureBarriers, texturesPacked, srcLayouts); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GetUnsignedBytei_vEXT is already defined. + +// GetUnsignedBytevEXT is already defined. + +// GL_EXT_semaphore_fd +void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLImportSemaphoreFdEXT, "context = %d, semaphore = %u, handleType = %s, fd = %d", + CID(context), semaphore, GLenumToString(GLESEnum::ExternalHandleType, handleType), fd); + + if (context) + { + SemaphoreID semaphorePacked = PackParam<SemaphoreID>(semaphore); + HandleType handleTypePacked = PackParam<HandleType>(handleType); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateImportSemaphoreFdEXT(context, angle::EntryPoint::GLImportSemaphoreFdEXT, + semaphorePacked, handleTypePacked, fd)); + if (isCallValid) + { + context->importSemaphoreFd(semaphorePacked, handleTypePacked, fd); + } + ANGLE_CAPTURE_GL(ImportSemaphoreFdEXT, isCallValid, context, semaphorePacked, + handleTypePacked, fd); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_separate_shader_objects +void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLActiveShaderProgramEXT, "context = %d, pipeline = %u, program = %u", + CID(context), pipeline, program); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateActiveShaderProgramEXT(context, angle::EntryPoint::GLActiveShaderProgramEXT, + pipelinePacked, programPacked)); + if (isCallValid) + { + context->activeShaderProgram(pipelinePacked, programPacked); + } + ANGLE_CAPTURE_GL(ActiveShaderProgramEXT, isCallValid, context, pipelinePacked, + programPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBindProgramPipelineEXT(context, angle::EntryPoint::GLBindProgramPipelineEXT, + pipelinePacked)); + if (isCallValid) + { + context->bindProgramPipeline(pipelinePacked); + } + ANGLE_CAPTURE_GL(BindProgramPipelineEXT, isCallValid, context, pipelinePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCreateShaderProgramvEXT, + "context = %d, type = %s, count = %d, strings = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::ShaderType, type), count, (uintptr_t)strings); + + GLuint returnValue; + if (context) + { + ShaderType typePacked = PackParam<ShaderType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCreateShaderProgramvEXT(context, angle::EntryPoint::GLCreateShaderProgramvEXT, + typePacked, count, strings)); + if (isCallValid) + { + returnValue = context->createShaderProgramv(typePacked, count, strings); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>(); + } + ANGLE_CAPTURE_GL(CreateShaderProgramvEXT, isCallValid, context, typePacked, count, strings, + returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLCreateShaderProgramvEXT, GLuint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_DeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteProgramPipelinesEXT, + "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", CID(context), n, + (uintptr_t)pipelines); + + if (context) + { + const ProgramPipelineID *pipelinesPacked = PackParam<const ProgramPipelineID *>(pipelines); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteProgramPipelinesEXT( + context, angle::EntryPoint::GLDeleteProgramPipelinesEXT, n, pipelinesPacked)); + if (isCallValid) + { + context->deleteProgramPipelines(n, pipelinesPacked); + } + ANGLE_CAPTURE_GL(DeleteProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenProgramPipelinesEXT(GLsizei n, GLuint *pipelines) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenProgramPipelinesEXT, "context = %d, n = %d, pipelines = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)pipelines); + + if (context) + { + ProgramPipelineID *pipelinesPacked = PackParam<ProgramPipelineID *>(pipelines); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenProgramPipelinesEXT(context, angle::EntryPoint::GLGenProgramPipelinesEXT, n, + pipelinesPacked)); + if (isCallValid) + { + context->genProgramPipelines(n, pipelinesPacked); + } + ANGLE_CAPTURE_GL(GenProgramPipelinesEXT, isCallValid, context, n, pipelinesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramPipelineInfoLogEXT(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramPipelineInfoLogEXT, + "context = %d, pipeline = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", infoLog = 0x%016" PRIxPTR "", + CID(context), pipeline, bufSize, (uintptr_t)length, (uintptr_t)infoLog); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetProgramPipelineInfoLogEXT( + context, angle::EntryPoint::GLGetProgramPipelineInfoLogEXT, + pipelinePacked, bufSize, length, infoLog)); + if (isCallValid) + { + context->getProgramPipelineInfoLog(pipelinePacked, bufSize, length, infoLog); + } + ANGLE_CAPTURE_GL(GetProgramPipelineInfoLogEXT, isCallValid, context, pipelinePacked, + bufSize, length, infoLog); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramPipelineivEXT, + "context = %d, pipeline = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + pipeline, GLenumToString(GLESEnum::PipelineParameterName, pname), (uintptr_t)params); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramPipelineivEXT(context, angle::EntryPoint::GLGetProgramPipelineivEXT, + pipelinePacked, pname, params)); + if (isCallValid) + { + context->getProgramPipelineiv(pipelinePacked, pname, params); + } + ANGLE_CAPTURE_GL(GetProgramPipelineivEXT, isCallValid, context, pipelinePacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsProgramPipelineEXT(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), pipeline); + + GLboolean returnValue; + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsProgramPipelineEXT(context, angle::EntryPoint::GLIsProgramPipelineEXT, + pipelinePacked)); + if (isCallValid) + { + returnValue = context->isProgramPipeline(pipelinePacked); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsProgramPipelineEXT, isCallValid, context, pipelinePacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsProgramPipelineEXT, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramParameteriEXT, "context = %d, program = %u, pname = %s, value = %d", + CID(context), program, GLenumToString(GLESEnum::ProgramParameterPName, pname), value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramParameteriEXT(context, angle::EntryPoint::GLProgramParameteriEXT, + programPacked, pname, value)); + if (isCallValid) + { + context->programParameteri(programPacked, pname, value); + } + ANGLE_CAPTURE_GL(ProgramParameteriEXT, isCallValid, context, programPacked, pname, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1fEXT, "context = %d, program = %u, location = %d, v0 = %f", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1fEXT(context, angle::EntryPoint::GLProgramUniform1fEXT, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1f(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1fEXT, isCallValid, context, programPacked, locationPacked, + v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1fvEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1fvEXT(context, angle::EntryPoint::GLProgramUniform1fvEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1fvEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1iEXT, "context = %d, program = %u, location = %d, v0 = %d", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1iEXT(context, angle::EntryPoint::GLProgramUniform1iEXT, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1i(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1iEXT, isCallValid, context, programPacked, locationPacked, + v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1ivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1ivEXT(context, angle::EntryPoint::GLProgramUniform1ivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1ivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1uiEXT, "context = %d, program = %u, location = %d, v0 = %u", + CID(context), program, location, v0); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1uiEXT(context, angle::EntryPoint::GLProgramUniform1uiEXT, + programPacked, locationPacked, v0)); + if (isCallValid) + { + context->programUniform1ui(programPacked, locationPacked, v0); + } + ANGLE_CAPTURE_GL(ProgramUniform1uiEXT, isCallValid, context, programPacked, locationPacked, + v0); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform1uivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform1uivEXT(context, angle::EntryPoint::GLProgramUniform1uivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform1uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform1uivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2fEXT, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2fEXT(context, angle::EntryPoint::GLProgramUniform2fEXT, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2f(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2fEXT, isCallValid, context, programPacked, locationPacked, + v0, v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2fvEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2fvEXT(context, angle::EntryPoint::GLProgramUniform2fvEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2fvEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2iEXT, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2iEXT(context, angle::EntryPoint::GLProgramUniform2iEXT, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2i(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2iEXT, isCallValid, context, programPacked, locationPacked, + v0, v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2ivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2ivEXT(context, angle::EntryPoint::GLProgramUniform2ivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2ivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2uiEXT, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u", CID(context), program, + location, v0, v1); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2uiEXT(context, angle::EntryPoint::GLProgramUniform2uiEXT, + programPacked, locationPacked, v0, v1)); + if (isCallValid) + { + context->programUniform2ui(programPacked, locationPacked, v0, v1); + } + ANGLE_CAPTURE_GL(ProgramUniform2uiEXT, isCallValid, context, programPacked, locationPacked, + v0, v1); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform2uivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform2uivEXT(context, angle::EntryPoint::GLProgramUniform2uivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform2uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform2uivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3fEXT, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3fEXT(context, angle::EntryPoint::GLProgramUniform3fEXT, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3f(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3fEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3fvEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3fvEXT(context, angle::EntryPoint::GLProgramUniform3fvEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3fvEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3iEXT, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3iEXT(context, angle::EntryPoint::GLProgramUniform3iEXT, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3i(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3iEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3ivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3ivEXT(context, angle::EntryPoint::GLProgramUniform3ivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3ivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3uiEXT, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u", CID(context), + program, location, v0, v1, v2); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3uiEXT(context, angle::EntryPoint::GLProgramUniform3uiEXT, + programPacked, locationPacked, v0, v1, v2)); + if (isCallValid) + { + context->programUniform3ui(programPacked, locationPacked, v0, v1, v2); + } + ANGLE_CAPTURE_GL(ProgramUniform3uiEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform3uivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform3uivEXT(context, angle::EntryPoint::GLProgramUniform3uivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform3uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform3uivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program, + GLint location, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4fEXT, + "context = %d, program = %u, location = %d, v0 = %f, v1 = %f, v2 = %f, v3 = %f", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4fEXT(context, angle::EntryPoint::GLProgramUniform4fEXT, + programPacked, locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4f(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4fEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4fvEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4fvEXT(context, angle::EntryPoint::GLProgramUniform4fvEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4fv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4fvEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4iEXT, + "context = %d, program = %u, location = %d, v0 = %d, v1 = %d, v2 = %d, v3 = %d", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4iEXT(context, angle::EntryPoint::GLProgramUniform4iEXT, + programPacked, locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4i(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4iEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4ivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4ivEXT(context, angle::EntryPoint::GLProgramUniform4ivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4iv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4ivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4uiEXT, + "context = %d, program = %u, location = %d, v0 = %u, v1 = %u, v2 = %u, v3 = %u", + CID(context), program, location, v0, v1, v2, v3); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4uiEXT(context, angle::EntryPoint::GLProgramUniform4uiEXT, + programPacked, locationPacked, v0, v1, v2, v3)); + if (isCallValid) + { + context->programUniform4ui(programPacked, locationPacked, v0, v1, v2, v3); + } + ANGLE_CAPTURE_GL(ProgramUniform4uiEXT, isCallValid, context, programPacked, locationPacked, + v0, v1, v2, v3); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniform4uivEXT, + "context = %d, program = %u, location = %d, count = %d, value = 0x%016" PRIxPTR "", + CID(context), program, location, count, (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateProgramUniform4uivEXT(context, angle::EntryPoint::GLProgramUniform4uivEXT, + programPacked, locationPacked, count, value)); + if (isCallValid) + { + context->programUniform4uiv(programPacked, locationPacked, count, value); + } + ANGLE_CAPTURE_GL(ProgramUniform4uivEXT, isCallValid, context, programPacked, locationPacked, + count, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix2fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2x3fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2x3fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix2x3fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2x3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2x3fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix2x4fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix2x4fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix2x4fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix2x4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix2x4fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix3fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3x2fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3x2fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix3x2fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3x2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3x2fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix3x4fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix3x4fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix3x4fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix3x4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix3x4fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix4fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4x2fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4x2fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix4x2fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4x2fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4x2fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramUniformMatrix4x3fvEXT, + "context = %d, program = %u, location = %d, count = %d, transpose = %s, value = " + "0x%016" PRIxPTR "", + CID(context), program, location, count, GLbooleanToString(transpose), (uintptr_t)value); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + UniformLocation locationPacked = PackParam<UniformLocation>(location); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramUniformMatrix4x3fvEXT( + context, angle::EntryPoint::GLProgramUniformMatrix4x3fvEXT, + programPacked, locationPacked, count, transpose, value)); + if (isCallValid) + { + context->programUniformMatrix4x3fv(programPacked, locationPacked, count, transpose, + value); + } + ANGLE_CAPTURE_GL(ProgramUniformMatrix4x3fvEXT, isCallValid, context, programPacked, + locationPacked, count, transpose, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUseProgramStagesEXT, "context = %d, pipeline = %u, stages = %s, program = %u", + CID(context), pipeline, GLbitfieldToString(GLESEnum::UseProgramStageMask, stages).c_str(), + program); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateUseProgramStagesEXT(context, angle::EntryPoint::GLUseProgramStagesEXT, + pipelinePacked, stages, programPacked)); + if (isCallValid) + { + context->useProgramStages(pipelinePacked, stages, programPacked); + } + ANGLE_CAPTURE_GL(UseProgramStagesEXT, isCallValid, context, pipelinePacked, stages, + programPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLValidateProgramPipelineEXT, "context = %d, pipeline = %u", CID(context), + pipeline); + + if (context) + { + ProgramPipelineID pipelinePacked = PackParam<ProgramPipelineID>(pipeline); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateValidateProgramPipelineEXT( + context, angle::EntryPoint::GLValidateProgramPipelineEXT, pipelinePacked)); + if (isCallValid) + { + context->validateProgramPipeline(pipelinePacked); + } + ANGLE_CAPTURE_GL(ValidateProgramPipelineEXT, isCallValid, context, pipelinePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_shader_framebuffer_fetch + +// GL_EXT_shader_framebuffer_fetch_non_coherent +void GL_APIENTRY GL_FramebufferFetchBarrierEXT() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferFetchBarrierEXT, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFramebufferFetchBarrierEXT( + context, angle::EntryPoint::GLFramebufferFetchBarrierEXT)); + if (isCallValid) + { + context->framebufferFetchBarrier(); + } + ANGLE_CAPTURE_GL(FramebufferFetchBarrierEXT, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_shader_io_blocks + +// GL_EXT_shader_non_constant_global_initializers + +// GL_EXT_shader_texture_lod + +// GL_EXT_shadow_samplers + +// GL_EXT_tessellation_shader +void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPatchParameteriEXT, "context = %d, pname = %s, value = %d", CID(context), + GLenumToString(GLESEnum::PatchParameterName, pname), value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidatePatchParameteriEXT( + context, angle::EntryPoint::GLPatchParameteriEXT, pname, value)); + if (isCallValid) + { + context->patchParameteri(pname, value); + } + ANGLE_CAPTURE_GL(PatchParameteriEXT, isCallValid, context, pname, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_texture_border_clamp +void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIivEXT, + "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() || + ValidateGetSamplerParameterIivEXT( + context, angle::EntryPoint::GLGetSamplerParameterIivEXT, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIivEXT, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIuivEXT, + "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() || + ValidateGetSamplerParameterIuivEXT( + context, angle::EntryPoint::GLGetSamplerParameterIuivEXT, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIuiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIivEXT, + "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() || + ValidateGetTexParameterIivEXT(context, angle::EntryPoint::GLGetTexParameterIivEXT, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIivEXT, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIuivEXT, + "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() || + ValidateGetTexParameterIuivEXT(context, angle::EntryPoint::GLGetTexParameterIuivEXT, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIuivEXT, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIivEXT, + "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() || + ValidateSamplerParameterIivEXT(context, angle::EntryPoint::GLSamplerParameterIivEXT, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIivEXT, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIuivEXT, + "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() || + ValidateSamplerParameterIuivEXT(context, angle::EntryPoint::GLSamplerParameterIuivEXT, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIuiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIuivEXT, isCallValid, context, samplerPacked, pname, + param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, GLenum pname, const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIivEXT, + "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() || + ValidateTexParameterIivEXT(context, angle::EntryPoint::GLTexParameterIivEXT, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIivEXT, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIuivEXT, + "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() || + ValidateTexParameterIuivEXT(context, angle::EntryPoint::GLTexParameterIuivEXT, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIuivEXT, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_texture_buffer +void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBufferEXT, "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() || + ValidateTexBufferEXT(context, angle::EntryPoint::GLTexBufferEXT, + targetPacked, internalformat, bufferPacked)); + if (isCallValid) + { + context->texBuffer(targetPacked, internalformat, bufferPacked); + } + ANGLE_CAPTURE_GL(TexBufferEXT, isCallValid, context, targetPacked, internalformat, + bufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBufferRangeEXT, + "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() || + ValidateTexBufferRangeEXT(context, angle::EntryPoint::GLTexBufferRangeEXT, + targetPacked, internalformat, bufferPacked, offset, size)); + if (isCallValid) + { + context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size); + } + ANGLE_CAPTURE_GL(TexBufferRangeEXT, isCallValid, context, targetPacked, internalformat, + bufferPacked, offset, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_texture_compression_bptc + +// GL_EXT_texture_compression_dxt1 + +// GL_EXT_texture_compression_rgtc + +// GL_EXT_texture_compression_s3tc + +// GL_EXT_texture_compression_s3tc_srgb + +// GL_EXT_texture_cube_map_array + +// GL_EXT_texture_filter_anisotropic + +// GL_EXT_texture_format_BGRA8888 + +// GL_EXT_texture_format_sRGB_override + +// GL_EXT_texture_norm16 + +// GL_EXT_texture_rg + +// GL_EXT_texture_sRGB_R8 + +// GL_EXT_texture_sRGB_RG8 + +// GL_EXT_texture_sRGB_decode + +// GL_EXT_texture_storage +void GL_APIENTRY GL_TexStorage1DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage1DEXT, + "context = %d, target = %s, levels = %d, internalformat = %s, width = %d", CID(context), + GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateTexStorage1DEXT(context, angle::EntryPoint::GLTexStorage1DEXT, + target, levels, internalformat, width)); + if (isCallValid) + { + context->texStorage1D(target, levels, internalformat, width); + } + ANGLE_CAPTURE_GL(TexStorage1DEXT, isCallValid, context, target, levels, internalformat, + width); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorage2DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage2DEXT, + "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage2DEXT(context, angle::EntryPoint::GLTexStorage2DEXT, targetPacked, + levels, internalformat, width, height)); + if (isCallValid) + { + context->texStorage2D(targetPacked, levels, internalformat, width, height); + } + ANGLE_CAPTURE_GL(TexStorage2DEXT, isCallValid, context, targetPacked, levels, + internalformat, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexStorage3DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage3DEXT, + "context = %d, target = %s, levels = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), levels, + GLenumToString(GLESEnum::SizedInternalFormat, internalformat), width, height, depth); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexStorage3DEXT(context, angle::EntryPoint::GLTexStorage3DEXT, targetPacked, + levels, internalformat, width, height, depth)); + if (isCallValid) + { + context->texStorage3D(targetPacked, levels, internalformat, width, height, depth); + } + ANGLE_CAPTURE_GL(TexStorage3DEXT, isCallValid, context, targetPacked, levels, + internalformat, width, height, depth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_EXT_texture_type_2_10_10_10_REV + +// GL_EXT_unpack_subimage + +// GL_IMG_texture_compression_pvrtc + +// GL_IMG_texture_compression_pvrtc2 + +// GL_KHR_blend_equation_advanced +void GL_APIENTRY GL_BlendBarrierKHR() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendBarrierKHR, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBlendBarrierKHR(context, angle::EntryPoint::GLBlendBarrierKHR)); + if (isCallValid) + { + context->blendBarrier(); + } + ANGLE_CAPTURE_GL(BlendBarrierKHR, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_KHR_debug +void GL_APIENTRY GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageCallbackKHR, + "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() || + ValidateDebugMessageCallbackKHR(context, angle::EntryPoint::GLDebugMessageCallbackKHR, + callback, userParam)); + if (isCallValid) + { + context->debugMessageCallback(callback, userParam); + } + ANGLE_CAPTURE_GL(DebugMessageCallbackKHR, isCallValid, context, callback, userParam); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageControlKHR, + "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() || + ValidateDebugMessageControlKHR(context, angle::EntryPoint::GLDebugMessageControlKHR, + source, type, severity, count, ids, enabled)); + if (isCallValid) + { + context->debugMessageControl(source, type, severity, count, ids, enabled); + } + ANGLE_CAPTURE_GL(DebugMessageControlKHR, isCallValid, context, source, type, severity, + count, ids, enabled); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDebugMessageInsertKHR, + "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() || + ValidateDebugMessageInsertKHR(context, angle::EntryPoint::GLDebugMessageInsertKHR, + source, type, id, severity, length, buf)); + if (isCallValid) + { + context->debugMessageInsert(source, type, id, severity, length, buf); + } + ANGLE_CAPTURE_GL(DebugMessageInsertKHR, isCallValid, context, source, type, id, severity, + length, buf); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLuint GL_APIENTRY GL_GetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetDebugMessageLogKHR, + "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() || + ValidateGetDebugMessageLogKHR( + context, angle::EntryPoint::GLGetDebugMessageLogKHR, 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::GLGetDebugMessageLogKHR, GLuint>(); + } + ANGLE_CAPTURE_GL(GetDebugMessageLogKHR, isCallValid, context, count, bufSize, sources, + types, ids, severities, lengths, messageLog, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLGetDebugMessageLogKHR, GLuint>(); + } + return returnValue; +} + +void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetObjectLabelKHR, + "context = %d, identifier = %s, name = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", label = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, identifier), name, bufSize, + (uintptr_t)length, (uintptr_t)label); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetObjectLabelKHR(context, angle::EntryPoint::GLGetObjectLabelKHR, identifier, + name, bufSize, length, label)); + if (isCallValid) + { + context->getObjectLabel(identifier, name, bufSize, length, label); + } + ANGLE_CAPTURE_GL(GetObjectLabelKHR, isCallValid, context, identifier, name, bufSize, length, + label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetObjectPtrLabelKHR, + "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() || + ValidateGetObjectPtrLabelKHR(context, angle::EntryPoint::GLGetObjectPtrLabelKHR, ptr, + bufSize, length, label)); + if (isCallValid) + { + context->getObjectPtrLabel(ptr, bufSize, length, label); + } + ANGLE_CAPTURE_GL(GetObjectPtrLabelKHR, isCallValid, context, ptr, bufSize, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetPointervKHR, "context = %d, pname = %s, params = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetPointervKHR(context, angle::EntryPoint::GLGetPointervKHR, pname, params)); + if (isCallValid) + { + context->getPointerv(pname, params); + } + ANGLE_CAPTURE_GL(GetPointervKHR, isCallValid, context, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLObjectLabelKHR, + "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() || + ValidateObjectLabelKHR(context, angle::EntryPoint::GLObjectLabelKHR, + identifier, name, length, label)); + if (isCallValid) + { + context->objectLabel(identifier, name, length, label); + } + ANGLE_CAPTURE_GL(ObjectLabelKHR, isCallValid, context, identifier, name, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLObjectPtrLabelKHR, + "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() || + ValidateObjectPtrLabelKHR(context, angle::EntryPoint::GLObjectPtrLabelKHR, ptr, length, + label)); + if (isCallValid) + { + context->objectPtrLabel(ptr, length, label); + } + ANGLE_CAPTURE_GL(ObjectPtrLabelKHR, isCallValid, context, ptr, length, label); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PopDebugGroupKHR() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPopDebugGroupKHR, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePopDebugGroupKHR(context, angle::EntryPoint::GLPopDebugGroupKHR)); + if (isCallValid) + { + context->popDebugGroup(); + } + ANGLE_CAPTURE_GL(PopDebugGroupKHR, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPushDebugGroupKHR, + "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() || + ValidatePushDebugGroupKHR(context, angle::EntryPoint::GLPushDebugGroupKHR, source, id, + length, message)); + if (isCallValid) + { + context->pushDebugGroup(source, id, length, message); + } + ANGLE_CAPTURE_GL(PushDebugGroupKHR, isCallValid, context, source, id, length, message); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_KHR_no_error + +// GL_KHR_parallel_shader_compile +void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMaxShaderCompilerThreadsKHR, "context = %d, count = %u", CID(context), count); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMaxShaderCompilerThreadsKHR( + context, angle::EntryPoint::GLMaxShaderCompilerThreadsKHR, count)); + if (isCallValid) + { + context->maxShaderCompilerThreads(count); + } + ANGLE_CAPTURE_GL(MaxShaderCompilerThreadsKHR, isCallValid, context, count); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_KHR_robust_buffer_access_behavior + +// GL_KHR_texture_compression_astc_hdr + +// GL_KHR_texture_compression_astc_ldr + +// GL_KHR_texture_compression_astc_sliced_3d + +// GL_MESA_framebuffer_flip_y +void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, GLenum pname, GLint param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferParameteriMESA, "context = %d, target = %s, pname = %s, param = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferParameterName, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFramebufferParameteriMESA( + context, angle::EntryPoint::GLFramebufferParameteriMESA, target, pname, param)); + if (isCallValid) + { + context->framebufferParameteriMESA(target, pname, param); + } + ANGLE_CAPTURE_GL(FramebufferParameteriMESA, isCallValid, context, target, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFramebufferParameterivMESA(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFramebufferParameterivMESA, + "context = %d, target = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachmentParameterName, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetFramebufferParameterivMESA( + context, angle::EntryPoint::GLGetFramebufferParameterivMESA, target, + pname, params)); + if (isCallValid) + { + context->getFramebufferParameterivMESA(target, pname, params); + } + ANGLE_CAPTURE_GL(GetFramebufferParameterivMESA, isCallValid, context, target, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_NV_fence +void GL_APIENTRY GL_DeleteFencesNV(GLsizei n, const GLuint *fences) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)fences); + + if (context) + { + const FenceNVID *fencesPacked = PackParam<const FenceNVID *>(fences); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteFencesNV(context, angle::EntryPoint::GLDeleteFencesNV, n, fencesPacked)); + if (isCallValid) + { + context->deleteFencesNV(n, fencesPacked); + } + ANGLE_CAPTURE_GL(DeleteFencesNV, isCallValid, context, n, fencesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FinishFenceNV(GLuint fence) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFinishFenceNV, "context = %d, fence = %u", CID(context), fence); + + if (context) + { + FenceNVID fencePacked = PackParam<FenceNVID>(fence); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateFinishFenceNV(context, angle::EntryPoint::GLFinishFenceNV, fencePacked)); + if (isCallValid) + { + context->finishFenceNV(fencePacked); + } + ANGLE_CAPTURE_GL(FinishFenceNV, isCallValid, context, fencePacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenFencesNV(GLsizei n, GLuint *fences) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenFencesNV, "context = %d, n = %d, fences = 0x%016" PRIxPTR "", CID(context), + n, (uintptr_t)fences); + + if (context) + { + FenceNVID *fencesPacked = PackParam<FenceNVID *>(fences); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGenFencesNV(context, angle::EntryPoint::GLGenFencesNV, n, fencesPacked)); + if (isCallValid) + { + context->genFencesNV(n, fencesPacked); + } + ANGLE_CAPTURE_GL(GenFencesNV, isCallValid, context, n, fencesPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFenceivNV, + "context = %d, fence = %u, pname = %s, params = 0x%016" PRIxPTR "", CID(context), fence, + GLenumToString(GLESEnum::AllEnums, pname), (uintptr_t)params); + + if (context) + { + FenceNVID fencePacked = PackParam<FenceNVID>(fence); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetFenceivNV(context, angle::EntryPoint::GLGetFenceivNV, + fencePacked, pname, params)); + if (isCallValid) + { + context->getFenceivNV(fencePacked, pname, params); + } + ANGLE_CAPTURE_GL(GetFenceivNV, isCallValid, context, fencePacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsFenceNV(GLuint fence) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsFenceNV, "context = %d, fence = %u", CID(context), fence); + + GLboolean returnValue; + if (context) + { + FenceNVID fencePacked = PackParam<FenceNVID>(fence); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsFenceNV(context, angle::EntryPoint::GLIsFenceNV, fencePacked)); + if (isCallValid) + { + returnValue = context->isFenceNV(fencePacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsFenceNV, isCallValid, context, fencePacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFenceNV, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSetFenceNV, "context = %d, fence = %u, condition = %s", CID(context), fence, + GLenumToString(GLESEnum::AllEnums, condition)); + + if (context) + { + FenceNVID fencePacked = PackParam<FenceNVID>(fence); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateSetFenceNV(context, angle::EntryPoint::GLSetFenceNV, fencePacked, condition)); + if (isCallValid) + { + context->setFenceNV(fencePacked, condition); + } + ANGLE_CAPTURE_GL(SetFenceNV, isCallValid, context, fencePacked, condition); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTestFenceNV, "context = %d, fence = %u", CID(context), fence); + + GLboolean returnValue; + if (context) + { + FenceNVID fencePacked = PackParam<FenceNVID>(fence); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTestFenceNV(context, angle::EntryPoint::GLTestFenceNV, fencePacked)); + if (isCallValid) + { + returnValue = context->testFenceNV(fencePacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>(); + } + ANGLE_CAPTURE_GL(TestFenceNV, isCallValid, context, fencePacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLTestFenceNV, GLboolean>(); + } + return returnValue; +} + +// GL_NV_framebuffer_blit +void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlitFramebufferNV, + "context = %d, srcX0 = %d, srcY0 = %d, srcX1 = %d, srcY1 = %d, dstX0 = %d, dstY0 = %d, " + "dstX1 = %d, dstY1 = %d, mask = %s, filter = %s", + CID(context), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, + GLbitfieldToString(GLESEnum::ClearBufferMask, mask).c_str(), + GLenumToString(GLESEnum::BlitFramebufferFilter, filter)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBlitFramebufferNV( + context, angle::EntryPoint::GLBlitFramebufferNV, srcX0, srcY0, + srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter)); + if (isCallValid) + { + context->blitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); + } + ANGLE_CAPTURE_GL(BlitFramebufferNV, isCallValid, context, srcX0, srcY0, srcX1, srcY1, dstX0, + dstY0, dstX1, dstY1, mask, filter); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_NV_pixel_buffer_object + +// GL_NV_read_depth + +// GL_NV_read_depth_stencil + +// GL_NV_read_stencil + +// GL_NV_robustness_video_memory_purge + +// GL_NV_shader_noperspective_interpolation + +// GL_OES_EGL_image +void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEGLImageTargetRenderbufferStorageOES, + "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateEGLImageTargetRenderbufferStorageOES( + context, angle::EntryPoint::GLEGLImageTargetRenderbufferStorageOES, + target, image)); + if (isCallValid) + { + context->eGLImageTargetRenderbufferStorage(target, image); + } + ANGLE_CAPTURE_GL(EGLImageTargetRenderbufferStorageOES, isCallValid, context, target, image); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEGLImageTargetTexture2DOES, + "context = %d, target = %s, image = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, target), (uintptr_t)image); + + if (context) + { + TextureType targetPacked = PackParam<TextureType>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEGLImageTargetTexture2DOES( + context, angle::EntryPoint::GLEGLImageTargetTexture2DOES, targetPacked, image)); + if (isCallValid) + { + context->eGLImageTargetTexture2D(targetPacked, image); + } + ANGLE_CAPTURE_GL(EGLImageTargetTexture2DOES, isCallValid, context, targetPacked, image); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_EGL_image_external + +// GL_OES_EGL_image_external_essl3 + +// GL_OES_compressed_ETC1_RGB8_texture + +// GL_OES_compressed_paletted_texture + +// GL_OES_copy_image +void GL_APIENTRY GL_CopyImageSubDataOES(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, GLCopyImageSubDataOES, + "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::CopyBufferSubDataTarget, srcTarget), + srcLevel, srcX, srcY, srcZ, dstName, + GLenumToString(GLESEnum::CopyBufferSubDataTarget, dstTarget), dstLevel, dstX, dstY, dstZ, + srcWidth, srcHeight, srcDepth); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCopyImageSubDataOES( + context, angle::EntryPoint::GLCopyImageSubDataOES, 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(CopyImageSubDataOES, isCallValid, context, srcName, srcTarget, srcLevel, + srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, + srcHeight, srcDepth); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_depth24 + +// GL_OES_depth32 + +// GL_OES_depth_texture + +// GL_OES_draw_buffers_indexed +void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationSeparateiOES, + "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() || + ValidateBlendEquationSeparateiOES( + context, angle::EntryPoint::GLBlendEquationSeparateiOES, buf, modeRGB, modeAlpha)); + if (isCallValid) + { + context->blendEquationSeparatei(buf, modeRGB, modeAlpha); + } + ANGLE_CAPTURE_GL(BlendEquationSeparateiOES, isCallValid, context, buf, modeRGB, modeAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendEquationiOES, "context = %d, buf = %u, mode = %s", CID(context), buf, + GLenumToString(GLESEnum::BlendEquationModeEXT, mode)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateBlendEquationiOES(context, angle::EntryPoint::GLBlendEquationiOES, buf, mode)); + if (isCallValid) + { + context->blendEquationi(buf, mode); + } + ANGLE_CAPTURE_GL(BlendEquationiOES, isCallValid, context, buf, mode); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY +GL_BlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFuncSeparateiOES, + "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() || + ValidateBlendFuncSeparateiOES(context, angle::EntryPoint::GLBlendFuncSeparateiOES, buf, + srcRGB, dstRGB, srcAlpha, dstAlpha)); + if (isCallValid) + { + context->blendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); + } + ANGLE_CAPTURE_GL(BlendFuncSeparateiOES, isCallValid, context, buf, srcRGB, dstRGB, srcAlpha, + dstAlpha); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBlendFunciOES, "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() || + ValidateBlendFunciOES(context, angle::EntryPoint::GLBlendFunciOES, buf, src, dst)); + if (isCallValid) + { + context->blendFunci(buf, src, dst); + } + ANGLE_CAPTURE_GL(BlendFunciOES, isCallValid, context, buf, src, dst); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLColorMaskiOES, "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() || + ValidateColorMaskiOES(context, angle::EntryPoint::GLColorMaskiOES, index, r, g, b, a)); + if (isCallValid) + { + context->colorMaski(index, r, g, b, a); + } + ANGLE_CAPTURE_GL(ColorMaskiOES, isCallValid, context, index, r, g, b, a); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDisableiOES, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDisableiOES(context, angle::EntryPoint::GLDisableiOES, target, index)); + if (isCallValid) + { + context->disablei(target, index); + } + ANGLE_CAPTURE_GL(DisableiOES, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLEnableiOES, "context = %d, target = %s, index = %u", CID(context), + GLenumToString(GLESEnum::EnableCap, target), index); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateEnableiOES(context, angle::EntryPoint::GLEnableiOES, target, index)); + if (isCallValid) + { + context->enablei(target, index); + } + ANGLE_CAPTURE_GL(EnableiOES, isCallValid, context, target, index); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsEnablediOES, "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() || + ValidateIsEnablediOES(context, angle::EntryPoint::GLIsEnablediOES, target, index)); + if (isCallValid) + { + returnValue = context->isEnabledi(target, index); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsEnablediOES, isCallValid, context, target, index, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsEnablediOES, GLboolean>(); + } + return returnValue; +} + +// GL_OES_draw_elements_base_vertex +void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsBaseVertexOES, + "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() || + ValidateDrawElementsBaseVertexOES( + context, angle::EntryPoint::GLDrawElementsBaseVertexOES, modePacked, + count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawElementsBaseVertex(modePacked, count, typePacked, indices, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsBaseVertexOES, isCallValid, context, modePacked, count, + typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawElementsInstancedBaseVertexOES, + "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() || + ValidateDrawElementsInstancedBaseVertexOES( + context, angle::EntryPoint::GLDrawElementsInstancedBaseVertexOES, + modePacked, count, typePacked, indices, instancecount, basevertex)); + if (isCallValid) + { + context->drawElementsInstancedBaseVertex(modePacked, count, typePacked, indices, + instancecount, basevertex); + } + ANGLE_CAPTURE_GL(DrawElementsInstancedBaseVertexOES, isCallValid, context, modePacked, + count, typePacked, indices, instancecount, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawRangeElementsBaseVertexOES, + "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() || + ValidateDrawRangeElementsBaseVertexOES( + context, angle::EntryPoint::GLDrawRangeElementsBaseVertexOES, + modePacked, start, end, count, typePacked, indices, basevertex)); + if (isCallValid) + { + context->drawRangeElementsBaseVertex(modePacked, start, end, count, typePacked, indices, + basevertex); + } + ANGLE_CAPTURE_GL(DrawRangeElementsBaseVertexOES, isCallValid, context, modePacked, start, + end, count, typePacked, indices, basevertex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// MultiDrawElementsBaseVertexEXT is already defined. + +// GL_OES_draw_texture +void GL_APIENTRY GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexfOES, "context = %d, x = %f, y = %f, z = %f, width = %f, height = %f", + CID(context), x, y, z, width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawTexfOES(context, angle::EntryPoint::GLDrawTexfOES, x, y, z, + width, height)); + if (isCallValid) + { + context->drawTexf(x, y, z, width, height); + } + ANGLE_CAPTURE_GL(DrawTexfOES, isCallValid, context, x, y, z, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexfvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)coords); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawTexfvOES(context, angle::EntryPoint::GLDrawTexfvOES, coords)); + if (isCallValid) + { + context->drawTexfv(coords); + } + ANGLE_CAPTURE_GL(DrawTexfvOES, isCallValid, context, coords); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexiOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d", + CID(context), x, y, z, width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawTexiOES(context, angle::EntryPoint::GLDrawTexiOES, x, y, z, + width, height)); + if (isCallValid) + { + context->drawTexi(x, y, z, width, height); + } + ANGLE_CAPTURE_GL(DrawTexiOES, isCallValid, context, x, y, z, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexivOES(const GLint *coords) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexivOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)coords); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawTexivOES(context, angle::EntryPoint::GLDrawTexivOES, coords)); + if (isCallValid) + { + context->drawTexiv(coords); + } + ANGLE_CAPTURE_GL(DrawTexivOES, isCallValid, context, coords); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexsOES, "context = %d, x = %d, y = %d, z = %d, width = %d, height = %d", + CID(context), x, y, z, width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawTexsOES(context, angle::EntryPoint::GLDrawTexsOES, x, y, z, + width, height)); + if (isCallValid) + { + context->drawTexs(x, y, z, width, height); + } + ANGLE_CAPTURE_GL(DrawTexsOES, isCallValid, context, x, y, z, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexsvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)coords); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawTexsvOES(context, angle::EntryPoint::GLDrawTexsvOES, coords)); + if (isCallValid) + { + context->drawTexsv(coords); + } + ANGLE_CAPTURE_GL(DrawTexsvOES, isCallValid, context, coords); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexxOES, + "context = %d, x = 0x%X, y = 0x%X, z = 0x%X, width = 0x%X, height = 0x%X", CID(context), + x, y, z, width, height); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateDrawTexxOES(context, angle::EntryPoint::GLDrawTexxOES, x, y, z, + width, height)); + if (isCallValid) + { + context->drawTexx(x, y, z, width, height); + } + ANGLE_CAPTURE_GL(DrawTexxOES, isCallValid, context, x, y, z, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDrawTexxvOES, "context = %d, coords = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)coords); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDrawTexxvOES(context, angle::EntryPoint::GLDrawTexxvOES, coords)); + if (isCallValid) + { + context->drawTexxv(coords); + } + ANGLE_CAPTURE_GL(DrawTexxvOES, isCallValid, context, coords); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_element_index_uint + +// GL_OES_fbo_render_mipmap + +// GL_OES_framebuffer_object +void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindFramebufferOES, "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() || + ValidateBindFramebufferOES(context, angle::EntryPoint::GLBindFramebufferOES, target, + framebufferPacked)); + if (isCallValid) + { + context->bindFramebuffer(target, framebufferPacked); + } + ANGLE_CAPTURE_GL(BindFramebufferOES, isCallValid, context, target, framebufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindRenderbufferOES, "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() || + ValidateBindRenderbufferOES(context, angle::EntryPoint::GLBindRenderbufferOES, target, + renderbufferPacked)); + if (isCallValid) + { + context->bindRenderbuffer(target, renderbufferPacked); + } + ANGLE_CAPTURE_GL(BindRenderbufferOES, isCallValid, context, target, renderbufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCheckFramebufferStatusOES, "context = %d, target = %s", CID(context), + GLenumToString(GLESEnum::FramebufferTarget, target)); + + GLenum returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCheckFramebufferStatusOES( + context, angle::EntryPoint::GLCheckFramebufferStatusOES, target)); + if (isCallValid) + { + returnValue = context->checkFramebufferStatus(target); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>(); + } + ANGLE_CAPTURE_GL(CheckFramebufferStatusOES, isCallValid, context, target, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLCheckFramebufferStatusOES, GLenum>(); + } + return returnValue; +} + +void GL_APIENTRY GL_DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteFramebuffersOES, + "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() || + ValidateDeleteFramebuffersOES(context, angle::EntryPoint::GLDeleteFramebuffersOES, n, + framebuffersPacked)); + if (isCallValid) + { + context->deleteFramebuffers(n, framebuffersPacked); + } + ANGLE_CAPTURE_GL(DeleteFramebuffersOES, isCallValid, context, n, framebuffersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteRenderbuffersOES, + "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() || + ValidateDeleteRenderbuffersOES(context, angle::EntryPoint::GLDeleteRenderbuffersOES, n, + renderbuffersPacked)); + if (isCallValid) + { + context->deleteRenderbuffers(n, renderbuffersPacked); + } + ANGLE_CAPTURE_GL(DeleteRenderbuffersOES, isCallValid, context, n, renderbuffersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferRenderbufferOES, + "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() || + ValidateFramebufferRenderbufferOES( + context, angle::EntryPoint::GLFramebufferRenderbufferOES, target, + attachment, renderbuffertarget, renderbufferPacked)); + if (isCallValid) + { + context->framebufferRenderbuffer(target, attachment, renderbuffertarget, + renderbufferPacked); + } + ANGLE_CAPTURE_GL(FramebufferRenderbufferOES, isCallValid, context, target, attachment, + renderbuffertarget, renderbufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTexture2DOES, + "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() || + ValidateFramebufferTexture2DOES( + context, angle::EntryPoint::GLFramebufferTexture2DOES, target, + attachment, textargetPacked, texturePacked, level)); + if (isCallValid) + { + context->framebufferTexture2D(target, attachment, textargetPacked, texturePacked, + level); + } + ANGLE_CAPTURE_GL(FramebufferTexture2DOES, isCallValid, context, target, attachment, + textargetPacked, texturePacked, level); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenFramebuffersOES(GLsizei n, GLuint *framebuffers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenFramebuffersOES, "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() || + ValidateGenFramebuffersOES(context, angle::EntryPoint::GLGenFramebuffersOES, n, + framebuffersPacked)); + if (isCallValid) + { + context->genFramebuffers(n, framebuffersPacked); + } + ANGLE_CAPTURE_GL(GenFramebuffersOES, isCallValid, context, n, framebuffersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenRenderbuffersOES, "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() || + ValidateGenRenderbuffersOES(context, angle::EntryPoint::GLGenRenderbuffersOES, n, + renderbuffersPacked)); + if (isCallValid) + { + context->genRenderbuffers(n, renderbuffersPacked); + } + ANGLE_CAPTURE_GL(GenRenderbuffersOES, isCallValid, context, n, renderbuffersPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenerateMipmapOES(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenerateMipmapOES, "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() || + ValidateGenerateMipmapOES( + context, angle::EntryPoint::GLGenerateMipmapOES, targetPacked)); + if (isCallValid) + { + context->generateMipmap(targetPacked); + } + ANGLE_CAPTURE_GL(GenerateMipmapOES, isCallValid, context, targetPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target, + GLenum attachment, + GLenum pname, + GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetFramebufferAttachmentParameterivOES, + "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() || + ValidateGetFramebufferAttachmentParameterivOES( + context, angle::EntryPoint::GLGetFramebufferAttachmentParameterivOES, target, + attachment, pname, params)); + if (isCallValid) + { + context->getFramebufferAttachmentParameteriv(target, attachment, pname, params); + } + ANGLE_CAPTURE_GL(GetFramebufferAttachmentParameterivOES, isCallValid, context, target, + attachment, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetRenderbufferParameterivOES, + "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() || + ValidateGetRenderbufferParameterivOES( + context, angle::EntryPoint::GLGetRenderbufferParameterivOES, target, + pname, params)); + if (isCallValid) + { + context->getRenderbufferParameteriv(target, pname, params); + } + ANGLE_CAPTURE_GL(GetRenderbufferParameterivOES, isCallValid, context, target, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsFramebufferOES(GLuint framebuffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsFramebufferOES, "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() || + ValidateIsFramebufferOES(context, angle::EntryPoint::GLIsFramebufferOES, + framebufferPacked)); + if (isCallValid) + { + returnValue = context->isFramebuffer(framebufferPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsFramebufferOES, isCallValid, context, framebufferPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsFramebufferOES, GLboolean>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_IsRenderbufferOES(GLuint renderbuffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsRenderbufferOES, "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() || + ValidateIsRenderbufferOES(context, angle::EntryPoint::GLIsRenderbufferOES, + renderbufferPacked)); + if (isCallValid) + { + returnValue = context->isRenderbuffer(renderbufferPacked); + } + else + { + returnValue = + GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsRenderbufferOES, isCallValid, context, renderbufferPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsRenderbufferOES, GLboolean>(); + } + return returnValue; +} + +void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLRenderbufferStorageOES, + "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() || + ValidateRenderbufferStorageOES(context, angle::EntryPoint::GLRenderbufferStorageOES, + target, internalformat, width, height)); + if (isCallValid) + { + context->renderbufferStorage(target, internalformat, width, height); + } + ANGLE_CAPTURE_GL(RenderbufferStorageOES, isCallValid, context, target, internalformat, + width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_geometry_shader +void GL_APIENTRY GL_FramebufferTextureOES(GLenum target, + GLenum attachment, + GLuint texture, + GLint level) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTextureOES, + "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() || + ValidateFramebufferTextureOES(context, angle::EntryPoint::GLFramebufferTextureOES, + target, attachment, texturePacked, level)); + if (isCallValid) + { + context->framebufferTexture(target, attachment, texturePacked, level); + } + ANGLE_CAPTURE_GL(FramebufferTextureOES, isCallValid, context, target, attachment, + texturePacked, level); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_get_program_binary +void GL_APIENTRY GL_GetProgramBinaryOES(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetProgramBinaryOES, + "context = %d, program = %u, bufSize = %d, length = 0x%016" PRIxPTR + ", binaryFormat = 0x%016" PRIxPTR ", binary = 0x%016" PRIxPTR "", + CID(context), program, bufSize, (uintptr_t)length, (uintptr_t)binaryFormat, + (uintptr_t)binary); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateGetProgramBinaryOES(context, angle::EntryPoint::GLGetProgramBinaryOES, + programPacked, bufSize, length, binaryFormat, binary)); + if (isCallValid) + { + context->getProgramBinary(programPacked, bufSize, length, binaryFormat, binary); + } + ANGLE_CAPTURE_GL(GetProgramBinaryOES, isCallValid, context, programPacked, bufSize, length, + binaryFormat, binary); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_ProgramBinaryOES(GLuint program, + GLenum binaryFormat, + const void *binary, + GLint length) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLProgramBinaryOES, + "context = %d, program = %u, binaryFormat = %s, binary = 0x%016" PRIxPTR ", length = %d", + CID(context), program, GLenumToString(GLESEnum::AllEnums, binaryFormat), + (uintptr_t)binary, length); + + if (context) + { + ShaderProgramID programPacked = PackParam<ShaderProgramID>(program); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateProgramBinaryOES(context, angle::EntryPoint::GLProgramBinaryOES, + programPacked, binaryFormat, binary, length)); + if (isCallValid) + { + context->programBinary(programPacked, binaryFormat, binary, length); + } + ANGLE_CAPTURE_GL(ProgramBinaryOES, isCallValid, context, programPacked, binaryFormat, + binary, length); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_mapbuffer +void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetBufferPointervOES, + "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() || + ValidateGetBufferPointervOES(context, angle::EntryPoint::GLGetBufferPointervOES, + targetPacked, pname, params)); + if (isCallValid) + { + context->getBufferPointerv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetBufferPointervOES, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMapBufferOES, "context = %d, target = %s, access = %s", CID(context), + GLenumToString(GLESEnum::BufferTargetARB, target), + GLenumToString(GLESEnum::BufferAccessARB, access)); + + void *returnValue; + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateMapBufferOES(context, angle::EntryPoint::GLMapBufferOES, + targetPacked, access)); + if (isCallValid) + { + returnValue = context->mapBuffer(targetPacked, access); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>(); + } + ANGLE_CAPTURE_GL(MapBufferOES, isCallValid, context, targetPacked, access, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLMapBufferOES, void *>(); + } + return returnValue; +} + +GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLUnmapBufferOES, "context = %d, target = %s", CID(context), + GLenumToString(GLESEnum::AllEnums, target)); + + GLboolean returnValue; + if (context) + { + BufferBinding targetPacked = PackParam<BufferBinding>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateUnmapBufferOES(context, angle::EntryPoint::GLUnmapBufferOES, targetPacked)); + if (isCallValid) + { + returnValue = context->unmapBuffer(targetPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>(); + } + ANGLE_CAPTURE_GL(UnmapBufferOES, isCallValid, context, targetPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLUnmapBufferOES, GLboolean>(); + } + return returnValue; +} + +// GL_OES_matrix_palette +void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCurrentPaletteMatrixOES, "context = %d, matrixpaletteindex = %u", CID(context), + matrixpaletteindex); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCurrentPaletteMatrixOES(context, angle::EntryPoint::GLCurrentPaletteMatrixOES, + matrixpaletteindex)); + if (isCallValid) + { + context->currentPaletteMatrix(matrixpaletteindex); + } + ANGLE_CAPTURE_GL(CurrentPaletteMatrixOES, isCallValid, context, matrixpaletteindex); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES() +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLLoadPaletteFromModelViewMatrixOES, "context = %d", CID(context)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateLoadPaletteFromModelViewMatrixOES( + context, angle::EntryPoint::GLLoadPaletteFromModelViewMatrixOES)); + if (isCallValid) + { + context->loadPaletteFromModelViewMatrix(); + } + ANGLE_CAPTURE_GL(LoadPaletteFromModelViewMatrixOES, isCallValid, context); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size, + GLenum type, + GLsizei stride, + const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMatrixIndexPointerOES, + "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", + CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMatrixIndexPointerOES(context, angle::EntryPoint::GLMatrixIndexPointerOES, + size, type, stride, pointer)); + if (isCallValid) + { + context->matrixIndexPointer(size, type, stride, pointer); + } + ANGLE_CAPTURE_GL(MatrixIndexPointerOES, isCallValid, context, size, type, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_WeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLWeightPointerOES, + "context = %d, size = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", + CID(context), size, GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateWeightPointerOES(context, angle::EntryPoint::GLWeightPointerOES, + size, type, stride, pointer)); + if (isCallValid) + { + context->weightPointer(size, type, stride, pointer); + } + ANGLE_CAPTURE_GL(WeightPointerOES, isCallValid, context, size, type, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_packed_depth_stencil + +// GL_OES_point_size_array +void GL_APIENTRY GL_PointSizePointerOES(GLenum type, GLsizei stride, const void *pointer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPointSizePointerOES, + "context = %d, type = %s, stride = %d, pointer = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::AllEnums, type), stride, (uintptr_t)pointer); + + if (context) + { + VertexAttribType typePacked = PackParam<VertexAttribType>(type); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidatePointSizePointerOES(context, angle::EntryPoint::GLPointSizePointerOES, + typePacked, stride, pointer)); + if (isCallValid) + { + context->pointSizePointer(typePacked, stride, pointer); + } + ANGLE_CAPTURE_GL(PointSizePointerOES, isCallValid, context, typePacked, stride, pointer); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_point_sprite + +// GL_OES_primitive_bounding_box +void GL_APIENTRY GL_PrimitiveBoundingBoxOES(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLPrimitiveBoundingBoxOES, + "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() || + ValidatePrimitiveBoundingBoxOES(context, angle::EntryPoint::GLPrimitiveBoundingBoxOES, + minX, minY, minZ, minW, maxX, maxY, maxZ, maxW)); + if (isCallValid) + { + context->primitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); + } + ANGLE_CAPTURE_GL(PrimitiveBoundingBoxOES, isCallValid, context, minX, minY, minZ, minW, + maxX, maxY, maxZ, maxW); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_query_matrix +GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLQueryMatrixxOES, + "context = %d, mantissa = 0x%016" PRIxPTR ", exponent = 0x%016" PRIxPTR "", CID(context), + (uintptr_t)mantissa, (uintptr_t)exponent); + + GLbitfield returnValue; + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateQueryMatrixxOES(context, angle::EntryPoint::GLQueryMatrixxOES, + mantissa, exponent)); + if (isCallValid) + { + returnValue = context->queryMatrixx(mantissa, exponent); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>(); + } + ANGLE_CAPTURE_GL(QueryMatrixxOES, isCallValid, context, mantissa, exponent, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLQueryMatrixxOES, GLbitfield>(); + } + return returnValue; +} + +// GL_OES_rgb8_rgba8 + +// GL_OES_sample_shading +void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLMinSampleShadingOES, "context = %d, value = %f", CID(context), value); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateMinSampleShadingOES(context, angle::EntryPoint::GLMinSampleShadingOES, value)); + if (isCallValid) + { + context->minSampleShading(value); + } + ANGLE_CAPTURE_GL(MinSampleShadingOES, isCallValid, context, value); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_sample_variables + +// GL_OES_shader_image_atomic + +// GL_OES_shader_io_blocks + +// GL_OES_shader_multisample_interpolation + +// GL_OES_standard_derivatives + +// GL_OES_surfaceless_context + +// GL_OES_texture_3D +void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexImage3DOES, + "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d, border = %d, imageSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, border, + imageSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexImage3DOES(context, angle::EntryPoint::GLCompressedTexImage3DOES, + targetPacked, level, internalformat, width, height, + depth, border, imageSize, data)); + if (isCallValid) + { + context->compressedTexImage3D(targetPacked, level, internalformat, width, height, depth, + border, imageSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexImage3DOES, isCallValid, context, targetPacked, level, + internalformat, width, height, depth, border, imageSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCompressedTexSubImage3DOES, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " + "= %d, height = %d, depth = %d, format = %s, imageSize = %d, data = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, GLenumToString(GLESEnum::InternalFormat, format), + imageSize, (uintptr_t)data); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateCompressedTexSubImage3DOES( + context, angle::EntryPoint::GLCompressedTexSubImage3DOES, targetPacked, level, + xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data)); + if (isCallValid) + { + context->compressedTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, + height, depth, format, imageSize, data); + } + ANGLE_CAPTURE_GL(CompressedTexSubImage3DOES, isCallValid, context, targetPacked, level, + xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLCopyTexSubImage3DOES, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, x = " + "%d, y = %d, width = %d, height = %d", + CID(context), GLenumToString(GLESEnum::AllEnums, target), level, xoffset, yoffset, + zoffset, x, y, width, height); + + if (context) + { + TextureTarget targetPacked = PackParam<TextureTarget>(target); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateCopyTexSubImage3DOES( + context, angle::EntryPoint::GLCopyTexSubImage3DOES, targetPacked, + level, xoffset, yoffset, zoffset, x, y, width, height)); + if (isCallValid) + { + context->copyTexSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, x, y, width, + height); + } + ANGLE_CAPTURE_GL(CopyTexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, + yoffset, zoffset, x, y, width, height); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLint zoffset) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTexture3DOES, + "context = %d, target = %s, attachment = %s, textarget = %s, texture = %u, level = %d, " + "zoffset = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), + GLenumToString(GLESEnum::TextureTarget, textarget), texture, level, zoffset); + + if (context) + { + TextureTarget textargetPacked = PackParam<TextureTarget>(textarget); + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFramebufferTexture3DOES( + context, angle::EntryPoint::GLFramebufferTexture3DOES, target, + attachment, textargetPacked, texturePacked, level, zoffset)); + if (isCallValid) + { + context->framebufferTexture3D(target, attachment, textargetPacked, texturePacked, level, + zoffset); + } + ANGLE_CAPTURE_GL(FramebufferTexture3DOES, isCallValid, context, target, attachment, + textargetPacked, texturePacked, level, zoffset); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexImage3DOES, + "context = %d, target = %s, level = %d, internalformat = %s, width = %d, height = %d, " + "depth = %d, border = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, + GLenumToString(GLESEnum::InternalFormat, internalformat), width, height, depth, 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() || + ValidateTexImage3DOES(context, angle::EntryPoint::GLTexImage3DOES, + targetPacked, level, internalformat, width, + height, depth, border, format, type, pixels)); + if (isCallValid) + { + context->texImage3D(targetPacked, level, internalformat, width, height, depth, border, + format, type, pixels); + } + ANGLE_CAPTURE_GL(TexImage3DOES, isCallValid, context, targetPacked, level, internalformat, + width, height, depth, border, format, type, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexSubImage3DOES, + "context = %d, target = %s, level = %d, xoffset = %d, yoffset = %d, zoffset = %d, width " + "= %d, height = %d, depth = %d, format = %s, type = %s, pixels = 0x%016" PRIxPTR "", + CID(context), GLenumToString(GLESEnum::TextureTarget, target), level, xoffset, yoffset, + zoffset, width, height, depth, 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() || + ValidateTexSubImage3DOES(context, angle::EntryPoint::GLTexSubImage3DOES, + targetPacked, level, xoffset, yoffset, zoffset, + width, height, depth, format, type, pixels)); + if (isCallValid) + { + context->texSubImage3D(targetPacked, level, xoffset, yoffset, zoffset, width, height, + depth, format, type, pixels); + } + ANGLE_CAPTURE_GL(TexSubImage3DOES, isCallValid, context, targetPacked, level, xoffset, + yoffset, zoffset, width, height, depth, format, type, pixels); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_texture_border_clamp +void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIivOES, + "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() || + ValidateGetSamplerParameterIivOES( + context, angle::EntryPoint::GLGetSamplerParameterIivOES, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIivOES, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetSamplerParameterIuivOES, + "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() || + ValidateGetSamplerParameterIuivOES( + context, angle::EntryPoint::GLGetSamplerParameterIuivOES, + samplerPacked, pname, params)); + if (isCallValid) + { + context->getSamplerParameterIuiv(samplerPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetSamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, + params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIivOES, + "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() || + ValidateGetTexParameterIivOES(context, angle::EntryPoint::GLGetTexParameterIivOES, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIivOES, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexParameterIuivOES, + "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() || + ValidateGetTexParameterIuivOES(context, angle::EntryPoint::GLGetTexParameterIuivOES, + targetPacked, pname, params)); + if (isCallValid) + { + context->getTexParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(GetTexParameterIuivOES, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIivOES, + "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() || + ValidateSamplerParameterIivOES(context, angle::EntryPoint::GLSamplerParameterIivOES, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIivOES, isCallValid, context, samplerPacked, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLSamplerParameterIuivOES, + "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() || + ValidateSamplerParameterIuivOES(context, angle::EntryPoint::GLSamplerParameterIuivOES, + samplerPacked, pname, param)); + if (isCallValid) + { + context->samplerParameterIuiv(samplerPacked, pname, param); + } + ANGLE_CAPTURE_GL(SamplerParameterIuivOES, isCallValid, context, samplerPacked, pname, + param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIivOES(GLenum target, GLenum pname, const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIivOES, + "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() || + ValidateTexParameterIivOES(context, angle::EntryPoint::GLTexParameterIivOES, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIivOES, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexParameterIuivOES, + "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() || + ValidateTexParameterIuivOES(context, angle::EntryPoint::GLTexParameterIuivOES, + targetPacked, pname, params)); + if (isCallValid) + { + context->texParameterIuiv(targetPacked, pname, params); + } + ANGLE_CAPTURE_GL(TexParameterIuivOES, isCallValid, context, targetPacked, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_texture_buffer +void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint buffer) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBufferOES, "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() || + ValidateTexBufferOES(context, angle::EntryPoint::GLTexBufferOES, + targetPacked, internalformat, bufferPacked)); + if (isCallValid) + { + context->texBuffer(targetPacked, internalformat, bufferPacked); + } + ANGLE_CAPTURE_GL(TexBufferOES, isCallValid, context, targetPacked, internalformat, + bufferPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexBufferRangeOES(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexBufferRangeOES, + "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() || + ValidateTexBufferRangeOES(context, angle::EntryPoint::GLTexBufferRangeOES, + targetPacked, internalformat, bufferPacked, offset, size)); + if (isCallValid) + { + context->texBufferRange(targetPacked, internalformat, bufferPacked, offset, size); + } + ANGLE_CAPTURE_GL(TexBufferRangeOES, isCallValid, context, targetPacked, internalformat, + bufferPacked, offset, size); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_texture_compression_astc + +// GL_OES_texture_cube_map +void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexGenfvOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexGenfvOES(context, angle::EntryPoint::GLGetTexGenfvOES, + coord, pname, params)); + if (isCallValid) + { + context->getTexGenfv(coord, pname, params); + } + ANGLE_CAPTURE_GL(GetTexGenfvOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexGenivOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexGenivOES(context, angle::EntryPoint::GLGetTexGenivOES, + coord, pname, params)); + if (isCallValid) + { + context->getTexGeniv(coord, pname, params); + } + ANGLE_CAPTURE_GL(GetTexGenivOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGetTexGenxvOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGetTexGenxvOES(context, angle::EntryPoint::GLGetTexGenxvOES, + coord, pname, params)); + if (isCallValid) + { + context->getTexGenxv(coord, pname, params); + } + ANGLE_CAPTURE_GL(GetTexGenxvOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGenfOES, "context = %d, coord = %s, pname = %s, param = %f", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGenfOES(context, angle::EntryPoint::GLTexGenfOES, coord, pname, param)); + if (isCallValid) + { + context->texGenf(coord, pname, param); + } + ANGLE_CAPTURE_GL(TexGenfOES, isCallValid, context, coord, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGenfvOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGenfvOES(context, angle::EntryPoint::GLTexGenfvOES, coord, pname, params)); + if (isCallValid) + { + context->texGenfv(coord, pname, params); + } + ANGLE_CAPTURE_GL(TexGenfvOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGeniOES, "context = %d, coord = %s, pname = %s, param = %d", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGeniOES(context, angle::EntryPoint::GLTexGeniOES, coord, pname, param)); + if (isCallValid) + { + context->texGeni(coord, pname, param); + } + ANGLE_CAPTURE_GL(TexGeniOES, isCallValid, context, coord, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGenivOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGenivOES(context, angle::EntryPoint::GLTexGenivOES, coord, pname, params)); + if (isCallValid) + { + context->texGeniv(coord, pname, params); + } + ANGLE_CAPTURE_GL(TexGenivOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGenxOES, "context = %d, coord = %s, pname = %s, param = 0x%X", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), param); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGenxOES(context, angle::EntryPoint::GLTexGenxOES, coord, pname, param)); + if (isCallValid) + { + context->texGenx(coord, pname, param); + } + ANGLE_CAPTURE_GL(TexGenxOES, isCallValid, context, coord, pname, param); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexGenxvOES, + "context = %d, coord = %s, pname = %s, params = 0x%016" PRIxPTR "", CID(context), + GLenumToString(GLESEnum::TextureCoordName, coord), + GLenumToString(GLESEnum::TextureGenParameter, pname), (uintptr_t)params); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateTexGenxvOES(context, angle::EntryPoint::GLTexGenxvOES, coord, pname, params)); + if (isCallValid) + { + context->texGenxv(coord, pname, params); + } + ANGLE_CAPTURE_GL(TexGenxvOES, isCallValid, context, coord, pname, params); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_texture_cube_map_array + +// GL_OES_texture_float + +// GL_OES_texture_float_linear + +// GL_OES_texture_half_float + +// GL_OES_texture_half_float_linear + +// GL_OES_texture_npot + +// GL_OES_texture_stencil8 + +// GL_OES_texture_storage_multisample_2d_array +void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLTexStorage3DMultisampleOES, + "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() || + ValidateTexStorage3DMultisampleOES( + context, angle::EntryPoint::GLTexStorage3DMultisampleOES, targetPacked, samples, + internalformat, width, height, depth, fixedsamplelocations)); + if (isCallValid) + { + context->texStorage3DMultisample(targetPacked, samples, internalformat, width, height, + depth, fixedsamplelocations); + } + ANGLE_CAPTURE_GL(TexStorage3DMultisampleOES, isCallValid, context, targetPacked, samples, + internalformat, width, height, depth, fixedsamplelocations); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OES_vertex_array_object +void GL_APIENTRY GL_BindVertexArrayOES(GLuint array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLBindVertexArrayOES, "context = %d, array = %u", CID(context), array); + + if (context) + { + VertexArrayID arrayPacked = PackParam<VertexArrayID>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateBindVertexArrayOES( + context, angle::EntryPoint::GLBindVertexArrayOES, arrayPacked)); + if (isCallValid) + { + context->bindVertexArray(arrayPacked); + } + ANGLE_CAPTURE_GL(BindVertexArrayOES, isCallValid, context, arrayPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_DeleteVertexArraysOES(GLsizei n, const GLuint *arrays) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLDeleteVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)arrays); + + if (context) + { + const VertexArrayID *arraysPacked = PackParam<const VertexArrayID *>(arrays); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateDeleteVertexArraysOES(context, angle::EntryPoint::GLDeleteVertexArraysOES, n, + arraysPacked)); + if (isCallValid) + { + context->deleteVertexArrays(n, arraysPacked); + } + ANGLE_CAPTURE_GL(DeleteVertexArraysOES, isCallValid, context, n, arraysPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +void GL_APIENTRY GL_GenVertexArraysOES(GLsizei n, GLuint *arrays) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLGenVertexArraysOES, "context = %d, n = %d, arrays = 0x%016" PRIxPTR "", + CID(context), n, (uintptr_t)arrays); + + if (context) + { + VertexArrayID *arraysPacked = PackParam<VertexArrayID *>(arrays); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateGenVertexArraysOES( + context, angle::EntryPoint::GLGenVertexArraysOES, n, arraysPacked)); + if (isCallValid) + { + context->genVertexArrays(n, arraysPacked); + } + ANGLE_CAPTURE_GL(GenVertexArraysOES, isCallValid, context, n, arraysPacked); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +GLboolean GL_APIENTRY GL_IsVertexArrayOES(GLuint array) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLIsVertexArrayOES, "context = %d, array = %u", CID(context), array); + + GLboolean returnValue; + if (context) + { + VertexArrayID arrayPacked = PackParam<VertexArrayID>(array); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateIsVertexArrayOES(context, angle::EntryPoint::GLIsVertexArrayOES, arrayPacked)); + if (isCallValid) + { + returnValue = context->isVertexArray(arrayPacked); + } + else + { + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>(); + } + ANGLE_CAPTURE_GL(IsVertexArrayOES, isCallValid, context, arrayPacked, returnValue); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + returnValue = GetDefaultReturnValue<angle::EntryPoint::GLIsVertexArrayOES, GLboolean>(); + } + return returnValue; +} + +// GL_OES_vertex_half_float + +// GL_OES_vertex_type_10_10_10_2 + +// GL_OVR_multiview +void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint baseViewIndex, + GLsizei numViews) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLFramebufferTextureMultiviewOVR, + "context = %d, target = %s, attachment = %s, texture = %u, level = %d, baseViewIndex = " + "%d, numViews = %d", + CID(context), GLenumToString(GLESEnum::FramebufferTarget, target), + GLenumToString(GLESEnum::FramebufferAttachment, attachment), texture, level, + baseViewIndex, numViews); + + if (context) + { + TextureID texturePacked = PackParam<TextureID>(texture); + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = (context->skipValidation() || + ValidateFramebufferTextureMultiviewOVR( + context, angle::EntryPoint::GLFramebufferTextureMultiviewOVR, + target, attachment, texturePacked, level, baseViewIndex, numViews)); + if (isCallValid) + { + context->framebufferTextureMultiview(target, attachment, texturePacked, level, + baseViewIndex, numViews); + } + ANGLE_CAPTURE_GL(FramebufferTextureMultiviewOVR, isCallValid, context, target, attachment, + texturePacked, level, baseViewIndex, numViews); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +// GL_OVR_multiview2 + +// GL_QCOM_shading_rate +void GL_APIENTRY GL_ShadingRateQCOM(GLenum rate) +{ + Context *context = GetValidGlobalContext(); + EVENT(context, GLShadingRateQCOM, "context = %d, rate = %s", CID(context), + GLenumToString(GLESEnum::ShadingRateQCOM, rate)); + + if (context) + { + SCOPED_SHARE_CONTEXT_LOCK(context); + bool isCallValid = + (context->skipValidation() || + ValidateShadingRateQCOM(context, angle::EntryPoint::GLShadingRateQCOM, rate)); + if (isCallValid) + { + context->shadingRateQCOM(rate); + } + ANGLE_CAPTURE_GL(ShadingRateQCOM, isCallValid, context, rate); + } + else + { + GenerateContextLostErrorOnCurrentGlobalContext(); + } +} + +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h new file mode 100644 index 0000000000..b086a3aa35 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/entry_points_gles_ext_autogen.h @@ -0,0 +1,1788 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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_ext_autogen.h: +// Defines the GLES extension entry points. + +#ifndef LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_ +#define LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_ + +#include <GLES/gl.h> +#include <GLES/glext.h> +#include <GLES2/gl2.h> +#include <GLES2/gl2ext.h> +#include <GLES3/gl32.h> +#include <export.h> + +extern "C" { + +// GL_AMD_performance_monitor +ANGLE_EXPORT void GL_APIENTRY GL_BeginPerfMonitorAMD(GLuint monitor); +ANGLE_EXPORT void GL_APIENTRY GL_DeletePerfMonitorsAMD(GLsizei n, GLuint *monitors); +ANGLE_EXPORT void GL_APIENTRY GL_EndPerfMonitorAMD(GLuint monitor); +ANGLE_EXPORT void GL_APIENTRY GL_GenPerfMonitorsAMD(GLsizei n, GLuint *monitors); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorCounterDataAMD(GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorCounterInfoAMD(GLuint group, + GLuint counter, + GLenum pname, + void *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorCounterStringAMD(GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorCountersAMD(GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorGroupStringAMD(GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString); +ANGLE_EXPORT void GL_APIENTRY GL_GetPerfMonitorGroupsAMD(GLint *numGroups, + GLsizei groupsSize, + GLuint *groups); +ANGLE_EXPORT void GL_APIENTRY GL_SelectPerfMonitorCountersAMD(GLuint monitor, + GLboolean enable, + GLuint group, + GLint numCounters, + GLuint *counterList); + +// GL_ANDROID_extension_pack_es31a + +// GL_ANGLE_base_vertex_base_instance +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance); +ANGLE_EXPORT void GL_APIENTRY +GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance); +ANGLE_EXPORT void GL_APIENTRY +GL_MultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount); +ANGLE_EXPORT void GL_APIENTRY +GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount); + +// GL_ANGLE_copy_texture_3d +ANGLE_EXPORT void GL_APIENTRY GL_CopyTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_CopySubTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLint z, + GLint width, + GLint height, + GLint depth, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); + +// GL_ANGLE_depth_texture + +// GL_ANGLE_framebuffer_blit +ANGLE_EXPORT void GL_APIENTRY GL_BlitFramebufferANGLE(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); + +// GL_ANGLE_framebuffer_multisample +ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorageMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_ANGLE_get_image +ANGLE_EXPORT void GL_APIENTRY +GL_GetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_GetCompressedTexImageANGLE(GLenum target, + GLint level, + void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_GetRenderbufferImageANGLE(GLenum target, + GLenum format, + GLenum type, + void *pixels); + +// GL_ANGLE_get_tex_level_parameter +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterivANGLE(GLenum target, + GLint level, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterfvANGLE(GLenum target, + GLint level, + GLenum pname, + GLfloat *params); + +// GL_ANGLE_instanced_arrays +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysInstancedANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei primcount); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedANGLE(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribDivisorANGLE(GLuint index, GLuint divisor); + +// GL_ANGLE_logic_op +ANGLE_EXPORT void GL_APIENTRY GL_LogicOpANGLE(GLenum opcode); + +// GL_ANGLE_memory_object_flags +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMemFlags2DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +ANGLE_EXPORT void GL_APIENTRY +GL_TexStorageMemFlags2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMemFlags3DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); +ANGLE_EXPORT void GL_APIENTRY +GL_TexStorageMemFlags3DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext); + +// GL_ANGLE_memory_object_fuchsia +ANGLE_EXPORT void GL_APIENTRY GL_ImportMemoryZirconHandleANGLE(GLuint memory, + GLuint64 size, + GLenum handleType, + GLuint handle); + +// GL_ANGLE_multi_draw +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawArraysANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount); +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawArraysInstancedANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount); +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawElementsANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + GLsizei drawcount); +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawElementsInstancedANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount); + +// GL_ANGLE_pack_reverse_row_order + +// GL_ANGLE_program_binary + +// GL_ANGLE_provoking_vertex +ANGLE_EXPORT void GL_APIENTRY GL_ProvokingVertexANGLE(GLenum mode); + +// GL_ANGLE_request_extension +ANGLE_EXPORT void GL_APIENTRY GL_RequestExtensionANGLE(const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_DisableExtensionANGLE(const GLchar *name); + +// GL_ANGLE_robust_client_memory +ANGLE_EXPORT void GL_APIENTRY GL_GetBooleanvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetFloatvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferAttachmentParameterivRobustANGLE(GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetIntegervRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramivRobustANGLE(GLuint program, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetRenderbufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetShaderivRobustANGLE(GLuint shader, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribfvRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribPointervRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer); +ANGLE_EXPORT void GL_APIENTRY GL_ReadPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexImage2DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexImage3DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexImage2DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLsizei xoffset, + GLsizei yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexImage3DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectuivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferPointervRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params); +ANGLE_EXPORT void GL_APIENTRY GL_GetIntegeri_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetInternalformativRobustANGLE(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribIivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetVertexAttribIuivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetActiveUniformBlockivRobustANGLE(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetInteger64vRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetInteger64i_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferParameteri64vRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterivRobustANGLE(GLuint sampler, + GLuint pname, + GLsizei bufSize, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLfloat *param); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramInterfaceivRobustANGLE(GLuint program, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetBooleani_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetMultisamplefvRobustANGLE(GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterivRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexLevelParameterfvRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetPointervRobustANGLERobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params); +ANGLE_EXPORT void GL_APIENTRY GL_ReadnPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLuint *param); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjecti64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectui64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params); + +// GL_ANGLE_robust_resource_initialization + +// GL_ANGLE_semaphore_fuchsia +ANGLE_EXPORT void GL_APIENTRY GL_ImportSemaphoreZirconHandleANGLE(GLuint semaphore, + GLenum handleType, + GLuint handle); + +// GL_ANGLE_shader_pixel_local_storage +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferMemorylessPixelLocalStorageANGLE(GLint plane, + GLenum internalformat); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexturePixelLocalStorageANGLE(GLint plane, + GLuint backingtexture, + GLint level, + GLint layer); +ANGLE_EXPORT void GL_APIENTRY GL_BeginPixelLocalStorageANGLE(GLsizei planes, + const GLenum *loadops, + const void *cleardata); +ANGLE_EXPORT void GL_APIENTRY GL_EndPixelLocalStorageANGLE(); +ANGLE_EXPORT void GL_APIENTRY GL_PixelLocalStorageBarrierANGLE(); + +// GL_ANGLE_texture_compression_dxt3 + +// GL_ANGLE_texture_compression_dxt5 + +// GL_ANGLE_texture_external_update +ANGLE_EXPORT void GL_APIENTRY GL_TexImage2DExternalANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type); +ANGLE_EXPORT void GL_APIENTRY GL_InvalidateTextureANGLE(GLenum target); + +// GL_ANGLE_texture_multisample +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations); +ANGLE_EXPORT void GL_APIENTRY GL_GetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val); +ANGLE_EXPORT void GL_APIENTRY GL_SampleMaskiANGLE(GLuint maskNumber, GLbitfield mask); + +// GL_ANGLE_texture_usage + +// GL_ANGLE_translated_shader_source +ANGLE_EXPORT void GL_APIENTRY GL_GetTranslatedShaderSourceANGLE(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *source); + +// GL_ANGLE_vulkan_image +ANGLE_EXPORT void GL_APIENTRY GL_AcquireTexturesANGLE(GLuint numTextures, + const GLuint *textures, + const GLenum *layouts); +ANGLE_EXPORT void GL_APIENTRY GL_ReleaseTexturesANGLE(GLuint numTextures, + const GLuint *textures, + GLenum *layouts); + +// GL_APPLE_clip_distance + +// GL_ARB_sync + +// GL_CHROMIUM_bind_uniform_location +ANGLE_EXPORT void GL_APIENTRY GL_BindUniformLocationCHROMIUM(GLuint program, + GLint location, + const GLchar *name); + +// GL_CHROMIUM_copy_compressed_texture +ANGLE_EXPORT void GL_APIENTRY GL_CompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId); + +// GL_CHROMIUM_copy_texture +ANGLE_EXPORT void GL_APIENTRY GL_CopyTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_CopySubTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLint width, + GLint height, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha); + +// GL_CHROMIUM_framebuffer_mixed_samples +ANGLE_EXPORT void GL_APIENTRY GL_CoverageModulationCHROMIUM(GLenum components); + +// GL_CHROMIUM_lose_context +ANGLE_EXPORT void GL_APIENTRY GL_LoseContextCHROMIUM(GLenum current, GLenum other); + +// GL_EXT_EGL_image_array + +// GL_EXT_EGL_image_storage +ANGLE_EXPORT void GL_APIENTRY GL_EGLImageTargetTexStorageEXT(GLenum target, + GLeglImageOES image, + const GLint *attrib_list); +ANGLE_EXPORT void GL_APIENTRY GL_EGLImageTargetTextureStorageEXT(GLuint texture, + GLeglImageOES image, + const GLint *attrib_list); + +// GL_EXT_YUV_target + +// GL_EXT_base_instance +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysInstancedBaseInstanceEXT(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLuint baseinstance); +ANGLE_EXPORT void GL_APIENTRY +GL_DrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance); + +// GL_EXT_blend_func_extended +ANGLE_EXPORT void GL_APIENTRY GL_BindFragDataLocationEXT(GLuint program, + GLuint color, + const GLchar *name); +ANGLE_EXPORT void GL_APIENTRY GL_BindFragDataLocationIndexedEXT(GLuint program, + GLuint colorNumber, + GLuint index, + const GLchar *name); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetFragDataIndexEXT(GLuint program, const GLchar *name); +ANGLE_EXPORT GLint GL_APIENTRY GL_GetProgramResourceLocationIndexEXT(GLuint program, + GLenum programInterface, + const GLchar *name); + +// GL_EXT_blend_minmax + +// GL_EXT_buffer_storage +ANGLE_EXPORT void GL_APIENTRY GL_BufferStorageEXT(GLenum target, + GLsizeiptr size, + const void *data, + GLbitfield flags); + +// GL_EXT_clip_control +ANGLE_EXPORT void GL_APIENTRY GL_ClipControlEXT(GLenum origin, GLenum depth); + +// GL_EXT_clip_cull_distance + +// GL_EXT_color_buffer_float + +// GL_EXT_color_buffer_half_float + +// GL_EXT_copy_image +ANGLE_EXPORT void GL_APIENTRY GL_CopyImageSubDataEXT(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); + +// GL_EXT_debug_label +ANGLE_EXPORT void GL_APIENTRY +GL_GetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_LabelObjectEXT(GLenum type, + GLuint object, + GLsizei length, + const GLchar *label); + +// GL_EXT_debug_marker +ANGLE_EXPORT void GL_APIENTRY GL_InsertEventMarkerEXT(GLsizei length, const GLchar *marker); +ANGLE_EXPORT void GL_APIENTRY GL_PopGroupMarkerEXT(); +ANGLE_EXPORT void GL_APIENTRY GL_PushGroupMarkerEXT(GLsizei length, const GLchar *marker); + +// GL_EXT_discard_framebuffer +ANGLE_EXPORT void GL_APIENTRY GL_DiscardFramebufferEXT(GLenum target, + GLsizei numAttachments, + const GLenum *attachments); + +// GL_EXT_disjoint_timer_query +ANGLE_EXPORT void GL_APIENTRY GL_BeginQueryEXT(GLenum target, GLuint id); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteQueriesEXT(GLsizei n, const GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_EndQueryEXT(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_GenQueriesEXT(GLsizei n, GLuint *ids); +ANGLE_EXPORT void GL_APIENTRY GL_GetInteger64vEXT(GLenum pname, GLint64 *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetQueryivEXT(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsQueryEXT(GLuint id); +ANGLE_EXPORT void GL_APIENTRY GL_QueryCounterEXT(GLuint id, GLenum target); + +// GL_EXT_draw_buffers +ANGLE_EXPORT void GL_APIENTRY GL_DrawBuffersEXT(GLsizei n, const GLenum *bufs); + +// GL_EXT_draw_buffers_indexed +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationSeparateiEXT(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationiEXT(GLuint buf, GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFuncSeparateiEXT(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFunciEXT(GLuint buf, GLenum src, GLenum dst); +ANGLE_EXPORT void GL_APIENTRY +GL_ColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +ANGLE_EXPORT void GL_APIENTRY GL_DisableiEXT(GLenum target, GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_EnableiEXT(GLenum target, GLuint index); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsEnablediEXT(GLenum target, GLuint index); + +// GL_EXT_draw_elements_base_vertex +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawRangeElementsBaseVertexEXT(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawElementsBaseVertexEXT(GLenum mode, + const GLsizei *count, + GLenum type, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex); + +// GL_EXT_external_buffer +ANGLE_EXPORT void GL_APIENTRY GL_BufferStorageExternalEXT(GLenum target, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags); +ANGLE_EXPORT void GL_APIENTRY GL_NamedBufferStorageExternalEXT(GLuint buffer, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags); + +// GL_EXT_float_blend + +// GL_EXT_geometry_shader +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTextureEXT(GLenum target, + GLenum attachment, + GLuint texture, + GLint level); + +// GL_EXT_gpu_shader5 + +// GL_EXT_instanced_arrays +ANGLE_EXPORT void GL_APIENTRY GL_DrawArraysInstancedEXT(GLenum mode, + GLint start, + GLsizei count, + GLsizei primcount); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount); +ANGLE_EXPORT void GL_APIENTRY GL_VertexAttribDivisorEXT(GLuint index, GLuint divisor); + +// GL_EXT_map_buffer_range +ANGLE_EXPORT void GL_APIENTRY GL_FlushMappedBufferRangeEXT(GLenum target, + GLintptr offset, + GLsizeiptr length); +ANGLE_EXPORT void *GL_APIENTRY GL_MapBufferRangeEXT(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access); + +// GL_EXT_memory_object +ANGLE_EXPORT void GL_APIENTRY GL_BufferStorageMemEXT(GLenum target, + GLsizeiptr size, + GLuint memory, + GLuint64 offset); +ANGLE_EXPORT void GL_APIENTRY GL_CreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects); +ANGLE_EXPORT void GL_APIENTRY GL_GetMemoryObjectParameterivEXT(GLuint memoryObject, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetUnsignedBytevEXT(GLenum pname, GLubyte *data); +ANGLE_EXPORT void GL_APIENTRY GL_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsMemoryObjectEXT(GLuint memoryObject); +ANGLE_EXPORT void GL_APIENTRY GL_MemoryObjectParameterivEXT(GLuint memoryObject, + GLenum pname, + const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMem2DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMem2DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMem3DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorageMem3DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset); + +// GL_EXT_memory_object_fd +ANGLE_EXPORT void GL_APIENTRY GL_ImportMemoryFdEXT(GLuint memory, + GLuint64 size, + GLenum handleType, + GLint fd); + +// GL_EXT_multi_draw_indirect +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawArraysIndirectEXT(GLenum mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride); +ANGLE_EXPORT void GL_APIENTRY GL_MultiDrawElementsIndirectEXT(GLenum mode, + GLenum type, + const void *indirect, + GLsizei drawcount, + GLsizei stride); + +// GL_EXT_multisampled_render_to_texture +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexture2DMultisampleEXT(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLsizei samples); +ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorageMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_EXT_multisampled_render_to_texture2 + +// GL_EXT_occlusion_query_boolean + +// GL_EXT_primitive_bounding_box +ANGLE_EXPORT void GL_APIENTRY GL_PrimitiveBoundingBoxEXT(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); + +// GL_EXT_protected_textures + +// GL_EXT_pvrtc_sRGB + +// GL_EXT_read_format_bgra + +// GL_EXT_robustness +ANGLE_EXPORT GLenum GL_APIENTRY GL_GetGraphicsResetStatusEXT(); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformfvEXT(GLuint program, + GLint location, + GLsizei bufSize, + GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetnUniformivEXT(GLuint program, + GLint location, + GLsizei bufSize, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_ReadnPixelsEXT(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data); + +// GL_EXT_sRGB + +// GL_EXT_sRGB_write_control + +// GL_EXT_semaphore +ANGLE_EXPORT void GL_APIENTRY GL_DeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores); +ANGLE_EXPORT void GL_APIENTRY GL_GenSemaphoresEXT(GLsizei n, GLuint *semaphores); +ANGLE_EXPORT void GL_APIENTRY GL_GetSemaphoreParameterui64vEXT(GLuint semaphore, + GLenum pname, + GLuint64 *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsSemaphoreEXT(GLuint semaphore); +ANGLE_EXPORT void GL_APIENTRY GL_SemaphoreParameterui64vEXT(GLuint semaphore, + GLenum pname, + const GLuint64 *params); +ANGLE_EXPORT void GL_APIENTRY GL_SignalSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *dstLayouts); +ANGLE_EXPORT void GL_APIENTRY GL_WaitSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *srcLayouts); + +// GL_EXT_semaphore_fd +ANGLE_EXPORT void GL_APIENTRY GL_ImportSemaphoreFdEXT(GLuint semaphore, + GLenum handleType, + GLint fd); + +// GL_EXT_separate_shader_objects +ANGLE_EXPORT void GL_APIENTRY GL_ActiveShaderProgramEXT(GLuint pipeline, GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_BindProgramPipelineEXT(GLuint pipeline); +ANGLE_EXPORT GLuint GL_APIENTRY GL_CreateShaderProgramvEXT(GLenum type, + GLsizei count, + const GLchar **strings); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines); +ANGLE_EXPORT void GL_APIENTRY GL_GenProgramPipelinesEXT(GLsizei n, GLuint *pipelines); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramPipelineInfoLogEXT(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog); +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramPipelineivEXT(GLuint pipeline, + GLenum pname, + GLint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsProgramPipelineEXT(GLuint pipeline); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramParameteriEXT(GLuint program, GLenum pname, GLint value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1iEXT(GLuint program, GLint location, GLint v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform1uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2fEXT(GLuint program, + GLint location, + GLfloat v0, + GLfloat v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2iEXT(GLuint program, + GLint location, + GLint v0, + GLint v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2uiEXT(GLuint program, + GLint location, + GLuint v0, + GLuint v1); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform2uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform3uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4fEXT(GLuint program, + GLint location, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value); +ANGLE_EXPORT void GL_APIENTRY +GL_ProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniform4uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix2x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix3x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramUniformMatrix4x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value); +ANGLE_EXPORT void GL_APIENTRY GL_UseProgramStagesEXT(GLuint pipeline, + GLbitfield stages, + GLuint program); +ANGLE_EXPORT void GL_APIENTRY GL_ValidateProgramPipelineEXT(GLuint pipeline); + +// GL_EXT_shader_framebuffer_fetch + +// GL_EXT_shader_framebuffer_fetch_non_coherent +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferFetchBarrierEXT(); + +// GL_EXT_shader_io_blocks + +// GL_EXT_shader_non_constant_global_initializers + +// GL_EXT_shader_texture_lod + +// GL_EXT_shadow_samplers + +// GL_EXT_tessellation_shader +ANGLE_EXPORT void GL_APIENTRY GL_PatchParameteriEXT(GLenum pname, GLint value); + +// GL_EXT_texture_border_clamp +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIivEXT(GLuint sampler, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIuivEXT(GLuint sampler, + GLenum pname, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIuivEXT(GLenum target, + GLenum pname, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIivEXT(GLuint sampler, + GLenum pname, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIuivEXT(GLuint sampler, + GLenum pname, + const GLuint *param); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIivEXT(GLenum target, + GLenum pname, + const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIuivEXT(GLenum target, + GLenum pname, + const GLuint *params); + +// GL_EXT_texture_buffer +ANGLE_EXPORT void GL_APIENTRY GL_TexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer); +ANGLE_EXPORT void GL_APIENTRY GL_TexBufferRangeEXT(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size); + +// GL_EXT_texture_compression_bptc + +// GL_EXT_texture_compression_dxt1 + +// GL_EXT_texture_compression_rgtc + +// GL_EXT_texture_compression_s3tc + +// GL_EXT_texture_compression_s3tc_srgb + +// GL_EXT_texture_cube_map_array + +// GL_EXT_texture_filter_anisotropic + +// GL_EXT_texture_format_BGRA8888 + +// GL_EXT_texture_format_sRGB_override + +// GL_EXT_texture_norm16 + +// GL_EXT_texture_rg + +// GL_EXT_texture_sRGB_R8 + +// GL_EXT_texture_sRGB_RG8 + +// GL_EXT_texture_sRGB_decode + +// GL_EXT_texture_storage +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage1DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage2DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage3DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth); + +// GL_EXT_texture_type_2_10_10_10_REV + +// GL_EXT_unpack_subimage + +// GL_IMG_texture_compression_pvrtc + +// GL_IMG_texture_compression_pvrtc2 + +// GL_KHR_blend_equation_advanced +ANGLE_EXPORT void GL_APIENTRY GL_BlendBarrierKHR(); + +// GL_KHR_debug +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageCallbackKHR(GLDEBUGPROCKHR callback, + const void *userParam); +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled); +ANGLE_EXPORT void GL_APIENTRY GL_DebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf); +ANGLE_EXPORT GLuint GL_APIENTRY GL_GetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog); +ANGLE_EXPORT void GL_APIENTRY GL_GetObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_GetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_GetPointervKHR(GLenum pname, void **params); +ANGLE_EXPORT void GL_APIENTRY GL_ObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_ObjectPtrLabelKHR(const void *ptr, + GLsizei length, + const GLchar *label); +ANGLE_EXPORT void GL_APIENTRY GL_PopDebugGroupKHR(); +ANGLE_EXPORT void GL_APIENTRY GL_PushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message); + +// GL_KHR_no_error + +// GL_KHR_parallel_shader_compile +ANGLE_EXPORT void GL_APIENTRY GL_MaxShaderCompilerThreadsKHR(GLuint count); + +// GL_KHR_robust_buffer_access_behavior + +// GL_KHR_texture_compression_astc_hdr + +// GL_KHR_texture_compression_astc_ldr + +// GL_KHR_texture_compression_astc_sliced_3d + +// GL_MESA_framebuffer_flip_y +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferParameteriMESA(GLenum target, + GLenum pname, + GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferParameterivMESA(GLenum target, + GLenum pname, + GLint *params); + +// GL_NV_fence +ANGLE_EXPORT void GL_APIENTRY GL_DeleteFencesNV(GLsizei n, const GLuint *fences); +ANGLE_EXPORT void GL_APIENTRY GL_FinishFenceNV(GLuint fence); +ANGLE_EXPORT void GL_APIENTRY GL_GenFencesNV(GLsizei n, GLuint *fences); +ANGLE_EXPORT void GL_APIENTRY GL_GetFenceivNV(GLuint fence, GLenum pname, GLint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsFenceNV(GLuint fence); +ANGLE_EXPORT void GL_APIENTRY GL_SetFenceNV(GLuint fence, GLenum condition); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_TestFenceNV(GLuint fence); + +// GL_NV_framebuffer_blit +ANGLE_EXPORT void GL_APIENTRY GL_BlitFramebufferNV(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter); + +// GL_NV_pixel_buffer_object + +// GL_NV_read_depth + +// GL_NV_read_depth_stencil + +// GL_NV_read_stencil + +// GL_NV_robustness_video_memory_purge + +// GL_NV_shader_noperspective_interpolation + +// GL_OES_EGL_image +ANGLE_EXPORT void GL_APIENTRY GL_EGLImageTargetRenderbufferStorageOES(GLenum target, + GLeglImageOES image); +ANGLE_EXPORT void GL_APIENTRY GL_EGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image); + +// GL_OES_EGL_image_external + +// GL_OES_EGL_image_external_essl3 + +// GL_OES_compressed_ETC1_RGB8_texture + +// GL_OES_compressed_paletted_texture + +// GL_OES_copy_image +ANGLE_EXPORT void GL_APIENTRY GL_CopyImageSubDataOES(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); + +// GL_OES_depth24 + +// GL_OES_depth32 + +// GL_OES_depth_texture + +// GL_OES_draw_buffers_indexed +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationSeparateiOES(GLuint buf, + GLenum modeRGB, + GLenum modeAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendEquationiOES(GLuint buf, GLenum mode); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFuncSeparateiOES(GLuint buf, + GLenum srcRGB, + GLenum dstRGB, + GLenum srcAlpha, + GLenum dstAlpha); +ANGLE_EXPORT void GL_APIENTRY GL_BlendFunciOES(GLuint buf, GLenum src, GLenum dst); +ANGLE_EXPORT void GL_APIENTRY +GL_ColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +ANGLE_EXPORT void GL_APIENTRY GL_DisableiOES(GLenum target, GLuint index); +ANGLE_EXPORT void GL_APIENTRY GL_EnableiOES(GLenum target, GLuint index); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsEnablediOES(GLenum target, GLuint index); + +// GL_OES_draw_elements_base_vertex +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawElementsInstancedBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex); +ANGLE_EXPORT void GL_APIENTRY GL_DrawRangeElementsBaseVertexOES(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex); + +// GL_OES_draw_texture +ANGLE_EXPORT void GL_APIENTRY +GL_DrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height); +ANGLE_EXPORT void GL_APIENTRY GL_DrawTexfvOES(const GLfloat *coords); +ANGLE_EXPORT void GL_APIENTRY GL_DrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height); +ANGLE_EXPORT void GL_APIENTRY GL_DrawTexivOES(const GLint *coords); +ANGLE_EXPORT void GL_APIENTRY +GL_DrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height); +ANGLE_EXPORT void GL_APIENTRY GL_DrawTexsvOES(const GLshort *coords); +ANGLE_EXPORT void GL_APIENTRY +GL_DrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height); +ANGLE_EXPORT void GL_APIENTRY GL_DrawTexxvOES(const GLfixed *coords); + +// GL_OES_element_index_uint + +// GL_OES_fbo_render_mipmap + +// GL_OES_framebuffer_object +ANGLE_EXPORT void GL_APIENTRY GL_BindFramebufferOES(GLenum target, GLuint framebuffer); +ANGLE_EXPORT void GL_APIENTRY GL_BindRenderbufferOES(GLenum target, GLuint renderbuffer); +ANGLE_EXPORT GLenum GL_APIENTRY GL_CheckFramebufferStatusOES(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferRenderbufferOES(GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexture2DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level); +ANGLE_EXPORT void GL_APIENTRY GL_GenFramebuffersOES(GLsizei n, GLuint *framebuffers); +ANGLE_EXPORT void GL_APIENTRY GL_GenRenderbuffersOES(GLsizei n, GLuint *renderbuffers); +ANGLE_EXPORT void GL_APIENTRY GL_GenerateMipmapOES(GLenum target); +ANGLE_EXPORT void GL_APIENTRY GL_GetFramebufferAttachmentParameterivOES(GLenum target, + GLenum attachment, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetRenderbufferParameterivOES(GLenum target, + GLenum pname, + GLint *params); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsFramebufferOES(GLuint framebuffer); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsRenderbufferOES(GLuint renderbuffer); +ANGLE_EXPORT void GL_APIENTRY GL_RenderbufferStorageOES(GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height); + +// GL_OES_geometry_shader +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTextureOES(GLenum target, + GLenum attachment, + GLuint texture, + GLint level); + +// GL_OES_get_program_binary +ANGLE_EXPORT void GL_APIENTRY GL_GetProgramBinaryOES(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary); +ANGLE_EXPORT void GL_APIENTRY GL_ProgramBinaryOES(GLuint program, + GLenum binaryFormat, + const void *binary, + GLint length); + +// GL_OES_mapbuffer +ANGLE_EXPORT void GL_APIENTRY GL_GetBufferPointervOES(GLenum target, GLenum pname, void **params); +ANGLE_EXPORT void *GL_APIENTRY GL_MapBufferOES(GLenum target, GLenum access); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_UnmapBufferOES(GLenum target); + +// GL_OES_matrix_palette +ANGLE_EXPORT void GL_APIENTRY GL_CurrentPaletteMatrixOES(GLuint matrixpaletteindex); +ANGLE_EXPORT void GL_APIENTRY GL_LoadPaletteFromModelViewMatrixOES(); +ANGLE_EXPORT void GL_APIENTRY GL_MatrixIndexPointerOES(GLint size, + GLenum type, + GLsizei stride, + const void *pointer); +ANGLE_EXPORT void GL_APIENTRY GL_WeightPointerOES(GLint size, + GLenum type, + GLsizei stride, + const void *pointer); + +// GL_OES_packed_depth_stencil + +// GL_OES_point_size_array +ANGLE_EXPORT void GL_APIENTRY GL_PointSizePointerOES(GLenum type, + GLsizei stride, + const void *pointer); + +// GL_OES_point_sprite + +// GL_OES_primitive_bounding_box +ANGLE_EXPORT void GL_APIENTRY GL_PrimitiveBoundingBoxOES(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW); + +// GL_OES_query_matrix +ANGLE_EXPORT GLbitfield GL_APIENTRY GL_QueryMatrixxOES(GLfixed *mantissa, GLint *exponent); + +// GL_OES_rgb8_rgba8 + +// GL_OES_sample_shading +ANGLE_EXPORT void GL_APIENTRY GL_MinSampleShadingOES(GLfloat value); + +// GL_OES_sample_variables + +// GL_OES_shader_image_atomic + +// GL_OES_shader_io_blocks + +// GL_OES_shader_multisample_interpolation + +// GL_OES_standard_derivatives + +// GL_OES_surfaceless_context + +// GL_OES_texture_3D +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CompressedTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data); +ANGLE_EXPORT void GL_APIENTRY GL_CopyTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height); +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTexture3DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLint zoffset); +ANGLE_EXPORT void GL_APIENTRY GL_TexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels); +ANGLE_EXPORT void GL_APIENTRY GL_TexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels); + +// GL_OES_texture_border_clamp +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIivOES(GLuint sampler, + GLenum pname, + GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetSamplerParameterIuivOES(GLuint sampler, + GLenum pname, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIivOES(GLenum target, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexParameterIuivOES(GLenum target, + GLenum pname, + GLuint *params); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIivOES(GLuint sampler, + GLenum pname, + const GLint *param); +ANGLE_EXPORT void GL_APIENTRY GL_SamplerParameterIuivOES(GLuint sampler, + GLenum pname, + const GLuint *param); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIivOES(GLenum target, + GLenum pname, + const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexParameterIuivOES(GLenum target, + GLenum pname, + const GLuint *params); + +// GL_OES_texture_buffer +ANGLE_EXPORT void GL_APIENTRY GL_TexBufferOES(GLenum target, GLenum internalformat, GLuint buffer); +ANGLE_EXPORT void GL_APIENTRY GL_TexBufferRangeOES(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size); + +// GL_OES_texture_compression_astc + +// GL_OES_texture_cube_map +ANGLE_EXPORT void GL_APIENTRY GL_GetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexGenivOES(GLenum coord, GLenum pname, GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_GetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexGenfOES(GLenum coord, GLenum pname, GLfloat param); +ANGLE_EXPORT void GL_APIENTRY GL_TexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexGeniOES(GLenum coord, GLenum pname, GLint param); +ANGLE_EXPORT void GL_APIENTRY GL_TexGenivOES(GLenum coord, GLenum pname, const GLint *params); +ANGLE_EXPORT void GL_APIENTRY GL_TexGenxOES(GLenum coord, GLenum pname, GLfixed param); +ANGLE_EXPORT void GL_APIENTRY GL_TexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params); + +// GL_OES_texture_cube_map_array + +// GL_OES_texture_float + +// GL_OES_texture_float_linear + +// GL_OES_texture_half_float + +// GL_OES_texture_half_float_linear + +// GL_OES_texture_npot + +// GL_OES_texture_stencil8 + +// GL_OES_texture_storage_multisample_2d_array +ANGLE_EXPORT void GL_APIENTRY GL_TexStorage3DMultisampleOES(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations); + +// GL_OES_vertex_array_object +ANGLE_EXPORT void GL_APIENTRY GL_BindVertexArrayOES(GLuint array); +ANGLE_EXPORT void GL_APIENTRY GL_DeleteVertexArraysOES(GLsizei n, const GLuint *arrays); +ANGLE_EXPORT void GL_APIENTRY GL_GenVertexArraysOES(GLsizei n, GLuint *arrays); +ANGLE_EXPORT GLboolean GL_APIENTRY GL_IsVertexArrayOES(GLuint array); + +// GL_OES_vertex_half_float + +// GL_OES_vertex_type_10_10_10_2 + +// GL_OVR_multiview +ANGLE_EXPORT void GL_APIENTRY GL_FramebufferTextureMultiviewOVR(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint baseViewIndex, + GLsizei numViews); + +// GL_OVR_multiview2 + +// GL_QCOM_shading_rate +ANGLE_EXPORT void GL_APIENTRY GL_ShadingRateQCOM(GLenum rate); +} // extern "C" + +#endif // LIBGLESV2_ENTRY_POINTS_GLES_EXT_AUTOGEN_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/global_state.cpp b/gfx/angle/checkout/src/libGLESv2/global_state.cpp new file mode 100644 index 0000000000..c776980524 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/global_state.cpp @@ -0,0 +1,373 @@ +// +// Copyright 2014 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. +// + +// global_state.cpp : Implements functions for querying the thread-local GL and EGL state. + +#include "libGLESv2/global_state.h" + +#include "common/debug.h" +#include "common/platform.h" +#include "common/system_utils.h" +#include "libANGLE/ErrorStrings.h" +#include "libANGLE/Thread.h" +#include "libGLESv2/resource.h" + +#include <atomic> +#if defined(ANGLE_PLATFORM_APPLE) +# include <dispatch/dispatch.h> +#endif +namespace egl +{ +namespace +{ +ANGLE_REQUIRE_CONSTANT_INIT std::atomic<angle::GlobalMutex *> g_Mutex{}; +static_assert(std::is_trivially_destructible<decltype(g_Mutex)>::value, + "global mutex is not trivially destructible"); +ANGLE_REQUIRE_CONSTANT_INIT std::atomic<angle::GlobalMutex *> g_SurfaceMutex{}; +static_assert(std::is_trivially_destructible<decltype(g_SurfaceMutex)>::value, + "global mutex is not trivially destructible"); + +ANGLE_REQUIRE_CONSTANT_INIT gl::Context *g_LastContext(nullptr); +static_assert(std::is_trivially_destructible<decltype(g_LastContext)>::value, + "global last context is not trivially destructible"); + +void SetContextToAndroidOpenGLTLSSlot(gl::Context *value) +{ +#if defined(ANGLE_USE_ANDROID_TLS_SLOT) + if (angle::gUseAndroidOpenGLTlsSlot) + { + ANGLE_ANDROID_GET_GL_TLS()[angle::kAndroidOpenGLTlsSlot] = static_cast<void *>(value); + } +#endif +} + +// Called only on Android platform +[[maybe_unused]] void ThreadCleanupCallback(void *ptr) +{ + ANGLE_SCOPED_GLOBAL_LOCK(); + angle::PthreadKeyDestructorCallback(ptr); +} + +Thread *AllocateCurrentThread() +{ + Thread *thread; + { + // Global thread intentionally leaked + ANGLE_SCOPED_DISABLE_LSAN(); + thread = new Thread(); +#if defined(ANGLE_PLATFORM_APPLE) + SetCurrentThreadTLS(thread); +#else + gCurrentThread = thread; +#endif + } + + // Initialize fast TLS slot + SetContextToAndroidOpenGLTLSSlot(nullptr); + +#if defined(ANGLE_PLATFORM_APPLE) + gl::SetCurrentValidContextTLS(nullptr); +#else + gl::gCurrentValidContext = nullptr; +#endif + +#if defined(ANGLE_PLATFORM_ANDROID) + static pthread_once_t keyOnce = PTHREAD_ONCE_INIT; + static TLSIndex gThreadCleanupTLSIndex = TLS_INVALID_INDEX; + + // Create thread cleanup TLS slot + auto CreateThreadCleanupTLSIndex = []() { + gThreadCleanupTLSIndex = CreateTLSIndex(ThreadCleanupCallback); + }; + pthread_once(&keyOnce, CreateThreadCleanupTLSIndex); + ASSERT(gThreadCleanupTLSIndex != TLS_INVALID_INDEX); + + // Initialize thread cleanup TLS slot + SetTLSValue(gThreadCleanupTLSIndex, thread); +#endif // ANGLE_PLATFORM_ANDROID + + ASSERT(thread); + return thread; +} + +void AllocateGlobalMutex(std::atomic<angle::GlobalMutex *> &mutex) +{ + if (mutex == nullptr) + { + std::unique_ptr<angle::GlobalMutex> newMutex(new angle::GlobalMutex()); + angle::GlobalMutex *expected = nullptr; + if (mutex.compare_exchange_strong(expected, newMutex.get())) + { + newMutex.release(); + } + } +} + +void AllocateMutex() +{ + AllocateGlobalMutex(g_Mutex); +} + +void AllocateSurfaceMutex() +{ + AllocateGlobalMutex(g_SurfaceMutex); +} + +} // anonymous namespace + +#if defined(ANGLE_PLATFORM_APPLE) +// TODO(angleproject:6479): Due to a bug in Apple's dyld loader, `thread_local` will cause +// excessive memory use. Temporarily avoid it by using pthread's thread +// local storage instead. +// https://bugs.webkit.org/show_bug.cgi?id=228240 + +static TLSIndex GetCurrentThreadTLSIndex() +{ + static TLSIndex CurrentThreadIndex = TLS_INVALID_INDEX; + static dispatch_once_t once; + dispatch_once(&once, ^{ + ASSERT(CurrentThreadIndex == TLS_INVALID_INDEX); + CurrentThreadIndex = CreateTLSIndex(nullptr); + }); + return CurrentThreadIndex; +} +Thread *GetCurrentThreadTLS() +{ + TLSIndex CurrentThreadIndex = GetCurrentThreadTLSIndex(); + ASSERT(CurrentThreadIndex != TLS_INVALID_INDEX); + return static_cast<Thread *>(GetTLSValue(CurrentThreadIndex)); +} +void SetCurrentThreadTLS(Thread *thread) +{ + TLSIndex CurrentThreadIndex = GetCurrentThreadTLSIndex(); + ASSERT(CurrentThreadIndex != TLS_INVALID_INDEX); + SetTLSValue(CurrentThreadIndex, thread); +} +#else +thread_local Thread *gCurrentThread = nullptr; +#endif + +angle::GlobalMutex &GetGlobalMutex() +{ + AllocateMutex(); + return *g_Mutex; +} + +angle::GlobalMutex &GetGlobalSurfaceMutex() +{ + AllocateSurfaceMutex(); + return *g_SurfaceMutex; +} + +gl::Context *GetGlobalLastContext() +{ + return g_LastContext; +} + +void SetGlobalLastContext(gl::Context *context) +{ + g_LastContext = context; +} + +// This function causes an MSAN false positive, which is muted. See https://crbug.com/1211047 +// It also causes a flaky false positive in TSAN. http://crbug.com/1223970 +ANGLE_NO_SANITIZE_MEMORY ANGLE_NO_SANITIZE_THREAD Thread *GetCurrentThread() +{ +#if defined(ANGLE_PLATFORM_APPLE) + Thread *current = GetCurrentThreadTLS(); +#else + Thread *current = gCurrentThread; +#endif + return (current ? current : AllocateCurrentThread()); +} + +void SetContextCurrent(Thread *thread, gl::Context *context) +{ +#if defined(ANGLE_PLATFORM_APPLE) + Thread *currentThread = GetCurrentThreadTLS(); +#else + Thread *currentThread = gCurrentThread; +#endif + ASSERT(currentThread); + currentThread->setCurrent(context); + SetContextToAndroidOpenGLTLSSlot(context); + +#if defined(ANGLE_PLATFORM_APPLE) + gl::SetCurrentValidContextTLS(context); +#else + gl::gCurrentValidContext = context; +#endif + +#if defined(ANGLE_FORCE_CONTEXT_CHECK_EVERY_CALL) + DirtyContextIfNeeded(context); +#endif +} + +ScopedSyncCurrentContextFromThread::ScopedSyncCurrentContextFromThread(egl::Thread *thread) + : mThread(thread) +{ + ASSERT(mThread); +} + +ScopedSyncCurrentContextFromThread::~ScopedSyncCurrentContextFromThread() +{ + SetContextCurrent(mThread, mThread->getContext()); +} + +} // namespace egl + +namespace gl +{ +void GenerateContextLostErrorOnContext(Context *context) +{ + if (context && context->isContextLost()) + { + context->validationError(angle::EntryPoint::GLInvalid, GL_CONTEXT_LOST, err::kContextLost); + } +} + +void GenerateContextLostErrorOnCurrentGlobalContext() +{ + // If the client starts issuing GL calls before ANGLE has had a chance to initialize, + // GenerateContextLostErrorOnCurrentGlobalContext can be called before AllocateCurrentThread has + // had a chance to run. Calling GetCurrentThread() ensures that TLS thread state is set up. + egl::GetCurrentThread(); + + GenerateContextLostErrorOnContext(GetGlobalContext()); +} +} // namespace gl + +#if defined(ANGLE_PLATFORM_WINDOWS) && !defined(ANGLE_STATIC) +namespace egl +{ + +namespace +{ + +void DeallocateGlobalMutex(std::atomic<angle::GlobalMutex *> &mutex) +{ + angle::GlobalMutex *toDelete = mutex.exchange(nullptr); + if (!mutex) + return; + { + // Wait for toDelete to become released by other threads before deleting. + std::lock_guard<angle::GlobalMutex> lock(*toDelete); + } + SafeDelete(toDelete); +} + +void DeallocateCurrentThread() +{ + SafeDelete(gCurrentThread); +} + +void DeallocateMutex() +{ + DeallocateGlobalMutex(g_Mutex); +} + +void DeallocateSurfaceMutex() +{ + DeallocateGlobalMutex(g_SurfaceMutex); +} + +bool InitializeProcess() +{ + EnsureDebugAllocated(); + AllocateMutex(); + return AllocateCurrentThread() != nullptr; +} + +void TerminateProcess() +{ + DeallocateDebug(); + DeallocateSurfaceMutex(); + DeallocateMutex(); + DeallocateCurrentThread(); +} + +} // anonymous namespace + +} // namespace egl + +namespace +{ +// The following WaitForDebugger code is based on SwiftShader. See: +// https://cs.chromium.org/chromium/src/third_party/swiftshader/src/Vulkan/main.cpp +# if defined(ANGLE_ENABLE_ASSERTS) && !defined(ANGLE_ENABLE_WINDOWS_UWP) +INT_PTR CALLBACK DebuggerWaitDialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) +{ + RECT rect; + + switch (uMsg) + { + case WM_INITDIALOG: + ::GetWindowRect(GetDesktopWindow(), &rect); + ::SetWindowPos(hwnd, HWND_TOP, rect.right / 2, rect.bottom / 2, 0, 0, SWP_NOSIZE); + ::SetTimer(hwnd, 1, 100, NULL); + return TRUE; + case WM_COMMAND: + if (LOWORD(wParam) == IDCANCEL) + { + ::EndDialog(hwnd, 0); + } + break; + case WM_TIMER: + if (angle::IsDebuggerAttached()) + { + ::EndDialog(hwnd, 0); + } + } + + return FALSE; +} + +void WaitForDebugger(HINSTANCE instance) +{ + if (angle::IsDebuggerAttached()) + return; + + HRSRC dialog = ::FindResourceA(instance, MAKEINTRESOURCEA(IDD_DIALOG1), MAKEINTRESOURCEA(5)); + if (!dialog) + { + printf("Error finding wait for debugger dialog. Error %lu.\n", ::GetLastError()); + return; + } + + DLGTEMPLATE *dialogTemplate = reinterpret_cast<DLGTEMPLATE *>(::LoadResource(instance, dialog)); + ::DialogBoxIndirectA(instance, dialogTemplate, NULL, DebuggerWaitDialogProc); +} +# else +void WaitForDebugger(HINSTANCE instance) {} +# endif // defined(ANGLE_ENABLE_ASSERTS) && !defined(ANGLE_ENABLE_WINDOWS_UWP) +} // namespace + +extern "C" BOOL WINAPI DllMain(HINSTANCE instance, DWORD reason, LPVOID) +{ + switch (reason) + { + case DLL_PROCESS_ATTACH: + if (angle::GetEnvironmentVar("ANGLE_WAIT_FOR_DEBUGGER") == "1") + { + WaitForDebugger(instance); + } + return static_cast<BOOL>(egl::InitializeProcess()); + + case DLL_THREAD_ATTACH: + return static_cast<BOOL>(egl::AllocateCurrentThread() != nullptr); + + case DLL_THREAD_DETACH: + egl::DeallocateCurrentThread(); + break; + + case DLL_PROCESS_DETACH: + egl::TerminateProcess(); + break; + } + + return TRUE; +} +#endif // defined(ANGLE_PLATFORM_WINDOWS) && !defined(ANGLE_STATIC) diff --git a/gfx/angle/checkout/src/libGLESv2/global_state.h b/gfx/angle/checkout/src/libGLESv2/global_state.h new file mode 100644 index 0000000000..947baf3c06 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/global_state.h @@ -0,0 +1,215 @@ +// +// Copyright 2014 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. +// + +// global_state.h : Defines functions for querying the thread-local GL and EGL state. + +#ifndef LIBGLESV2_GLOBALSTATE_H_ +#define LIBGLESV2_GLOBALSTATE_H_ + +#include "libANGLE/Context.h" +#include "libANGLE/Debug.h" +#include "libANGLE/Thread.h" +#include "libANGLE/features.h" + +#if defined(ANGLE_PLATFORM_APPLE) || (ANGLE_PLATFORM_ANDROID) +# include "common/tls.h" +#endif + +#include <mutex> + +namespace angle +{ +using GlobalMutex = std::recursive_mutex; + +// - TLS_SLOT_OPENGL and TLS_SLOT_OPENGL_API: These two aren't used by bionic +// itself, but allow the graphics code to access TLS directly rather than +// using the pthread API. +// +// Choose the TLS_SLOT_OPENGL TLS slot with the value that matches value in the header file in +// bionic(tls_defines.h) +constexpr size_t kAndroidOpenGLTlsSlot = 3; + +#if defined(ANGLE_PLATFORM_ANDROID) + +// The following ASM variant provides a much more performant store/retrieve interface +// compared to those provided by the pthread library. These have been derived from code +// in the bionic module of Android -> +// https://cs.android.com/android/platform/superproject/+/master:bionic/libc/platform/bionic/tls.h;l=30 + +# if defined(__aarch64__) +# define ANGLE_ANDROID_GET_GL_TLS() \ + ({ \ + void **__val; \ + __asm__("mrs %0, tpidr_el0" : "=r"(__val)); \ + __val; \ + }) +# elif defined(__arm__) +# define ANGLE_ANDROID_GET_GL_TLS() \ + ({ \ + void **__val; \ + __asm__("mrc p15, 0, %0, c13, c0, 3" : "=r"(__val)); \ + __val; \ + }) +# elif defined(__mips__) +// On mips32r1, this goes via a kernel illegal instruction trap that's +// optimized for v1 +# define ANGLE_ANDROID_GET_GL_TLS() \ + ({ \ + register void **__val asm("v1"); \ + __asm__( \ + ".set push\n" \ + ".set mips32r2\n" \ + "rdhwr %0,$29\n" \ + ".set pop\n" \ + : "=r"(__val)); \ + __val; \ + }) +# elif defined(__i386__) +# define ANGLE_ANDROID_GET_GL_TLS() \ + ({ \ + void **__val; \ + __asm__("movl %%gs:0, %0" : "=r"(__val)); \ + __val; \ + }) +# elif defined(__x86_64__) +# define ANGLE_ANDROID_GET_GL_TLS() \ + ({ \ + void **__val; \ + __asm__("mov %%fs:0, %0" : "=r"(__val)); \ + __val; \ + }) +# else +# error unsupported architecture +# endif + +#endif // ANGLE_PLATFORM_ANDROID +} // namespace angle + +namespace egl +{ +class Debug; +class Thread; + +#if defined(ANGLE_PLATFORM_APPLE) +extern Thread *GetCurrentThreadTLS(); +extern void SetCurrentThreadTLS(Thread *thread); +#else +extern thread_local Thread *gCurrentThread; +#endif + +angle::GlobalMutex &GetGlobalMutex(); +angle::GlobalMutex &GetGlobalSurfaceMutex(); +gl::Context *GetGlobalLastContext(); +void SetGlobalLastContext(gl::Context *context); +Thread *GetCurrentThread(); +Debug *GetDebug(); + +// Sync the current context from Thread to global state. +class [[nodiscard]] ScopedSyncCurrentContextFromThread +{ + public: + ScopedSyncCurrentContextFromThread(egl::Thread *thread); + ~ScopedSyncCurrentContextFromThread(); + + private: + egl::Thread *const mThread; +}; + +} // namespace egl + +#define ANGLE_GLOBAL_SURFACE_LOCK_VAR_NAME globalSurfaceMutexLock +#define ANGLE_SCOPED_GLOBAL_SURFACE_LOCK() \ + std::lock_guard<angle::GlobalMutex> ANGLE_GLOBAL_SURFACE_LOCK_VAR_NAME( \ + egl::GetGlobalSurfaceMutex()) + +#define ANGLE_GLOBAL_LOCK_VAR_NAME globalMutexLock +#define ANGLE_SCOPED_GLOBAL_LOCK() \ + std::lock_guard<angle::GlobalMutex> ANGLE_GLOBAL_LOCK_VAR_NAME(egl::GetGlobalMutex()) + +namespace gl +{ +ANGLE_INLINE Context *GetGlobalContext() +{ +#if defined(ANGLE_USE_ANDROID_TLS_SLOT) + // TODO: Replace this branch with a compile time flag (http://anglebug.com/4764) + if (angle::gUseAndroidOpenGLTlsSlot) + { + return static_cast<gl::Context *>(ANGLE_ANDROID_GET_GL_TLS()[angle::kAndroidOpenGLTlsSlot]); + } +#endif + +#if defined(ANGLE_PLATFORM_APPLE) + egl::Thread *currentThread = egl::GetCurrentThreadTLS(); +#else + egl::Thread *currentThread = egl::gCurrentThread; +#endif + ASSERT(currentThread); + return currentThread->getContext(); +} + +ANGLE_INLINE Context *GetValidGlobalContext() +{ +#if defined(ANGLE_USE_ANDROID_TLS_SLOT) + // TODO: Replace this branch with a compile time flag (http://anglebug.com/4764) + if (angle::gUseAndroidOpenGLTlsSlot) + { + Context *context = + static_cast<gl::Context *>(ANGLE_ANDROID_GET_GL_TLS()[angle::kAndroidOpenGLTlsSlot]); + if (context && !context->isContextLost()) + { + return context; + } + } +#endif + +#if defined(ANGLE_PLATFORM_APPLE) + return GetCurrentValidContextTLS(); +#else + return gCurrentValidContext; +#endif +} + +// Generate a context lost error on the context if it is non-null and lost. +void GenerateContextLostErrorOnContext(Context *context); +void GenerateContextLostErrorOnCurrentGlobalContext(); + +#if defined(ANGLE_FORCE_CONTEXT_CHECK_EVERY_CALL) +// TODO(b/177574181): This should be handled in a backend-specific way. +// if previous context different from current context, dirty all state +static ANGLE_INLINE void DirtyContextIfNeeded(Context *context) +{ + if (context && context != egl::GetGlobalLastContext()) + { + context->dirtyAllState(); + SetGlobalLastContext(context); + } +} + +#endif + +#if !defined(ANGLE_ENABLE_SHARE_CONTEXT_LOCK) +# define SCOPED_SHARE_CONTEXT_LOCK(context) +#else +ANGLE_INLINE std::unique_lock<angle::GlobalMutex> GetContextLock(Context *context) +{ +# if defined(ANGLE_FORCE_CONTEXT_CHECK_EVERY_CALL) + auto lock = std::unique_lock<angle::GlobalMutex>(egl::GetGlobalMutex()); + + DirtyContextIfNeeded(context); + return lock; +# else + return context->isShared() ? std::unique_lock<angle::GlobalMutex>(egl::GetGlobalMutex()) + : std::unique_lock<angle::GlobalMutex>(); +# endif +} + +# define SCOPED_SHARE_CONTEXT_LOCK(context) \ + std::unique_lock<angle::GlobalMutex> shareContextLock = GetContextLock(context) +#endif + +} // namespace gl + +#endif // LIBGLESV2_GLOBALSTATE_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc b/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc new file mode 100644 index 0000000000..2d2c9f9681 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2.rc @@ -0,0 +1,137 @@ +// Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include <windows.h> +#include "../common/angle_version.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (U.S.) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +#ifdef _WIN32 +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US +#pragma code_page(1252) +#endif //_WIN32 + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""afxres.h""\r\n" + "#include ""../common/version.h""\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION ANGLE_MAJOR_VERSION,ANGLE_MINOR_VERSION,ANGLE_REVISION,0 + PRODUCTVERSION ANGLE_MAJOR_VERSION,ANGLE_MINOR_VERSION,ANGLE_REVISION,0 + FILEFLAGSMASK 0x17L +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904b0" + BEGIN + VALUE "FileDescription", "ANGLE libGLESv2 Dynamic Link Library" + VALUE "FileVersion", ANGLE_VERSION_STRING + VALUE "InternalName", "libGLESv2" + VALUE "LegalCopyright", "Copyright (C) 2015 Google Inc." + VALUE "OriginalFilename", "libGLESv2.dll" + VALUE "PrivateBuild", ANGLE_VERSION_STRING + VALUE "ProductName", "ANGLE libGLESv2 Dynamic Link Library" + VALUE "ProductVersion", ANGLE_VERSION_STRING + VALUE "Comments", "Build Date: " ANGLE_COMMIT_DATE + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1200 + END +END + + +///////////////////////////////////////////////////////////////////////////// +// +// Dialog +// + +IDD_DIALOG1 DIALOGEX 0, 0, 129, 47 +STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU +CAPTION "Waiting for debugger" +FONT 8, "MS Shell Dlg", 400, 0, 0x1 +BEGIN +PUSHBUTTON "Cancel",IDCANCEL,72,26,50,14 +LTEXT "Attach a debugger or ESC to cancel",IDC_STATIC,7,7,115,8 +END + + +///////////////////////////////////////////////////////////////////////////// +// +// DESIGNINFO +// + +#ifdef APSTUDIO_INVOKED +GUIDELINES DESIGNINFO +BEGIN +IDD_DIALOG1, DIALOG +BEGIN +LEFTMARGIN, 7 +RIGHTMARGIN, 122 +TOPMARGIN, 7 +BOTTOMMARGIN, 40 +END +END +#endif // APSTUDIO_INVOKED + +#endif // English (U.S.) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp new file mode 100644 index 0000000000..078dc810a0 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.cpp @@ -0,0 +1,9704 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by generate_entry_points.py using data from gl.xml and gl_angle_ext.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. +// +// libGLESv2_autogen.cpp: Implements the exported OpenGL ES functions. + +#include "angle_gl.h" + +#include "libGLESv2/entry_points_gles_1_0_autogen.h" +#include "libGLESv2/entry_points_gles_2_0_autogen.h" +#include "libGLESv2/entry_points_gles_3_0_autogen.h" +#include "libGLESv2/entry_points_gles_3_1_autogen.h" +#include "libGLESv2/entry_points_gles_3_2_autogen.h" +#include "libGLESv2/entry_points_gles_ext_autogen.h" + +#if defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND) +# include "libGLESv2/entry_points_gl_1_autogen.h" +# include "libGLESv2/entry_points_gl_2_autogen.h" +# include "libGLESv2/entry_points_gl_3_autogen.h" +# include "libGLESv2/entry_points_gl_4_autogen.h" +#endif + +#include "common/event_tracer.h" + +extern "C" { + +// OpenGL ES 2.0 +void GL_APIENTRY glActiveTexture(GLenum texture) +{ + return GL_ActiveTexture(texture); +} + +void GL_APIENTRY glAttachShader(GLuint program, GLuint shader) +{ + return GL_AttachShader(program, shader); +} + +void GL_APIENTRY glBindAttribLocation(GLuint program, GLuint index, const GLchar *name) +{ + return GL_BindAttribLocation(program, index, name); +} + +void GL_APIENTRY glBindBuffer(GLenum target, GLuint buffer) +{ + return GL_BindBuffer(target, buffer); +} + +void GL_APIENTRY glBindFramebuffer(GLenum target, GLuint framebuffer) +{ + return GL_BindFramebuffer(target, framebuffer); +} + +void GL_APIENTRY glBindRenderbuffer(GLenum target, GLuint renderbuffer) +{ + return GL_BindRenderbuffer(target, renderbuffer); +} + +void GL_APIENTRY glBindTexture(GLenum target, GLuint texture) +{ + return GL_BindTexture(target, texture); +} + +void GL_APIENTRY glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + return GL_BlendColor(red, green, blue, alpha); +} + +void GL_APIENTRY glBlendEquation(GLenum mode) +{ + return GL_BlendEquation(mode); +} + +void GL_APIENTRY glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + return GL_BlendEquationSeparate(modeRGB, modeAlpha); +} + +void GL_APIENTRY glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + return GL_BlendFunc(sfactor, dfactor); +} + +void GL_APIENTRY glBlendFuncSeparate(GLenum sfactorRGB, + GLenum dfactorRGB, + GLenum sfactorAlpha, + GLenum dfactorAlpha) +{ + return GL_BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); +} + +void GL_APIENTRY glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage) +{ + return GL_BufferData(target, size, data, usage); +} + +void GL_APIENTRY glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data) +{ + return GL_BufferSubData(target, offset, size, data); +} + +GLenum GL_APIENTRY glCheckFramebufferStatus(GLenum target) +{ + return GL_CheckFramebufferStatus(target); +} + +void GL_APIENTRY glClear(GLbitfield mask) +{ + return GL_Clear(mask); +} + +void GL_APIENTRY glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + return GL_ClearColor(red, green, blue, alpha); +} + +void GL_APIENTRY glClearDepthf(GLfloat d) +{ + return GL_ClearDepthf(d); +} + +void GL_APIENTRY glClearStencil(GLint s) +{ + return GL_ClearStencil(s); +} + +void GL_APIENTRY glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + return GL_ColorMask(red, green, blue, alpha); +} + +void GL_APIENTRY glCompileShader(GLuint shader) +{ + return GL_CompileShader(shader); +} + +void GL_APIENTRY glCompressedTexImage2D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, + data); +} + +void GL_APIENTRY glCompressedTexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, + imageSize, data); +} + +void GL_APIENTRY glCopyTexImage2D(GLenum target, + GLint level, + GLenum internalformat, + GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLint border) +{ + return GL_CopyTexImage2D(target, level, internalformat, x, y, width, height, border); +} + +void GL_APIENTRY glCopyTexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +GLuint GL_APIENTRY glCreateProgram() +{ + return GL_CreateProgram(); +} + +GLuint GL_APIENTRY glCreateShader(GLenum type) +{ + return GL_CreateShader(type); +} + +void GL_APIENTRY glCullFace(GLenum mode) +{ + return GL_CullFace(mode); +} + +void GL_APIENTRY glDeleteBuffers(GLsizei n, const GLuint *buffers) +{ + return GL_DeleteBuffers(n, buffers); +} + +void GL_APIENTRY glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers) +{ + return GL_DeleteFramebuffers(n, framebuffers); +} + +void GL_APIENTRY glDeleteProgram(GLuint program) +{ + return GL_DeleteProgram(program); +} + +void GL_APIENTRY glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers) +{ + return GL_DeleteRenderbuffers(n, renderbuffers); +} + +void GL_APIENTRY glDeleteShader(GLuint shader) +{ + return GL_DeleteShader(shader); +} + +void GL_APIENTRY glDeleteTextures(GLsizei n, const GLuint *textures) +{ + return GL_DeleteTextures(n, textures); +} + +void GL_APIENTRY glDepthFunc(GLenum func) +{ + return GL_DepthFunc(func); +} + +void GL_APIENTRY glDepthMask(GLboolean flag) +{ + return GL_DepthMask(flag); +} + +void GL_APIENTRY glDepthRangef(GLfloat n, GLfloat f) +{ + return GL_DepthRangef(n, f); +} + +void GL_APIENTRY glDetachShader(GLuint program, GLuint shader) +{ + return GL_DetachShader(program, shader); +} + +void GL_APIENTRY glDisable(GLenum cap) +{ + return GL_Disable(cap); +} + +void GL_APIENTRY glDisableVertexAttribArray(GLuint index) +{ + return GL_DisableVertexAttribArray(index); +} + +void GL_APIENTRY glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + return GL_DrawArrays(mode, first, count); +} + +void GL_APIENTRY glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices) +{ + return GL_DrawElements(mode, count, type, indices); +} + +void GL_APIENTRY glEnable(GLenum cap) +{ + return GL_Enable(cap); +} + +void GL_APIENTRY glEnableVertexAttribArray(GLuint index) +{ + return GL_EnableVertexAttribArray(index); +} + +void GL_APIENTRY glFinish() +{ + return GL_Finish(); +} + +void GL_APIENTRY glFlush() +{ + return GL_Flush(); +} + +void GL_APIENTRY glFramebufferRenderbuffer(GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer) +{ + return GL_FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer); +} + +void GL_APIENTRY glFramebufferTexture2D(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level) +{ + return GL_FramebufferTexture2D(target, attachment, textarget, texture, level); +} + +void GL_APIENTRY glFrontFace(GLenum mode) +{ + return GL_FrontFace(mode); +} + +void GL_APIENTRY glGenBuffers(GLsizei n, GLuint *buffers) +{ + return GL_GenBuffers(n, buffers); +} + +void GL_APIENTRY glGenFramebuffers(GLsizei n, GLuint *framebuffers) +{ + return GL_GenFramebuffers(n, framebuffers); +} + +void GL_APIENTRY glGenRenderbuffers(GLsizei n, GLuint *renderbuffers) +{ + return GL_GenRenderbuffers(n, renderbuffers); +} + +void GL_APIENTRY glGenTextures(GLsizei n, GLuint *textures) +{ + return GL_GenTextures(n, textures); +} + +void GL_APIENTRY glGenerateMipmap(GLenum target) +{ + return GL_GenerateMipmap(target); +} + +void GL_APIENTRY glGetActiveAttrib(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name) +{ + return GL_GetActiveAttrib(program, index, bufSize, length, size, type, name); +} + +void GL_APIENTRY glGetActiveUniform(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *size, + GLenum *type, + GLchar *name) +{ + return GL_GetActiveUniform(program, index, bufSize, length, size, type, name); +} + +void GL_APIENTRY glGetAttachedShaders(GLuint program, + GLsizei maxCount, + GLsizei *count, + GLuint *shaders) +{ + return GL_GetAttachedShaders(program, maxCount, count, shaders); +} + +GLint GL_APIENTRY glGetAttribLocation(GLuint program, const GLchar *name) +{ + return GL_GetAttribLocation(program, name); +} + +void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean *data) +{ + return GL_GetBooleanv(pname, data); +} + +void GL_APIENTRY glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetBufferParameteriv(target, pname, params); +} + +GLenum GL_APIENTRY glGetError() +{ + return GL_GetError(); +} + +void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat *data) +{ + return GL_GetFloatv(pname, data); +} + +void GL_APIENTRY glGetFramebufferAttachmentParameteriv(GLenum target, + GLenum attachment, + GLenum pname, + GLint *params) +{ + return GL_GetFramebufferAttachmentParameteriv(target, attachment, pname, params); +} + +void GL_APIENTRY glGetIntegerv(GLenum pname, GLint *data) +{ + return GL_GetIntegerv(pname, data); +} + +void GL_APIENTRY glGetProgramInfoLog(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + return GL_GetProgramInfoLog(program, bufSize, length, infoLog); +} + +void GL_APIENTRY glGetProgramiv(GLuint program, GLenum pname, GLint *params) +{ + return GL_GetProgramiv(program, pname, params); +} + +void GL_APIENTRY glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetRenderbufferParameteriv(target, pname, params); +} + +void GL_APIENTRY glGetShaderInfoLog(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + return GL_GetShaderInfoLog(shader, bufSize, length, infoLog); +} + +void GL_APIENTRY glGetShaderPrecisionFormat(GLenum shadertype, + GLenum precisiontype, + GLint *range, + GLint *precision) +{ + return GL_GetShaderPrecisionFormat(shadertype, precisiontype, range, precision); +} + +void GL_APIENTRY glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source) +{ + return GL_GetShaderSource(shader, bufSize, length, source); +} + +void GL_APIENTRY glGetShaderiv(GLuint shader, GLenum pname, GLint *params) +{ + return GL_GetShaderiv(shader, pname, params); +} + +const GLubyte *GL_APIENTRY glGetString(GLenum name) +{ + return GL_GetString(name); +} + +void GL_APIENTRY glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + return GL_GetTexParameterfv(target, pname, params); +} + +void GL_APIENTRY glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetTexParameteriv(target, pname, params); +} + +GLint GL_APIENTRY glGetUniformLocation(GLuint program, const GLchar *name) +{ + return GL_GetUniformLocation(program, name); +} + +void GL_APIENTRY glGetUniformfv(GLuint program, GLint location, GLfloat *params) +{ + return GL_GetUniformfv(program, location, params); +} + +void GL_APIENTRY glGetUniformiv(GLuint program, GLint location, GLint *params) +{ + return GL_GetUniformiv(program, location, params); +} + +void GL_APIENTRY glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer) +{ + return GL_GetVertexAttribPointerv(index, pname, pointer); +} + +void GL_APIENTRY glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params) +{ + return GL_GetVertexAttribfv(index, pname, params); +} + +void GL_APIENTRY glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params) +{ + return GL_GetVertexAttribiv(index, pname, params); +} + +void GL_APIENTRY glHint(GLenum target, GLenum mode) +{ + return GL_Hint(target, mode); +} + +GLboolean GL_APIENTRY glIsBuffer(GLuint buffer) +{ + return GL_IsBuffer(buffer); +} + +GLboolean GL_APIENTRY glIsEnabled(GLenum cap) +{ + return GL_IsEnabled(cap); +} + +GLboolean GL_APIENTRY glIsFramebuffer(GLuint framebuffer) +{ + return GL_IsFramebuffer(framebuffer); +} + +GLboolean GL_APIENTRY glIsProgram(GLuint program) +{ + return GL_IsProgram(program); +} + +GLboolean GL_APIENTRY glIsRenderbuffer(GLuint renderbuffer) +{ + return GL_IsRenderbuffer(renderbuffer); +} + +GLboolean GL_APIENTRY glIsShader(GLuint shader) +{ + return GL_IsShader(shader); +} + +GLboolean GL_APIENTRY glIsTexture(GLuint texture) +{ + return GL_IsTexture(texture); +} + +void GL_APIENTRY glLineWidth(GLfloat width) +{ + return GL_LineWidth(width); +} + +void GL_APIENTRY glLinkProgram(GLuint program) +{ + return GL_LinkProgram(program); +} + +void GL_APIENTRY glPixelStorei(GLenum pname, GLint param) +{ + return GL_PixelStorei(pname, param); +} + +void GL_APIENTRY glPolygonOffset(GLfloat factor, GLfloat units) +{ + return GL_PolygonOffset(factor, units); +} + +void GL_APIENTRY glReadPixels(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + void *pixels) +{ + return GL_ReadPixels(x, y, width, height, format, type, pixels); +} + +void GL_APIENTRY glReleaseShaderCompiler() +{ + return GL_ReleaseShaderCompiler(); +} + +void GL_APIENTRY glRenderbufferStorage(GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_RenderbufferStorage(target, internalformat, width, height); +} + +void GL_APIENTRY glSampleCoverage(GLfloat value, GLboolean invert) +{ + return GL_SampleCoverage(value, invert); +} + +void GL_APIENTRY glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ + return GL_Scissor(x, y, width, height); +} + +void GL_APIENTRY glShaderBinary(GLsizei count, + const GLuint *shaders, + GLenum binaryFormat, + const void *binary, + GLsizei length) +{ + return GL_ShaderBinary(count, shaders, binaryFormat, binary, length); +} + +void GL_APIENTRY glShaderSource(GLuint shader, + GLsizei count, + const GLchar *const *string, + const GLint *length) +{ + return GL_ShaderSource(shader, count, string, length); +} + +void GL_APIENTRY glStencilFunc(GLenum func, GLint ref, GLuint mask) +{ + return GL_StencilFunc(func, ref, mask); +} + +void GL_APIENTRY glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + return GL_StencilFuncSeparate(face, func, ref, mask); +} + +void GL_APIENTRY glStencilMask(GLuint mask) +{ + return GL_StencilMask(mask); +} + +void GL_APIENTRY glStencilMaskSeparate(GLenum face, GLuint mask) +{ + return GL_StencilMaskSeparate(face, mask); +} + +void GL_APIENTRY glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + return GL_StencilOp(fail, zfail, zpass); +} + +void GL_APIENTRY glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) +{ + return GL_StencilOpSeparate(face, sfail, dpfail, dppass); +} + +void GL_APIENTRY glTexImage2D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexImage2D(target, level, internalformat, width, height, border, format, type, + pixels); +} + +void GL_APIENTRY glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + return GL_TexParameterf(target, pname, param); +} + +void GL_APIENTRY glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + return GL_TexParameterfv(target, pname, params); +} + +void GL_APIENTRY glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + return GL_TexParameteri(target, pname, param); +} + +void GL_APIENTRY glTexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + return GL_TexParameteriv(target, pname, params); +} + +void GL_APIENTRY glTexSubImage2D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +void GL_APIENTRY glUniform1f(GLint location, GLfloat v0) +{ + return GL_Uniform1f(location, v0); +} + +void GL_APIENTRY glUniform1fv(GLint location, GLsizei count, const GLfloat *value) +{ + return GL_Uniform1fv(location, count, value); +} + +void GL_APIENTRY glUniform1i(GLint location, GLint v0) +{ + return GL_Uniform1i(location, v0); +} + +void GL_APIENTRY glUniform1iv(GLint location, GLsizei count, const GLint *value) +{ + return GL_Uniform1iv(location, count, value); +} + +void GL_APIENTRY glUniform2f(GLint location, GLfloat v0, GLfloat v1) +{ + return GL_Uniform2f(location, v0, v1); +} + +void GL_APIENTRY glUniform2fv(GLint location, GLsizei count, const GLfloat *value) +{ + return GL_Uniform2fv(location, count, value); +} + +void GL_APIENTRY glUniform2i(GLint location, GLint v0, GLint v1) +{ + return GL_Uniform2i(location, v0, v1); +} + +void GL_APIENTRY glUniform2iv(GLint location, GLsizei count, const GLint *value) +{ + return GL_Uniform2iv(location, count, value); +} + +void GL_APIENTRY glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + return GL_Uniform3f(location, v0, v1, v2); +} + +void GL_APIENTRY glUniform3fv(GLint location, GLsizei count, const GLfloat *value) +{ + return GL_Uniform3fv(location, count, value); +} + +void GL_APIENTRY glUniform3i(GLint location, GLint v0, GLint v1, GLint v2) +{ + return GL_Uniform3i(location, v0, v1, v2); +} + +void GL_APIENTRY glUniform3iv(GLint location, GLsizei count, const GLint *value) +{ + return GL_Uniform3iv(location, count, value); +} + +void GL_APIENTRY glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + return GL_Uniform4f(location, v0, v1, v2, v3); +} + +void GL_APIENTRY glUniform4fv(GLint location, GLsizei count, const GLfloat *value) +{ + return GL_Uniform4fv(location, count, value); +} + +void GL_APIENTRY glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + return GL_Uniform4i(location, v0, v1, v2, v3); +} + +void GL_APIENTRY glUniform4iv(GLint location, GLsizei count, const GLint *value) +{ + return GL_Uniform4iv(location, count, value); +} + +void GL_APIENTRY glUniformMatrix2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix2fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix3fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix4fv(location, count, transpose, value); +} + +void GL_APIENTRY glUseProgram(GLuint program) +{ + return GL_UseProgram(program); +} + +void GL_APIENTRY glValidateProgram(GLuint program) +{ + return GL_ValidateProgram(program); +} + +void GL_APIENTRY glVertexAttrib1f(GLuint index, GLfloat x) +{ + return GL_VertexAttrib1f(index, x); +} + +void GL_APIENTRY glVertexAttrib1fv(GLuint index, const GLfloat *v) +{ + return GL_VertexAttrib1fv(index, v); +} + +void GL_APIENTRY glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) +{ + return GL_VertexAttrib2f(index, x, y); +} + +void GL_APIENTRY glVertexAttrib2fv(GLuint index, const GLfloat *v) +{ + return GL_VertexAttrib2fv(index, v); +} + +void GL_APIENTRY glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) +{ + return GL_VertexAttrib3f(index, x, y, z); +} + +void GL_APIENTRY glVertexAttrib3fv(GLuint index, const GLfloat *v) +{ + return GL_VertexAttrib3fv(index, v); +} + +void GL_APIENTRY glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + return GL_VertexAttrib4f(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttrib4fv(GLuint index, const GLfloat *v) +{ + return GL_VertexAttrib4fv(index, v); +} + +void GL_APIENTRY glVertexAttribPointer(GLuint index, + GLint size, + GLenum type, + GLboolean normalized, + GLsizei stride, + const void *pointer) +{ + return GL_VertexAttribPointer(index, size, type, normalized, stride, pointer); +} + +void GL_APIENTRY glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + return GL_Viewport(x, y, width, height); +} + +// OpenGL ES 3.0 +void GL_APIENTRY glBeginQuery(GLenum target, GLuint id) +{ + return GL_BeginQuery(target, id); +} + +void GL_APIENTRY glBeginTransformFeedback(GLenum primitiveMode) +{ + return GL_BeginTransformFeedback(primitiveMode); +} + +void GL_APIENTRY glBindBufferBase(GLenum target, GLuint index, GLuint buffer) +{ + return GL_BindBufferBase(target, index, buffer); +} + +void GL_APIENTRY +glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) +{ + return GL_BindBufferRange(target, index, buffer, offset, size); +} + +void GL_APIENTRY glBindSampler(GLuint unit, GLuint sampler) +{ + return GL_BindSampler(unit, sampler); +} + +void GL_APIENTRY glBindTransformFeedback(GLenum target, GLuint id) +{ + return GL_BindTransformFeedback(target, id); +} + +void GL_APIENTRY glBindVertexArray(GLuint array) +{ + return GL_BindVertexArray(array); +} + +void GL_APIENTRY glBlitFramebuffer(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + return GL_BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +void GL_APIENTRY glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) +{ + return GL_ClearBufferfi(buffer, drawbuffer, depth, stencil); +} + +void GL_APIENTRY glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value) +{ + return GL_ClearBufferfv(buffer, drawbuffer, value); +} + +void GL_APIENTRY glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value) +{ + return GL_ClearBufferiv(buffer, drawbuffer, value); +} + +void GL_APIENTRY glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value) +{ + return GL_ClearBufferuiv(buffer, drawbuffer, value); +} + +GLenum GL_APIENTRY glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + return GL_ClientWaitSync(sync, flags, timeout); +} + +void GL_APIENTRY glCompressedTexImage3D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexImage3D(target, level, internalformat, width, height, depth, border, + imageSize, data); +} + +void GL_APIENTRY glCompressedTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, data); +} + +void GL_APIENTRY glCopyBufferSubData(GLenum readTarget, + GLenum writeTarget, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size) +{ + return GL_CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); +} + +void GL_APIENTRY glCopyTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void GL_APIENTRY glDeleteQueries(GLsizei n, const GLuint *ids) +{ + return GL_DeleteQueries(n, ids); +} + +void GL_APIENTRY glDeleteSamplers(GLsizei count, const GLuint *samplers) +{ + return GL_DeleteSamplers(count, samplers); +} + +void GL_APIENTRY glDeleteSync(GLsync sync) +{ + return GL_DeleteSync(sync); +} + +void GL_APIENTRY glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids) +{ + return GL_DeleteTransformFeedbacks(n, ids); +} + +void GL_APIENTRY glDeleteVertexArrays(GLsizei n, const GLuint *arrays) +{ + return GL_DeleteVertexArrays(n, arrays); +} + +void GL_APIENTRY glDrawArraysInstanced(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount) +{ + return GL_DrawArraysInstanced(mode, first, count, instancecount); +} + +void GL_APIENTRY glDrawBuffers(GLsizei n, const GLenum *bufs) +{ + return GL_DrawBuffers(n, bufs); +} + +void GL_APIENTRY glDrawElementsInstanced(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount) +{ + return GL_DrawElementsInstanced(mode, count, type, indices, instancecount); +} + +void GL_APIENTRY glDrawRangeElements(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices) +{ + return GL_DrawRangeElements(mode, start, end, count, type, indices); +} + +void GL_APIENTRY glEndQuery(GLenum target) +{ + return GL_EndQuery(target); +} + +void GL_APIENTRY glEndTransformFeedback() +{ + return GL_EndTransformFeedback(); +} + +GLsync GL_APIENTRY glFenceSync(GLenum condition, GLbitfield flags) +{ + return GL_FenceSync(condition, flags); +} + +void GL_APIENTRY glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) +{ + return GL_FlushMappedBufferRange(target, offset, length); +} + +void GL_APIENTRY glFramebufferTextureLayer(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint layer) +{ + return GL_FramebufferTextureLayer(target, attachment, texture, level, layer); +} + +void GL_APIENTRY glGenQueries(GLsizei n, GLuint *ids) +{ + return GL_GenQueries(n, ids); +} + +void GL_APIENTRY glGenSamplers(GLsizei count, GLuint *samplers) +{ + return GL_GenSamplers(count, samplers); +} + +void GL_APIENTRY glGenTransformFeedbacks(GLsizei n, GLuint *ids) +{ + return GL_GenTransformFeedbacks(n, ids); +} + +void GL_APIENTRY glGenVertexArrays(GLsizei n, GLuint *arrays) +{ + return GL_GenVertexArrays(n, arrays); +} + +void GL_APIENTRY glGetActiveUniformBlockName(GLuint program, + GLuint uniformBlockIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformBlockName) +{ + return GL_GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, + uniformBlockName); +} + +void GL_APIENTRY glGetActiveUniformBlockiv(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLint *params) +{ + return GL_GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); +} + +void GL_APIENTRY glGetActiveUniformsiv(GLuint program, + GLsizei uniformCount, + const GLuint *uniformIndices, + GLenum pname, + GLint *params) +{ + return GL_GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); +} + +void GL_APIENTRY glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params) +{ + return GL_GetBufferParameteri64v(target, pname, params); +} + +void GL_APIENTRY glGetBufferPointerv(GLenum target, GLenum pname, void **params) +{ + return GL_GetBufferPointerv(target, pname, params); +} + +GLint GL_APIENTRY glGetFragDataLocation(GLuint program, const GLchar *name) +{ + return GL_GetFragDataLocation(program, name); +} + +void GL_APIENTRY glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data) +{ + return GL_GetInteger64i_v(target, index, data); +} + +void GL_APIENTRY glGetInteger64v(GLenum pname, GLint64 *data) +{ + return GL_GetInteger64v(pname, data); +} + +void GL_APIENTRY glGetIntegeri_v(GLenum target, GLuint index, GLint *data) +{ + return GL_GetIntegeri_v(target, index, data); +} + +void GL_APIENTRY glGetInternalformativ(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint *params) +{ + return GL_GetInternalformativ(target, internalformat, pname, count, params); +} + +void GL_APIENTRY glGetProgramBinary(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary) +{ + return GL_GetProgramBinary(program, bufSize, length, binaryFormat, binary); +} + +void GL_APIENTRY glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params) +{ + return GL_GetQueryObjectuiv(id, pname, params); +} + +void GL_APIENTRY glGetQueryiv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetQueryiv(target, pname, params); +} + +void GL_APIENTRY glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params) +{ + return GL_GetSamplerParameterfv(sampler, pname, params); +} + +void GL_APIENTRY glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params) +{ + return GL_GetSamplerParameteriv(sampler, pname, params); +} + +const GLubyte *GL_APIENTRY glGetStringi(GLenum name, GLuint index) +{ + return GL_GetStringi(name, index); +} + +void GL_APIENTRY +glGetSynciv(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values) +{ + return GL_GetSynciv(sync, pname, count, length, values); +} + +void GL_APIENTRY glGetTransformFeedbackVarying(GLuint program, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLsizei *size, + GLenum *type, + GLchar *name) +{ + return GL_GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); +} + +GLuint GL_APIENTRY glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName) +{ + return GL_GetUniformBlockIndex(program, uniformBlockName); +} + +void GL_APIENTRY glGetUniformIndices(GLuint program, + GLsizei uniformCount, + const GLchar *const *uniformNames, + GLuint *uniformIndices) +{ + return GL_GetUniformIndices(program, uniformCount, uniformNames, uniformIndices); +} + +void GL_APIENTRY glGetUniformuiv(GLuint program, GLint location, GLuint *params) +{ + return GL_GetUniformuiv(program, location, params); +} + +void GL_APIENTRY glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params) +{ + return GL_GetVertexAttribIiv(index, pname, params); +} + +void GL_APIENTRY glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params) +{ + return GL_GetVertexAttribIuiv(index, pname, params); +} + +void GL_APIENTRY glInvalidateFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments) +{ + return GL_InvalidateFramebuffer(target, numAttachments, attachments); +} + +void GL_APIENTRY glInvalidateSubFramebuffer(GLenum target, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); +} + +GLboolean GL_APIENTRY glIsQuery(GLuint id) +{ + return GL_IsQuery(id); +} + +GLboolean GL_APIENTRY glIsSampler(GLuint sampler) +{ + return GL_IsSampler(sampler); +} + +GLboolean GL_APIENTRY glIsSync(GLsync sync) +{ + return GL_IsSync(sync); +} + +GLboolean GL_APIENTRY glIsTransformFeedback(GLuint id) +{ + return GL_IsTransformFeedback(id); +} + +GLboolean GL_APIENTRY glIsVertexArray(GLuint array) +{ + return GL_IsVertexArray(array); +} + +void *GL_APIENTRY glMapBufferRange(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ + return GL_MapBufferRange(target, offset, length, access); +} + +void GL_APIENTRY glPauseTransformFeedback() +{ + return GL_PauseTransformFeedback(); +} + +void GL_APIENTRY glProgramBinary(GLuint program, + GLenum binaryFormat, + const void *binary, + GLsizei length) +{ + return GL_ProgramBinary(program, binaryFormat, binary, length); +} + +void GL_APIENTRY glProgramParameteri(GLuint program, GLenum pname, GLint value) +{ + return GL_ProgramParameteri(program, pname, value); +} + +void GL_APIENTRY glReadBuffer(GLenum src) +{ + return GL_ReadBuffer(src); +} + +void GL_APIENTRY glRenderbufferStorageMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_RenderbufferStorageMultisample(target, samples, internalformat, width, height); +} + +void GL_APIENTRY glResumeTransformFeedback() +{ + return GL_ResumeTransformFeedback(); +} + +void GL_APIENTRY glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) +{ + return GL_SamplerParameterf(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param) +{ + return GL_SamplerParameterfv(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameteri(GLuint sampler, GLenum pname, GLint param) +{ + return GL_SamplerParameteri(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param) +{ + return GL_SamplerParameteriv(sampler, pname, param); +} + +void GL_APIENTRY glTexImage3D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexImage3D(target, level, internalformat, width, height, depth, border, format, type, + pixels); +} + +void GL_APIENTRY +glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) +{ + return GL_TexStorage2D(target, levels, internalformat, width, height); +} + +void GL_APIENTRY glTexStorage3D(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + return GL_TexStorage3D(target, levels, internalformat, width, height, depth); +} + +void GL_APIENTRY glTexSubImage3D(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, + type, pixels); +} + +void GL_APIENTRY glTransformFeedbackVaryings(GLuint program, + GLsizei count, + const GLchar *const *varyings, + GLenum bufferMode) +{ + return GL_TransformFeedbackVaryings(program, count, varyings, bufferMode); +} + +void GL_APIENTRY glUniform1ui(GLint location, GLuint v0) +{ + return GL_Uniform1ui(location, v0); +} + +void GL_APIENTRY glUniform1uiv(GLint location, GLsizei count, const GLuint *value) +{ + return GL_Uniform1uiv(location, count, value); +} + +void GL_APIENTRY glUniform2ui(GLint location, GLuint v0, GLuint v1) +{ + return GL_Uniform2ui(location, v0, v1); +} + +void GL_APIENTRY glUniform2uiv(GLint location, GLsizei count, const GLuint *value) +{ + return GL_Uniform2uiv(location, count, value); +} + +void GL_APIENTRY glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + return GL_Uniform3ui(location, v0, v1, v2); +} + +void GL_APIENTRY glUniform3uiv(GLint location, GLsizei count, const GLuint *value) +{ + return GL_Uniform3uiv(location, count, value); +} + +void GL_APIENTRY glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + return GL_Uniform4ui(location, v0, v1, v2, v3); +} + +void GL_APIENTRY glUniform4uiv(GLint location, GLsizei count, const GLuint *value) +{ + return GL_Uniform4uiv(location, count, value); +} + +void GL_APIENTRY glUniformBlockBinding(GLuint program, + GLuint uniformBlockIndex, + GLuint uniformBlockBinding) +{ + return GL_UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); +} + +void GL_APIENTRY glUniformMatrix2x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix2x3fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix2x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix2x4fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix3x2fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3x4fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix3x4fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4x2fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix4x2fv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4x3fv(GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_UniformMatrix4x3fv(location, count, transpose, value); +} + +GLboolean GL_APIENTRY glUnmapBuffer(GLenum target) +{ + return GL_UnmapBuffer(target); +} + +void GL_APIENTRY glVertexAttribDivisor(GLuint index, GLuint divisor) +{ + return GL_VertexAttribDivisor(index, divisor); +} + +void GL_APIENTRY glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) +{ + return GL_VertexAttribI4i(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttribI4iv(GLuint index, const GLint *v) +{ + return GL_VertexAttribI4iv(index, v); +} + +void GL_APIENTRY glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) +{ + return GL_VertexAttribI4ui(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttribI4uiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttribI4uiv(index, v); +} + +void GL_APIENTRY +glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_VertexAttribIPointer(index, size, type, stride, pointer); +} + +void GL_APIENTRY glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) +{ + return GL_WaitSync(sync, flags, timeout); +} + +// OpenGL ES 3.1 +void GL_APIENTRY glActiveShaderProgram(GLuint pipeline, GLuint program) +{ + return GL_ActiveShaderProgram(pipeline, program); +} + +void GL_APIENTRY glBindImageTexture(GLuint unit, + GLuint texture, + GLint level, + GLboolean layered, + GLint layer, + GLenum access, + GLenum format) +{ + return GL_BindImageTexture(unit, texture, level, layered, layer, access, format); +} + +void GL_APIENTRY glBindProgramPipeline(GLuint pipeline) +{ + return GL_BindProgramPipeline(pipeline); +} + +void GL_APIENTRY glBindVertexBuffer(GLuint bindingindex, + GLuint buffer, + GLintptr offset, + GLsizei stride) +{ + return GL_BindVertexBuffer(bindingindex, buffer, offset, stride); +} + +GLuint GL_APIENTRY glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings) +{ + return GL_CreateShaderProgramv(type, count, strings); +} + +void GL_APIENTRY glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines) +{ + return GL_DeleteProgramPipelines(n, pipelines); +} + +void GL_APIENTRY glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z) +{ + return GL_DispatchCompute(num_groups_x, num_groups_y, num_groups_z); +} + +void GL_APIENTRY glDispatchComputeIndirect(GLintptr indirect) +{ + return GL_DispatchComputeIndirect(indirect); +} + +void GL_APIENTRY glDrawArraysIndirect(GLenum mode, const void *indirect) +{ + return GL_DrawArraysIndirect(mode, indirect); +} + +void GL_APIENTRY glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect) +{ + return GL_DrawElementsIndirect(mode, type, indirect); +} + +void GL_APIENTRY glFramebufferParameteri(GLenum target, GLenum pname, GLint param) +{ + return GL_FramebufferParameteri(target, pname, param); +} + +void GL_APIENTRY glGenProgramPipelines(GLsizei n, GLuint *pipelines) +{ + return GL_GenProgramPipelines(n, pipelines); +} + +void GL_APIENTRY glGetBooleani_v(GLenum target, GLuint index, GLboolean *data) +{ + return GL_GetBooleani_v(target, index, data); +} + +void GL_APIENTRY glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetFramebufferParameteriv(target, pname, params); +} + +void GL_APIENTRY glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val) +{ + return GL_GetMultisamplefv(pname, index, val); +} + +void GL_APIENTRY glGetProgramInterfaceiv(GLuint program, + GLenum programInterface, + GLenum pname, + GLint *params) +{ + return GL_GetProgramInterfaceiv(program, programInterface, pname, params); +} + +void GL_APIENTRY glGetProgramPipelineInfoLog(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + return GL_GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog); +} + +void GL_APIENTRY glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params) +{ + return GL_GetProgramPipelineiv(pipeline, pname, params); +} + +GLuint GL_APIENTRY glGetProgramResourceIndex(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + return GL_GetProgramResourceIndex(program, programInterface, name); +} + +GLint GL_APIENTRY glGetProgramResourceLocation(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + return GL_GetProgramResourceLocation(program, programInterface, name); +} + +void GL_APIENTRY glGetProgramResourceName(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name) +{ + return GL_GetProgramResourceName(program, programInterface, index, bufSize, length, name); +} + +void GL_APIENTRY glGetProgramResourceiv(GLuint program, + GLenum programInterface, + GLuint index, + GLsizei propCount, + const GLenum *props, + GLsizei count, + GLsizei *length, + GLint *params) +{ + return GL_GetProgramResourceiv(program, programInterface, index, propCount, props, count, + length, params); +} + +void GL_APIENTRY glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) +{ + return GL_GetTexLevelParameterfv(target, level, pname, params); +} + +void GL_APIENTRY glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) +{ + return GL_GetTexLevelParameteriv(target, level, pname, params); +} + +GLboolean GL_APIENTRY glIsProgramPipeline(GLuint pipeline) +{ + return GL_IsProgramPipeline(pipeline); +} + +void GL_APIENTRY glMemoryBarrier(GLbitfield barriers) +{ + return GL_MemoryBarrier(barriers); +} + +void GL_APIENTRY glMemoryBarrierByRegion(GLbitfield barriers) +{ + return GL_MemoryBarrierByRegion(barriers); +} + +void GL_APIENTRY glProgramUniform1f(GLuint program, GLint location, GLfloat v0) +{ + return GL_ProgramUniform1f(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform1fv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform1i(GLuint program, GLint location, GLint v0) +{ + return GL_ProgramUniform1i(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform1iv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform1ui(GLuint program, GLint location, GLuint v0) +{ + return GL_ProgramUniform1ui(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform1uiv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + return GL_ProgramUniform2f(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform2fv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1) +{ + return GL_ProgramUniform2i(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform2iv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1) +{ + return GL_ProgramUniform2ui(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform2uiv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + return GL_ProgramUniform3f(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform3fv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + return GL_ProgramUniform3i(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform3iv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + return GL_ProgramUniform3ui(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform3uiv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) +{ + return GL_ProgramUniform4f(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4fv(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform4fv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + return GL_ProgramUniform4i(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4iv(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform4iv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + return GL_ProgramUniform4ui(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4uiv(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform4uiv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniformMatrix2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2x3fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2x4fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3x2fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3x4fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x2fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4x2fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x3fv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4x3fv(program, location, count, transpose, value); +} + +void GL_APIENTRY glSampleMaski(GLuint maskNumber, GLbitfield mask) +{ + return GL_SampleMaski(maskNumber, mask); +} + +void GL_APIENTRY glTexStorage2DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + return GL_TexStorage2DMultisample(target, samples, internalformat, width, height, + fixedsamplelocations); +} + +void GL_APIENTRY glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program) +{ + return GL_UseProgramStages(pipeline, stages, program); +} + +void GL_APIENTRY glValidateProgramPipeline(GLuint pipeline) +{ + return GL_ValidateProgramPipeline(pipeline); +} + +void GL_APIENTRY glVertexAttribBinding(GLuint attribindex, GLuint bindingindex) +{ + return GL_VertexAttribBinding(attribindex, bindingindex); +} + +void GL_APIENTRY glVertexAttribFormat(GLuint attribindex, + GLint size, + GLenum type, + GLboolean normalized, + GLuint relativeoffset) +{ + return GL_VertexAttribFormat(attribindex, size, type, normalized, relativeoffset); +} + +void GL_APIENTRY glVertexAttribIFormat(GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset) +{ + return GL_VertexAttribIFormat(attribindex, size, type, relativeoffset); +} + +void GL_APIENTRY glVertexBindingDivisor(GLuint bindingindex, GLuint divisor) +{ + return GL_VertexBindingDivisor(bindingindex, divisor); +} + +// OpenGL ES 3.2 +void GL_APIENTRY glBlendBarrier() +{ + return GL_BlendBarrier(); +} + +void GL_APIENTRY glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + return GL_BlendEquationSeparatei(buf, modeRGB, modeAlpha); +} + +void GL_APIENTRY glBlendEquationi(GLuint buf, GLenum mode) +{ + return GL_BlendEquationi(buf, mode); +} + +void GL_APIENTRY +glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + return GL_BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void GL_APIENTRY glBlendFunci(GLuint buf, GLenum src, GLenum dst) +{ + return GL_BlendFunci(buf, src, dst); +} + +void GL_APIENTRY glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + return GL_ColorMaski(index, r, g, b, a); +} + +void GL_APIENTRY glCopyImageSubData(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) +{ + return GL_CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, + dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); +} + +void GL_APIENTRY glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam) +{ + return GL_DebugMessageCallback(callback, userParam); +} + +void GL_APIENTRY glDebugMessageControl(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + return GL_DebugMessageControl(source, type, severity, count, ids, enabled); +} + +void GL_APIENTRY glDebugMessageInsert(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + return GL_DebugMessageInsert(source, type, id, severity, length, buf); +} + +void GL_APIENTRY glDisablei(GLenum target, GLuint index) +{ + return GL_Disablei(target, index); +} + +void GL_APIENTRY glDrawElementsBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawElementsBaseVertex(mode, count, type, indices, basevertex); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertex(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + return GL_DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, + basevertex); +} + +void GL_APIENTRY glDrawRangeElementsBaseVertex(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex); +} + +void GL_APIENTRY glEnablei(GLenum target, GLuint index) +{ + return GL_Enablei(target, index); +} + +void GL_APIENTRY glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level) +{ + return GL_FramebufferTexture(target, attachment, texture, level); +} + +GLuint GL_APIENTRY glGetDebugMessageLog(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + return GL_GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, + messageLog); +} + +GLenum GL_APIENTRY glGetGraphicsResetStatus() +{ + return GL_GetGraphicsResetStatus(); +} + +void GL_APIENTRY +glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + return GL_GetObjectLabel(identifier, name, bufSize, length, label); +} + +void GL_APIENTRY glGetObjectPtrLabel(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + return GL_GetObjectPtrLabel(ptr, bufSize, length, label); +} + +void GL_APIENTRY glGetPointerv(GLenum pname, void **params) +{ + return GL_GetPointerv(pname, params); +} + +void GL_APIENTRY glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params) +{ + return GL_GetSamplerParameterIiv(sampler, pname, params); +} + +void GL_APIENTRY glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params) +{ + return GL_GetSamplerParameterIuiv(sampler, pname, params); +} + +void GL_APIENTRY glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetTexParameterIiv(target, pname, params); +} + +void GL_APIENTRY glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params) +{ + return GL_GetTexParameterIuiv(target, pname, params); +} + +void GL_APIENTRY glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params) +{ + return GL_GetnUniformfv(program, location, bufSize, params); +} + +void GL_APIENTRY glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params) +{ + return GL_GetnUniformiv(program, location, bufSize, params); +} + +void GL_APIENTRY glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params) +{ + return GL_GetnUniformuiv(program, location, bufSize, params); +} + +GLboolean GL_APIENTRY glIsEnabledi(GLenum target, GLuint index) +{ + return GL_IsEnabledi(target, index); +} + +void GL_APIENTRY glMinSampleShading(GLfloat value) +{ + return GL_MinSampleShading(value); +} + +void GL_APIENTRY glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label) +{ + return GL_ObjectLabel(identifier, name, length, label); +} + +void GL_APIENTRY glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label) +{ + return GL_ObjectPtrLabel(ptr, length, label); +} + +void GL_APIENTRY glPatchParameteri(GLenum pname, GLint value) +{ + return GL_PatchParameteri(pname, value); +} + +void GL_APIENTRY glPopDebugGroup() +{ + return GL_PopDebugGroup(); +} + +void GL_APIENTRY glPrimitiveBoundingBox(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + return GL_PrimitiveBoundingBox(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); +} + +void GL_APIENTRY glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message) +{ + return GL_PushDebugGroup(source, id, length, message); +} + +void GL_APIENTRY glReadnPixels(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data) +{ + return GL_ReadnPixels(x, y, width, height, format, type, bufSize, data); +} + +void GL_APIENTRY glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param) +{ + return GL_SamplerParameterIiv(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param) +{ + return GL_SamplerParameterIuiv(sampler, pname, param); +} + +void GL_APIENTRY glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer) +{ + return GL_TexBuffer(target, internalformat, buffer); +} + +void GL_APIENTRY glTexBufferRange(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + return GL_TexBufferRange(target, internalformat, buffer, offset, size); +} + +void GL_APIENTRY glTexParameterIiv(GLenum target, GLenum pname, const GLint *params) +{ + return GL_TexParameterIiv(target, pname, params); +} + +void GL_APIENTRY glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params) +{ + return GL_TexParameterIuiv(target, pname, params); +} + +void GL_APIENTRY glTexStorage3DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + return GL_TexStorage3DMultisample(target, samples, internalformat, width, height, depth, + fixedsamplelocations); +} + +// OpenGL ES 1.0 +void GL_APIENTRY glAlphaFunc(GLenum func, GLfloat ref) +{ + return GL_AlphaFunc(func, ref); +} + +void GL_APIENTRY glAlphaFuncx(GLenum func, GLfixed ref) +{ + return GL_AlphaFuncx(func, ref); +} + +void GL_APIENTRY glClearColorx(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + return GL_ClearColorx(red, green, blue, alpha); +} + +void GL_APIENTRY glClearDepthx(GLfixed depth) +{ + return GL_ClearDepthx(depth); +} + +void GL_APIENTRY glClientActiveTexture(GLenum texture) +{ + return GL_ClientActiveTexture(texture); +} + +void GL_APIENTRY glClipPlanef(GLenum p, const GLfloat *eqn) +{ + return GL_ClipPlanef(p, eqn); +} + +void GL_APIENTRY glClipPlanex(GLenum plane, const GLfixed *equation) +{ + return GL_ClipPlanex(plane, equation); +} + +void GL_APIENTRY glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + return GL_Color4f(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + return GL_Color4ub(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + return GL_Color4x(red, green, blue, alpha); +} + +void GL_APIENTRY glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_ColorPointer(size, type, stride, pointer); +} + +void GL_APIENTRY glDepthRangex(GLfixed n, GLfixed f) +{ + return GL_DepthRangex(n, f); +} + +void GL_APIENTRY glDisableClientState(GLenum array) +{ + return GL_DisableClientState(array); +} + +void GL_APIENTRY glEnableClientState(GLenum array) +{ + return GL_EnableClientState(array); +} + +void GL_APIENTRY glFogf(GLenum pname, GLfloat param) +{ + return GL_Fogf(pname, param); +} + +void GL_APIENTRY glFogfv(GLenum pname, const GLfloat *params) +{ + return GL_Fogfv(pname, params); +} + +void GL_APIENTRY glFogx(GLenum pname, GLfixed param) +{ + return GL_Fogx(pname, param); +} + +void GL_APIENTRY glFogxv(GLenum pname, const GLfixed *param) +{ + return GL_Fogxv(pname, param); +} + +void GL_APIENTRY glFrustumf(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) +{ + return GL_Frustumf(l, r, b, t, n, f); +} + +void GL_APIENTRY glFrustumx(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) +{ + return GL_Frustumx(l, r, b, t, n, f); +} + +void GL_APIENTRY glGetClipPlanef(GLenum plane, GLfloat *equation) +{ + return GL_GetClipPlanef(plane, equation); +} + +void GL_APIENTRY glGetClipPlanex(GLenum plane, GLfixed *equation) +{ + return GL_GetClipPlanex(plane, equation); +} + +void GL_APIENTRY glGetFixedv(GLenum pname, GLfixed *params) +{ + return GL_GetFixedv(pname, params); +} + +void GL_APIENTRY glGetLightfv(GLenum light, GLenum pname, GLfloat *params) +{ + return GL_GetLightfv(light, pname, params); +} + +void GL_APIENTRY glGetLightxv(GLenum light, GLenum pname, GLfixed *params) +{ + return GL_GetLightxv(light, pname, params); +} + +void GL_APIENTRY glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) +{ + return GL_GetMaterialfv(face, pname, params); +} + +void GL_APIENTRY glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) +{ + return GL_GetMaterialxv(face, pname, params); +} + +void GL_APIENTRY glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) +{ + return GL_GetTexEnvfv(target, pname, params); +} + +void GL_APIENTRY glGetTexEnviv(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetTexEnviv(target, pname, params); +} + +void GL_APIENTRY glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) +{ + return GL_GetTexEnvxv(target, pname, params); +} + +void GL_APIENTRY glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) +{ + return GL_GetTexParameterxv(target, pname, params); +} + +void GL_APIENTRY glLightModelf(GLenum pname, GLfloat param) +{ + return GL_LightModelf(pname, param); +} + +void GL_APIENTRY glLightModelfv(GLenum pname, const GLfloat *params) +{ + return GL_LightModelfv(pname, params); +} + +void GL_APIENTRY glLightModelx(GLenum pname, GLfixed param) +{ + return GL_LightModelx(pname, param); +} + +void GL_APIENTRY glLightModelxv(GLenum pname, const GLfixed *param) +{ + return GL_LightModelxv(pname, param); +} + +void GL_APIENTRY glLightf(GLenum light, GLenum pname, GLfloat param) +{ + return GL_Lightf(light, pname, param); +} + +void GL_APIENTRY glLightfv(GLenum light, GLenum pname, const GLfloat *params) +{ + return GL_Lightfv(light, pname, params); +} + +void GL_APIENTRY glLightx(GLenum light, GLenum pname, GLfixed param) +{ + return GL_Lightx(light, pname, param); +} + +void GL_APIENTRY glLightxv(GLenum light, GLenum pname, const GLfixed *params) +{ + return GL_Lightxv(light, pname, params); +} + +void GL_APIENTRY glLineWidthx(GLfixed width) +{ + return GL_LineWidthx(width); +} + +void GL_APIENTRY glLoadIdentity() +{ + return GL_LoadIdentity(); +} + +void GL_APIENTRY glLoadMatrixf(const GLfloat *m) +{ + return GL_LoadMatrixf(m); +} + +void GL_APIENTRY glLoadMatrixx(const GLfixed *m) +{ + return GL_LoadMatrixx(m); +} + +void GL_APIENTRY glLogicOp(GLenum opcode) +{ + return GL_LogicOp(opcode); +} + +void GL_APIENTRY glMaterialf(GLenum face, GLenum pname, GLfloat param) +{ + return GL_Materialf(face, pname, param); +} + +void GL_APIENTRY glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) +{ + return GL_Materialfv(face, pname, params); +} + +void GL_APIENTRY glMaterialx(GLenum face, GLenum pname, GLfixed param) +{ + return GL_Materialx(face, pname, param); +} + +void GL_APIENTRY glMaterialxv(GLenum face, GLenum pname, const GLfixed *param) +{ + return GL_Materialxv(face, pname, param); +} + +void GL_APIENTRY glMatrixMode(GLenum mode) +{ + return GL_MatrixMode(mode); +} + +void GL_APIENTRY glMultMatrixf(const GLfloat *m) +{ + return GL_MultMatrixf(m); +} + +void GL_APIENTRY glMultMatrixx(const GLfixed *m) +{ + return GL_MultMatrixx(m); +} + +void GL_APIENTRY glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + return GL_MultiTexCoord4f(target, s, t, r, q); +} + +void GL_APIENTRY glMultiTexCoord4x(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + return GL_MultiTexCoord4x(texture, s, t, r, q); +} + +void GL_APIENTRY glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) +{ + return GL_Normal3f(nx, ny, nz); +} + +void GL_APIENTRY glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) +{ + return GL_Normal3x(nx, ny, nz); +} + +void GL_APIENTRY glNormalPointer(GLenum type, GLsizei stride, const void *pointer) +{ + return GL_NormalPointer(type, stride, pointer); +} + +void GL_APIENTRY glOrthof(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f) +{ + return GL_Orthof(l, r, b, t, n, f); +} + +void GL_APIENTRY glOrthox(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f) +{ + return GL_Orthox(l, r, b, t, n, f); +} + +void GL_APIENTRY glPointParameterf(GLenum pname, GLfloat param) +{ + return GL_PointParameterf(pname, param); +} + +void GL_APIENTRY glPointParameterfv(GLenum pname, const GLfloat *params) +{ + return GL_PointParameterfv(pname, params); +} + +void GL_APIENTRY glPointParameterx(GLenum pname, GLfixed param) +{ + return GL_PointParameterx(pname, param); +} + +void GL_APIENTRY glPointParameterxv(GLenum pname, const GLfixed *params) +{ + return GL_PointParameterxv(pname, params); +} + +void GL_APIENTRY glPointSize(GLfloat size) +{ + return GL_PointSize(size); +} + +void GL_APIENTRY glPointSizex(GLfixed size) +{ + return GL_PointSizex(size); +} + +void GL_APIENTRY glPolygonOffsetx(GLfixed factor, GLfixed units) +{ + return GL_PolygonOffsetx(factor, units); +} + +void GL_APIENTRY glPopMatrix() +{ + return GL_PopMatrix(); +} + +void GL_APIENTRY glPushMatrix() +{ + return GL_PushMatrix(); +} + +void GL_APIENTRY glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + return GL_Rotatef(angle, x, y, z); +} + +void GL_APIENTRY glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + return GL_Rotatex(angle, x, y, z); +} + +void GL_APIENTRY glSampleCoveragex(GLclampx value, GLboolean invert) +{ + return GL_SampleCoveragex(value, invert); +} + +void GL_APIENTRY glScalef(GLfloat x, GLfloat y, GLfloat z) +{ + return GL_Scalef(x, y, z); +} + +void GL_APIENTRY glScalex(GLfixed x, GLfixed y, GLfixed z) +{ + return GL_Scalex(x, y, z); +} + +void GL_APIENTRY glShadeModel(GLenum mode) +{ + return GL_ShadeModel(mode); +} + +void GL_APIENTRY glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_TexCoordPointer(size, type, stride, pointer); +} + +void GL_APIENTRY glTexEnvf(GLenum target, GLenum pname, GLfloat param) +{ + return GL_TexEnvf(target, pname, param); +} + +void GL_APIENTRY glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) +{ + return GL_TexEnvfv(target, pname, params); +} + +void GL_APIENTRY glTexEnvi(GLenum target, GLenum pname, GLint param) +{ + return GL_TexEnvi(target, pname, param); +} + +void GL_APIENTRY glTexEnviv(GLenum target, GLenum pname, const GLint *params) +{ + return GL_TexEnviv(target, pname, params); +} + +void GL_APIENTRY glTexEnvx(GLenum target, GLenum pname, GLfixed param) +{ + return GL_TexEnvx(target, pname, param); +} + +void GL_APIENTRY glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) +{ + return GL_TexEnvxv(target, pname, params); +} + +void GL_APIENTRY glTexParameterx(GLenum target, GLenum pname, GLfixed param) +{ + return GL_TexParameterx(target, pname, param); +} + +void GL_APIENTRY glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) +{ + return GL_TexParameterxv(target, pname, params); +} + +void GL_APIENTRY glTranslatef(GLfloat x, GLfloat y, GLfloat z) +{ + return GL_Translatef(x, y, z); +} + +void GL_APIENTRY glTranslatex(GLfixed x, GLfixed y, GLfixed z) +{ + return GL_Translatex(x, y, z); +} + +void GL_APIENTRY glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_VertexPointer(size, type, stride, pointer); +} + +// GL_AMD_performance_monitor +void GL_APIENTRY glBeginPerfMonitorAMD(GLuint monitor) +{ + return GL_BeginPerfMonitorAMD(monitor); +} + +void GL_APIENTRY glDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors) +{ + return GL_DeletePerfMonitorsAMD(n, monitors); +} + +void GL_APIENTRY glEndPerfMonitorAMD(GLuint monitor) +{ + return GL_EndPerfMonitorAMD(monitor); +} + +void GL_APIENTRY glGenPerfMonitorsAMD(GLsizei n, GLuint *monitors) +{ + return GL_GenPerfMonitorsAMD(n, monitors); +} + +void GL_APIENTRY glGetPerfMonitorCounterDataAMD(GLuint monitor, + GLenum pname, + GLsizei dataSize, + GLuint *data, + GLint *bytesWritten) +{ + return GL_GetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten); +} + +void GL_APIENTRY glGetPerfMonitorCounterInfoAMD(GLuint group, + GLuint counter, + GLenum pname, + void *data) +{ + return GL_GetPerfMonitorCounterInfoAMD(group, counter, pname, data); +} + +void GL_APIENTRY glGetPerfMonitorCounterStringAMD(GLuint group, + GLuint counter, + GLsizei bufSize, + GLsizei *length, + GLchar *counterString) +{ + return GL_GetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString); +} + +void GL_APIENTRY glGetPerfMonitorCountersAMD(GLuint group, + GLint *numCounters, + GLint *maxActiveCounters, + GLsizei counterSize, + GLuint *counters) +{ + return GL_GetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, + counters); +} + +void GL_APIENTRY glGetPerfMonitorGroupStringAMD(GLuint group, + GLsizei bufSize, + GLsizei *length, + GLchar *groupString) +{ + return GL_GetPerfMonitorGroupStringAMD(group, bufSize, length, groupString); +} + +void GL_APIENTRY glGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups) +{ + return GL_GetPerfMonitorGroupsAMD(numGroups, groupsSize, groups); +} + +void GL_APIENTRY glSelectPerfMonitorCountersAMD(GLuint monitor, + GLboolean enable, + GLuint group, + GLint numCounters, + GLuint *counterList) +{ + return GL_SelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList); +} + +// GL_ANDROID_extension_pack_es31a + +// GL_ANGLE_base_vertex_base_instance +void GL_APIENTRY glDrawArraysInstancedBaseInstanceANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei instanceCount, + GLuint baseInstance) +{ + return GL_DrawArraysInstancedBaseInstanceANGLE(mode, first, count, instanceCount, baseInstance); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + GLsizei count, + GLenum type, + const GLvoid *indices, + GLsizei instanceCount, + GLint baseVertex, + GLuint baseInstance) +{ + return GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE( + mode, count, type, indices, instanceCount, baseVertex, baseInstance); +} + +void GL_APIENTRY glMultiDrawArraysInstancedBaseInstanceANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + const GLuint *baseInstances, + GLsizei drawcount) +{ + return GL_MultiDrawArraysInstancedBaseInstanceANGLE(mode, firsts, counts, instanceCounts, + baseInstances, drawcount); +} + +void GL_APIENTRY +glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + const GLint *baseVertices, + const GLuint *baseInstances, + GLsizei drawcount) +{ + return GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE( + mode, counts, type, indices, instanceCounts, baseVertices, baseInstances, drawcount); +} + +// GL_ANGLE_copy_texture_3d +void GL_APIENTRY glCopyTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + return GL_CopyTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel, + internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha); +} + +void GL_APIENTRY glCopySubTexture3DANGLE(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLint z, + GLint width, + GLint height, + GLint depth, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + return GL_CopySubTexture3DANGLE(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, + yoffset, zoffset, x, y, z, width, height, depth, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); +} + +// GL_ANGLE_depth_texture + +// GL_ANGLE_framebuffer_blit +void GL_APIENTRY glBlitFramebufferANGLE(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + return GL_BlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); +} + +// GL_ANGLE_framebuffer_multisample +void GL_APIENTRY glRenderbufferStorageMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_RenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height); +} + +// GL_ANGLE_get_image +void GL_APIENTRY +glGetTexImageANGLE(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) +{ + return GL_GetTexImageANGLE(target, level, format, type, pixels); +} + +void GL_APIENTRY glGetCompressedTexImageANGLE(GLenum target, GLint level, void *pixels) +{ + return GL_GetCompressedTexImageANGLE(target, level, pixels); +} + +void GL_APIENTRY glGetRenderbufferImageANGLE(GLenum target, + GLenum format, + GLenum type, + void *pixels) +{ + return GL_GetRenderbufferImageANGLE(target, format, type, pixels); +} + +// GL_ANGLE_get_tex_level_parameter +void GL_APIENTRY glGetTexLevelParameterivANGLE(GLenum target, + GLint level, + GLenum pname, + GLint *params) +{ + return GL_GetTexLevelParameterivANGLE(target, level, pname, params); +} + +void GL_APIENTRY glGetTexLevelParameterfvANGLE(GLenum target, + GLint level, + GLenum pname, + GLfloat *params) +{ + return GL_GetTexLevelParameterfvANGLE(target, level, pname, params); +} + +// GL_ANGLE_instanced_arrays +void GL_APIENTRY glDrawArraysInstancedANGLE(GLenum mode, + GLint first, + GLsizei count, + GLsizei primcount) +{ + return GL_DrawArraysInstancedANGLE(mode, first, count, primcount); +} + +void GL_APIENTRY glDrawElementsInstancedANGLE(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount) +{ + return GL_DrawElementsInstancedANGLE(mode, count, type, indices, primcount); +} + +void GL_APIENTRY glVertexAttribDivisorANGLE(GLuint index, GLuint divisor) +{ + return GL_VertexAttribDivisorANGLE(index, divisor); +} + +// GL_ANGLE_logic_op +void GL_APIENTRY glLogicOpANGLE(GLenum opcode) +{ + return GL_LogicOpANGLE(opcode); +} + +// GL_ANGLE_memory_object_flags +void GL_APIENTRY glTexStorageMemFlags2DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + return GL_TexStorageMemFlags2DANGLE(target, levels, internalFormat, width, height, memory, + offset, createFlags, usageFlags, imageCreateInfoPNext); +} + +void GL_APIENTRY glTexStorageMemFlags2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + return GL_TexStorageMemFlags2DMultisampleANGLE(target, samples, internalFormat, width, height, + fixedSampleLocations, memory, offset, + createFlags, usageFlags, imageCreateInfoPNext); +} + +void GL_APIENTRY glTexStorageMemFlags3DANGLE(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + return GL_TexStorageMemFlags3DANGLE(target, levels, internalFormat, width, height, depth, + memory, offset, createFlags, usageFlags, + imageCreateInfoPNext); +} + +void GL_APIENTRY glTexStorageMemFlags3DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset, + GLbitfield createFlags, + GLbitfield usageFlags, + const void *imageCreateInfoPNext) +{ + return GL_TexStorageMemFlags3DMultisampleANGLE(target, samples, internalFormat, width, height, + depth, fixedSampleLocations, memory, offset, + createFlags, usageFlags, imageCreateInfoPNext); +} + +// GL_ANGLE_memory_object_fuchsia +void GL_APIENTRY glImportMemoryZirconHandleANGLE(GLuint memory, + GLuint64 size, + GLenum handleType, + GLuint handle) +{ + return GL_ImportMemoryZirconHandleANGLE(memory, size, handleType, handle); +} + +// GL_ANGLE_multi_draw +void GL_APIENTRY glMultiDrawArraysANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + GLsizei drawcount) +{ + return GL_MultiDrawArraysANGLE(mode, firsts, counts, drawcount); +} + +void GL_APIENTRY glMultiDrawArraysInstancedANGLE(GLenum mode, + const GLint *firsts, + const GLsizei *counts, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + return GL_MultiDrawArraysInstancedANGLE(mode, firsts, counts, instanceCounts, drawcount); +} + +void GL_APIENTRY glMultiDrawElementsANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + GLsizei drawcount) +{ + return GL_MultiDrawElementsANGLE(mode, counts, type, indices, drawcount); +} + +void GL_APIENTRY glMultiDrawElementsInstancedANGLE(GLenum mode, + const GLsizei *counts, + GLenum type, + const GLvoid *const *indices, + const GLsizei *instanceCounts, + GLsizei drawcount) +{ + return GL_MultiDrawElementsInstancedANGLE(mode, counts, type, indices, instanceCounts, + drawcount); +} + +// GL_ANGLE_pack_reverse_row_order + +// GL_ANGLE_program_binary + +// GL_ANGLE_provoking_vertex +void GL_APIENTRY glProvokingVertexANGLE(GLenum mode) +{ + return GL_ProvokingVertexANGLE(mode); +} + +// GL_ANGLE_request_extension +void GL_APIENTRY glRequestExtensionANGLE(const GLchar *name) +{ + return GL_RequestExtensionANGLE(name); +} + +void GL_APIENTRY glDisableExtensionANGLE(const GLchar *name) +{ + return GL_DisableExtensionANGLE(name); +} + +// GL_ANGLE_robust_client_memory +void GL_APIENTRY glGetBooleanvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLboolean *params) +{ + return GL_GetBooleanvRobustANGLE(pname, bufSize, length, params); +} + +void GL_APIENTRY glGetBufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetBufferParameterivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetFloatvRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetFloatvRobustANGLE(pname, bufSize, length, params); +} + +void GL_APIENTRY glGetFramebufferAttachmentParameterivRobustANGLE(GLenum target, + GLenum attachment, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetFramebufferAttachmentParameterivRobustANGLE(target, attachment, pname, bufSize, + length, params); +} + +void GL_APIENTRY glGetIntegervRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *data) +{ + return GL_GetIntegervRobustANGLE(pname, bufSize, length, data); +} + +void GL_APIENTRY glGetProgramivRobustANGLE(GLuint program, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetProgramivRobustANGLE(program, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetRenderbufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetRenderbufferParameterivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetShaderivRobustANGLE(GLuint shader, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetShaderivRobustANGLE(shader, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetTexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetTexParameterfvRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetTexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetTexParameterivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetUniformfvRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glGetUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetUniformivRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glGetVertexAttribfvRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetVertexAttribfvRobustANGLE(index, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetVertexAttribivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetVertexAttribivRobustANGLE(index, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetVertexAttribPointervRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **pointer) +{ + return GL_GetVertexAttribPointervRobustANGLE(index, pname, bufSize, length, pointer); +} + +void GL_APIENTRY glReadPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *pixels) +{ + return GL_ReadPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns, + rows, pixels); +} + +void GL_APIENTRY glTexImage2DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + return GL_TexImage2DRobustANGLE(target, level, internalformat, width, height, border, format, + type, bufSize, pixels); +} + +void GL_APIENTRY glTexParameterfvRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLfloat *params) +{ + return GL_TexParameterfvRobustANGLE(target, pname, bufSize, params); +} + +void GL_APIENTRY glTexParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params) +{ + return GL_TexParameterivRobustANGLE(target, pname, bufSize, params); +} + +void GL_APIENTRY glTexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + return GL_TexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, format, type, + bufSize, pixels); +} + +void GL_APIENTRY glTexImage3DRobustANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + return GL_TexImage3DRobustANGLE(target, level, internalformat, width, height, depth, border, + format, type, bufSize, pixels); +} + +void GL_APIENTRY glTexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + const void *pixels) +{ + return GL_TexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, height, + depth, format, type, bufSize, pixels); +} + +void GL_APIENTRY glCompressedTexImage2DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + return GL_CompressedTexImage2DRobustANGLE(target, level, internalformat, width, height, border, + imageSize, dataSize, data); +} + +void GL_APIENTRY glCompressedTexSubImage2DRobustANGLE(GLenum target, + GLint level, + GLsizei xoffset, + GLsizei yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + return GL_CompressedTexSubImage2DRobustANGLE(target, level, xoffset, yoffset, width, height, + format, imageSize, dataSize, data); +} + +void GL_APIENTRY glCompressedTexImage3DRobustANGLE(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + return GL_CompressedTexImage3DRobustANGLE(target, level, internalformat, width, height, depth, + border, imageSize, dataSize, data); +} + +void GL_APIENTRY glCompressedTexSubImage3DRobustANGLE(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + GLsizei dataSize, + const GLvoid *data) +{ + return GL_CompressedTexSubImage3DRobustANGLE(target, level, xoffset, yoffset, zoffset, width, + height, depth, format, imageSize, dataSize, data); +} + +void GL_APIENTRY glGetQueryivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetQueryivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetQueryObjectuivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetQueryObjectuivRobustANGLE(id, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetBufferPointervRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params) +{ + return GL_GetBufferPointervRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetIntegeri_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint *data) +{ + return GL_GetIntegeri_vRobustANGLE(target, index, bufSize, length, data); +} + +void GL_APIENTRY glGetInternalformativRobustANGLE(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetInternalformativRobustANGLE(target, internalformat, pname, bufSize, length, + params); +} + +void GL_APIENTRY glGetVertexAttribIivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetVertexAttribIivRobustANGLE(index, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetVertexAttribIuivRobustANGLE(GLuint index, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetVertexAttribIuivRobustANGLE(index, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetUniformuivRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glGetActiveUniformBlockivRobustANGLE(GLuint program, + GLuint uniformBlockIndex, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetActiveUniformBlockivRobustANGLE(program, uniformBlockIndex, pname, bufSize, length, + params); +} + +void GL_APIENTRY glGetInteger64vRobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *data) +{ + return GL_GetInteger64vRobustANGLE(pname, bufSize, length, data); +} + +void GL_APIENTRY glGetInteger64i_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLint64 *data) +{ + return GL_GetInteger64i_vRobustANGLE(target, index, bufSize, length, data); +} + +void GL_APIENTRY glGetBufferParameteri64vRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params) +{ + return GL_GetBufferParameteri64vRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glSamplerParameterivRobustANGLE(GLuint sampler, + GLuint pname, + GLsizei bufSize, + const GLint *param) +{ + return GL_SamplerParameterivRobustANGLE(sampler, pname, bufSize, param); +} + +void GL_APIENTRY glSamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLfloat *param) +{ + return GL_SamplerParameterfvRobustANGLE(sampler, pname, bufSize, param); +} + +void GL_APIENTRY glGetSamplerParameterivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetSamplerParameterivRobustANGLE(sampler, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetSamplerParameterfvRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetSamplerParameterfvRobustANGLE(sampler, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetFramebufferParameterivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetFramebufferParameterivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetProgramInterfaceivRobustANGLE(GLuint program, + GLenum programInterface, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetProgramInterfaceivRobustANGLE(program, programInterface, pname, bufSize, length, + params); +} + +void GL_APIENTRY glGetBooleani_vRobustANGLE(GLenum target, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLboolean *data) +{ + return GL_GetBooleani_vRobustANGLE(target, index, bufSize, length, data); +} + +void GL_APIENTRY glGetMultisamplefvRobustANGLE(GLenum pname, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLfloat *val) +{ + return GL_GetMultisamplefvRobustANGLE(pname, index, bufSize, length, val); +} + +void GL_APIENTRY glGetTexLevelParameterivRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetTexLevelParameterivRobustANGLE(target, level, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetTexLevelParameterfvRobustANGLE(GLenum target, + GLint level, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetTexLevelParameterfvRobustANGLE(target, level, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetPointervRobustANGLERobustANGLE(GLenum pname, + GLsizei bufSize, + GLsizei *length, + void **params) +{ + return GL_GetPointervRobustANGLERobustANGLE(pname, bufSize, length, params); +} + +void GL_APIENTRY glReadnPixelsRobustANGLE(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + GLsizei *length, + GLsizei *columns, + GLsizei *rows, + void *data) +{ + return GL_ReadnPixelsRobustANGLE(x, y, width, height, format, type, bufSize, length, columns, + rows, data); +} + +void GL_APIENTRY glGetnUniformfvRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLfloat *params) +{ + return GL_GetnUniformfvRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glGetnUniformivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetnUniformivRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glGetnUniformuivRobustANGLE(GLuint program, + GLint location, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetnUniformuivRobustANGLE(program, location, bufSize, length, params); +} + +void GL_APIENTRY glTexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLint *params) +{ + return GL_TexParameterIivRobustANGLE(target, pname, bufSize, params); +} + +void GL_APIENTRY glTexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + const GLuint *params) +{ + return GL_TexParameterIuivRobustANGLE(target, pname, bufSize, params); +} + +void GL_APIENTRY glGetTexParameterIivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetTexParameterIivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetTexParameterIuivRobustANGLE(GLenum target, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetTexParameterIuivRobustANGLE(target, pname, bufSize, length, params); +} + +void GL_APIENTRY glSamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLint *param) +{ + return GL_SamplerParameterIivRobustANGLE(sampler, pname, bufSize, param); +} + +void GL_APIENTRY glSamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + const GLuint *param) +{ + return GL_SamplerParameterIuivRobustANGLE(sampler, pname, bufSize, param); +} + +void GL_APIENTRY glGetSamplerParameterIivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetSamplerParameterIivRobustANGLE(sampler, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetSamplerParameterIuivRobustANGLE(GLuint sampler, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint *params) +{ + return GL_GetSamplerParameterIuivRobustANGLE(sampler, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetQueryObjectivRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint *params) +{ + return GL_GetQueryObjectivRobustANGLE(id, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetQueryObjecti64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLint64 *params) +{ + return GL_GetQueryObjecti64vRobustANGLE(id, pname, bufSize, length, params); +} + +void GL_APIENTRY glGetQueryObjectui64vRobustANGLE(GLuint id, + GLenum pname, + GLsizei bufSize, + GLsizei *length, + GLuint64 *params) +{ + return GL_GetQueryObjectui64vRobustANGLE(id, pname, bufSize, length, params); +} + +// GL_ANGLE_robust_resource_initialization + +// GL_ANGLE_semaphore_fuchsia +void GL_APIENTRY glImportSemaphoreZirconHandleANGLE(GLuint semaphore, + GLenum handleType, + GLuint handle) +{ + return GL_ImportSemaphoreZirconHandleANGLE(semaphore, handleType, handle); +} + +// GL_ANGLE_shader_pixel_local_storage +void GL_APIENTRY glFramebufferMemorylessPixelLocalStorageANGLE(GLint plane, GLenum internalformat) +{ + return GL_FramebufferMemorylessPixelLocalStorageANGLE(plane, internalformat); +} + +void GL_APIENTRY glFramebufferTexturePixelLocalStorageANGLE(GLint plane, + GLuint backingtexture, + GLint level, + GLint layer) +{ + return GL_FramebufferTexturePixelLocalStorageANGLE(plane, backingtexture, level, layer); +} + +void GL_APIENTRY glBeginPixelLocalStorageANGLE(GLsizei planes, + const GLenum *loadops, + const void *cleardata) +{ + return GL_BeginPixelLocalStorageANGLE(planes, loadops, cleardata); +} + +void GL_APIENTRY glEndPixelLocalStorageANGLE() +{ + return GL_EndPixelLocalStorageANGLE(); +} + +void GL_APIENTRY glPixelLocalStorageBarrierANGLE() +{ + return GL_PixelLocalStorageBarrierANGLE(); +} + +// GL_ANGLE_texture_compression_dxt3 + +// GL_ANGLE_texture_compression_dxt5 + +// GL_ANGLE_texture_external_update +void GL_APIENTRY glTexImage2DExternalANGLE(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLsizei height, + GLint border, + GLenum format, + GLenum type) +{ + return GL_TexImage2DExternalANGLE(target, level, internalformat, width, height, border, format, + type); +} + +void GL_APIENTRY glInvalidateTextureANGLE(GLenum target) +{ + return GL_InvalidateTextureANGLE(target); +} + +// GL_ANGLE_texture_multisample +void GL_APIENTRY glTexStorage2DMultisampleANGLE(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + return GL_TexStorage2DMultisampleANGLE(target, samples, internalformat, width, height, + fixedsamplelocations); +} + +void GL_APIENTRY glGetMultisamplefvANGLE(GLenum pname, GLuint index, GLfloat *val) +{ + return GL_GetMultisamplefvANGLE(pname, index, val); +} + +void GL_APIENTRY glSampleMaskiANGLE(GLuint maskNumber, GLbitfield mask) +{ + return GL_SampleMaskiANGLE(maskNumber, mask); +} + +// GL_ANGLE_texture_usage + +// GL_ANGLE_translated_shader_source +void GL_APIENTRY glGetTranslatedShaderSourceANGLE(GLuint shader, + GLsizei bufSize, + GLsizei *length, + GLchar *source) +{ + return GL_GetTranslatedShaderSourceANGLE(shader, bufSize, length, source); +} + +// GL_ANGLE_vulkan_image +void GL_APIENTRY glAcquireTexturesANGLE(GLuint numTextures, + const GLuint *textures, + const GLenum *layouts) +{ + return GL_AcquireTexturesANGLE(numTextures, textures, layouts); +} + +void GL_APIENTRY glReleaseTexturesANGLE(GLuint numTextures, const GLuint *textures, GLenum *layouts) +{ + return GL_ReleaseTexturesANGLE(numTextures, textures, layouts); +} + +// GL_APPLE_clip_distance + +// GL_ARB_sync + +// GL_CHROMIUM_bind_uniform_location +void GL_APIENTRY glBindUniformLocationCHROMIUM(GLuint program, GLint location, const GLchar *name) +{ + return GL_BindUniformLocationCHROMIUM(program, location, name); +} + +// GL_CHROMIUM_copy_compressed_texture +void GL_APIENTRY glCompressedCopyTextureCHROMIUM(GLuint sourceId, GLuint destId) +{ + return GL_CompressedCopyTextureCHROMIUM(sourceId, destId); +} + +// GL_CHROMIUM_copy_texture +void GL_APIENTRY glCopyTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint internalFormat, + GLenum destType, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + return GL_CopyTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel, + internalFormat, destType, unpackFlipY, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha); +} + +void GL_APIENTRY glCopySubTextureCHROMIUM(GLuint sourceId, + GLint sourceLevel, + GLenum destTarget, + GLuint destId, + GLint destLevel, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLint width, + GLint height, + GLboolean unpackFlipY, + GLboolean unpackPremultiplyAlpha, + GLboolean unpackUnmultiplyAlpha) +{ + return GL_CopySubTextureCHROMIUM(sourceId, sourceLevel, destTarget, destId, destLevel, xoffset, + yoffset, x, y, width, height, unpackFlipY, + unpackPremultiplyAlpha, unpackUnmultiplyAlpha); +} + +// GL_CHROMIUM_framebuffer_mixed_samples +void GL_APIENTRY glCoverageModulationCHROMIUM(GLenum components) +{ + return GL_CoverageModulationCHROMIUM(components); +} + +// GL_CHROMIUM_lose_context +void GL_APIENTRY glLoseContextCHROMIUM(GLenum current, GLenum other) +{ + return GL_LoseContextCHROMIUM(current, other); +} + +// GL_EXT_EGL_image_array + +// GL_EXT_EGL_image_storage +void GL_APIENTRY glEGLImageTargetTexStorageEXT(GLenum target, + GLeglImageOES image, + const GLint *attrib_list) +{ + return GL_EGLImageTargetTexStorageEXT(target, image, attrib_list); +} + +void GL_APIENTRY glEGLImageTargetTextureStorageEXT(GLuint texture, + GLeglImageOES image, + const GLint *attrib_list) +{ + return GL_EGLImageTargetTextureStorageEXT(texture, image, attrib_list); +} + +// GL_EXT_YUV_target + +// GL_EXT_base_instance +void GL_APIENTRY glDrawArraysInstancedBaseInstanceEXT(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance) +{ + return GL_DrawArraysInstancedBaseInstanceEXT(mode, first, count, instancecount, baseinstance); +} + +void GL_APIENTRY glDrawElementsInstancedBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLuint baseinstance) +{ + return GL_DrawElementsInstancedBaseInstanceEXT(mode, count, type, indices, instancecount, + baseinstance); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance) +{ + return GL_DrawElementsInstancedBaseVertexBaseInstanceEXT( + mode, count, type, indices, instancecount, basevertex, baseinstance); +} + +// GL_EXT_blend_func_extended +void GL_APIENTRY glBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name) +{ + return GL_BindFragDataLocationEXT(program, color, name); +} + +void GL_APIENTRY glBindFragDataLocationIndexedEXT(GLuint program, + GLuint colorNumber, + GLuint index, + const GLchar *name) +{ + return GL_BindFragDataLocationIndexedEXT(program, colorNumber, index, name); +} + +GLint GL_APIENTRY glGetFragDataIndexEXT(GLuint program, const GLchar *name) +{ + return GL_GetFragDataIndexEXT(program, name); +} + +GLint GL_APIENTRY glGetProgramResourceLocationIndexEXT(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + return GL_GetProgramResourceLocationIndexEXT(program, programInterface, name); +} + +// GL_EXT_blend_minmax + +// GL_EXT_buffer_storage +void GL_APIENTRY glBufferStorageEXT(GLenum target, + GLsizeiptr size, + const void *data, + GLbitfield flags) +{ + return GL_BufferStorageEXT(target, size, data, flags); +} + +// GL_EXT_clip_control +void GL_APIENTRY glClipControlEXT(GLenum origin, GLenum depth) +{ + return GL_ClipControlEXT(origin, depth); +} + +// GL_EXT_clip_cull_distance + +// GL_EXT_color_buffer_float + +// GL_EXT_color_buffer_half_float + +// GL_EXT_copy_image +void GL_APIENTRY glCopyImageSubDataEXT(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) +{ + return GL_CopyImageSubDataEXT(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, + dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, + srcDepth); +} + +// GL_EXT_debug_label +void GL_APIENTRY +glGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + return GL_GetObjectLabelEXT(type, object, bufSize, length, label); +} + +void GL_APIENTRY glLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label) +{ + return GL_LabelObjectEXT(type, object, length, label); +} + +// GL_EXT_debug_marker +void GL_APIENTRY glInsertEventMarkerEXT(GLsizei length, const GLchar *marker) +{ + return GL_InsertEventMarkerEXT(length, marker); +} + +void GL_APIENTRY glPopGroupMarkerEXT() +{ + return GL_PopGroupMarkerEXT(); +} + +void GL_APIENTRY glPushGroupMarkerEXT(GLsizei length, const GLchar *marker) +{ + return GL_PushGroupMarkerEXT(length, marker); +} + +// GL_EXT_discard_framebuffer +void GL_APIENTRY glDiscardFramebufferEXT(GLenum target, + GLsizei numAttachments, + const GLenum *attachments) +{ + return GL_DiscardFramebufferEXT(target, numAttachments, attachments); +} + +// GL_EXT_disjoint_timer_query +void GL_APIENTRY glBeginQueryEXT(GLenum target, GLuint id) +{ + return GL_BeginQueryEXT(target, id); +} + +void GL_APIENTRY glDeleteQueriesEXT(GLsizei n, const GLuint *ids) +{ + return GL_DeleteQueriesEXT(n, ids); +} + +void GL_APIENTRY glEndQueryEXT(GLenum target) +{ + return GL_EndQueryEXT(target); +} + +void GL_APIENTRY glGenQueriesEXT(GLsizei n, GLuint *ids) +{ + return GL_GenQueriesEXT(n, ids); +} + +void GL_APIENTRY glGetInteger64vEXT(GLenum pname, GLint64 *data) +{ + return GL_GetInteger64vEXT(pname, data); +} + +void GL_APIENTRY glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params) +{ + return GL_GetQueryObjecti64vEXT(id, pname, params); +} + +void GL_APIENTRY glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params) +{ + return GL_GetQueryObjectivEXT(id, pname, params); +} + +void GL_APIENTRY glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params) +{ + return GL_GetQueryObjectui64vEXT(id, pname, params); +} + +void GL_APIENTRY glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params) +{ + return GL_GetQueryObjectuivEXT(id, pname, params); +} + +void GL_APIENTRY glGetQueryivEXT(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetQueryivEXT(target, pname, params); +} + +GLboolean GL_APIENTRY glIsQueryEXT(GLuint id) +{ + return GL_IsQueryEXT(id); +} + +void GL_APIENTRY glQueryCounterEXT(GLuint id, GLenum target) +{ + return GL_QueryCounterEXT(id, target); +} + +// GL_EXT_draw_buffers +void GL_APIENTRY glDrawBuffersEXT(GLsizei n, const GLenum *bufs) +{ + return GL_DrawBuffersEXT(n, bufs); +} + +// GL_EXT_draw_buffers_indexed +void GL_APIENTRY glBlendEquationSeparateiEXT(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + return GL_BlendEquationSeparateiEXT(buf, modeRGB, modeAlpha); +} + +void GL_APIENTRY glBlendEquationiEXT(GLuint buf, GLenum mode) +{ + return GL_BlendEquationiEXT(buf, mode); +} + +void GL_APIENTRY +glBlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + return GL_BlendFuncSeparateiEXT(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void GL_APIENTRY glBlendFunciEXT(GLuint buf, GLenum src, GLenum dst) +{ + return GL_BlendFunciEXT(buf, src, dst); +} + +void GL_APIENTRY glColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + return GL_ColorMaskiEXT(index, r, g, b, a); +} + +void GL_APIENTRY glDisableiEXT(GLenum target, GLuint index) +{ + return GL_DisableiEXT(target, index); +} + +void GL_APIENTRY glEnableiEXT(GLenum target, GLuint index) +{ + return GL_EnableiEXT(target, index); +} + +GLboolean GL_APIENTRY glIsEnablediEXT(GLenum target, GLuint index) +{ + return GL_IsEnablediEXT(target, index); +} + +// GL_EXT_draw_elements_base_vertex +void GL_APIENTRY glDrawElementsBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawElementsBaseVertexEXT(mode, count, type, indices, basevertex); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertexEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + return GL_DrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount, + basevertex); +} + +void GL_APIENTRY glDrawRangeElementsBaseVertexEXT(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex); +} + +void GL_APIENTRY glMultiDrawElementsBaseVertexEXT(GLenum mode, + const GLsizei *count, + GLenum type, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex) +{ + return GL_MultiDrawElementsBaseVertexEXT(mode, count, type, indices, drawcount, basevertex); +} + +// GL_EXT_external_buffer +void GL_APIENTRY glBufferStorageExternalEXT(GLenum target, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags) +{ + return GL_BufferStorageExternalEXT(target, offset, size, clientBuffer, flags); +} + +void GL_APIENTRY glNamedBufferStorageExternalEXT(GLuint buffer, + GLintptr offset, + GLsizeiptr size, + GLeglClientBufferEXT clientBuffer, + GLbitfield flags) +{ + return GL_NamedBufferStorageExternalEXT(buffer, offset, size, clientBuffer, flags); +} + +// GL_EXT_float_blend + +// GL_EXT_geometry_shader +void GL_APIENTRY glFramebufferTextureEXT(GLenum target, + GLenum attachment, + GLuint texture, + GLint level) +{ + return GL_FramebufferTextureEXT(target, attachment, texture, level); +} + +// GL_EXT_gpu_shader5 + +// GL_EXT_instanced_arrays +void GL_APIENTRY glDrawArraysInstancedEXT(GLenum mode, + GLint start, + GLsizei count, + GLsizei primcount) +{ + return GL_DrawArraysInstancedEXT(mode, start, count, primcount); +} + +void GL_APIENTRY glDrawElementsInstancedEXT(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei primcount) +{ + return GL_DrawElementsInstancedEXT(mode, count, type, indices, primcount); +} + +void GL_APIENTRY glVertexAttribDivisorEXT(GLuint index, GLuint divisor) +{ + return GL_VertexAttribDivisorEXT(index, divisor); +} + +// GL_EXT_map_buffer_range +void GL_APIENTRY glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length) +{ + return GL_FlushMappedBufferRangeEXT(target, offset, length); +} + +void *GL_APIENTRY glMapBufferRangeEXT(GLenum target, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ + return GL_MapBufferRangeEXT(target, offset, length, access); +} + +// GL_EXT_memory_object +void GL_APIENTRY glBufferStorageMemEXT(GLenum target, + GLsizeiptr size, + GLuint memory, + GLuint64 offset) +{ + return GL_BufferStorageMemEXT(target, size, memory, offset); +} + +void GL_APIENTRY glCreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects) +{ + return GL_CreateMemoryObjectsEXT(n, memoryObjects); +} + +void GL_APIENTRY glDeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects) +{ + return GL_DeleteMemoryObjectsEXT(n, memoryObjects); +} + +void GL_APIENTRY glGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params) +{ + return GL_GetMemoryObjectParameterivEXT(memoryObject, pname, params); +} + +void GL_APIENTRY glGetUnsignedBytevEXT(GLenum pname, GLubyte *data) +{ + return GL_GetUnsignedBytevEXT(pname, data); +} + +void GL_APIENTRY glGetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data) +{ + return GL_GetUnsignedBytei_vEXT(target, index, data); +} + +GLboolean GL_APIENTRY glIsMemoryObjectEXT(GLuint memoryObject) +{ + return GL_IsMemoryObjectEXT(memoryObject); +} + +void GL_APIENTRY glMemoryObjectParameterivEXT(GLuint memoryObject, + GLenum pname, + const GLint *params) +{ + return GL_MemoryObjectParameterivEXT(memoryObject, pname, params); +} + +void GL_APIENTRY glTexStorageMem2DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLuint memory, + GLuint64 offset) +{ + return GL_TexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset); +} + +void GL_APIENTRY glTexStorageMem2DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset) +{ + return GL_TexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height, + fixedSampleLocations, memory, offset); +} + +void GL_APIENTRY glTexStorageMem3DEXT(GLenum target, + GLsizei levels, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLuint memory, + GLuint64 offset) +{ + return GL_TexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory, + offset); +} + +void GL_APIENTRY glTexStorageMem3DMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalFormat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedSampleLocations, + GLuint memory, + GLuint64 offset) +{ + return GL_TexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth, + fixedSampleLocations, memory, offset); +} + +// GL_EXT_memory_object_fd +void GL_APIENTRY glImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd) +{ + return GL_ImportMemoryFdEXT(memory, size, handleType, fd); +} + +// GL_EXT_multi_draw_indirect +void GL_APIENTRY glMultiDrawArraysIndirectEXT(GLenum mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return GL_MultiDrawArraysIndirectEXT(mode, indirect, drawcount, stride); +} + +void GL_APIENTRY glMultiDrawElementsIndirectEXT(GLenum mode, + GLenum type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return GL_MultiDrawElementsIndirectEXT(mode, type, indirect, drawcount, stride); +} + +// GL_EXT_multisampled_render_to_texture +void GL_APIENTRY glFramebufferTexture2DMultisampleEXT(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLsizei samples) +{ + return GL_FramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, + samples); +} + +void GL_APIENTRY glRenderbufferStorageMultisampleEXT(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_RenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height); +} + +// GL_EXT_multisampled_render_to_texture2 + +// GL_EXT_occlusion_query_boolean + +// GL_EXT_primitive_bounding_box +void GL_APIENTRY glPrimitiveBoundingBoxEXT(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + return GL_PrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); +} + +// GL_EXT_protected_textures + +// GL_EXT_pvrtc_sRGB + +// GL_EXT_read_format_bgra + +// GL_EXT_robustness +GLenum GL_APIENTRY glGetGraphicsResetStatusEXT() +{ + return GL_GetGraphicsResetStatusEXT(); +} + +void GL_APIENTRY glGetnUniformfvEXT(GLuint program, + GLint location, + GLsizei bufSize, + GLfloat *params) +{ + return GL_GetnUniformfvEXT(program, location, bufSize, params); +} + +void GL_APIENTRY glGetnUniformivEXT(GLuint program, GLint location, GLsizei bufSize, GLint *params) +{ + return GL_GetnUniformivEXT(program, location, bufSize, params); +} + +void GL_APIENTRY glReadnPixelsEXT(GLint x, + GLint y, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + GLsizei bufSize, + void *data) +{ + return GL_ReadnPixelsEXT(x, y, width, height, format, type, bufSize, data); +} + +// GL_EXT_sRGB + +// GL_EXT_sRGB_write_control + +// GL_EXT_semaphore +void GL_APIENTRY glDeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores) +{ + return GL_DeleteSemaphoresEXT(n, semaphores); +} + +void GL_APIENTRY glGenSemaphoresEXT(GLsizei n, GLuint *semaphores) +{ + return GL_GenSemaphoresEXT(n, semaphores); +} + +void GL_APIENTRY glGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params) +{ + return GL_GetSemaphoreParameterui64vEXT(semaphore, pname, params); +} + +GLboolean GL_APIENTRY glIsSemaphoreEXT(GLuint semaphore) +{ + return GL_IsSemaphoreEXT(semaphore); +} + +void GL_APIENTRY glSemaphoreParameterui64vEXT(GLuint semaphore, + GLenum pname, + const GLuint64 *params) +{ + return GL_SemaphoreParameterui64vEXT(semaphore, pname, params); +} + +void GL_APIENTRY glSignalSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *dstLayouts) +{ + return GL_SignalSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, + textures, dstLayouts); +} + +void GL_APIENTRY glWaitSemaphoreEXT(GLuint semaphore, + GLuint numBufferBarriers, + const GLuint *buffers, + GLuint numTextureBarriers, + const GLuint *textures, + const GLenum *srcLayouts) +{ + return GL_WaitSemaphoreEXT(semaphore, numBufferBarriers, buffers, numTextureBarriers, textures, + srcLayouts); +} + +// GL_EXT_semaphore_fd +void GL_APIENTRY glImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd) +{ + return GL_ImportSemaphoreFdEXT(semaphore, handleType, fd); +} + +// GL_EXT_separate_shader_objects +void GL_APIENTRY glActiveShaderProgramEXT(GLuint pipeline, GLuint program) +{ + return GL_ActiveShaderProgramEXT(pipeline, program); +} + +void GL_APIENTRY glBindProgramPipelineEXT(GLuint pipeline) +{ + return GL_BindProgramPipelineEXT(pipeline); +} + +GLuint GL_APIENTRY glCreateShaderProgramvEXT(GLenum type, GLsizei count, const GLchar **strings) +{ + return GL_CreateShaderProgramvEXT(type, count, strings); +} + +void GL_APIENTRY glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines) +{ + return GL_DeleteProgramPipelinesEXT(n, pipelines); +} + +void GL_APIENTRY glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines) +{ + return GL_GenProgramPipelinesEXT(n, pipelines); +} + +void GL_APIENTRY glGetProgramPipelineInfoLogEXT(GLuint pipeline, + GLsizei bufSize, + GLsizei *length, + GLchar *infoLog) +{ + return GL_GetProgramPipelineInfoLogEXT(pipeline, bufSize, length, infoLog); +} + +void GL_APIENTRY glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname, GLint *params) +{ + return GL_GetProgramPipelineivEXT(pipeline, pname, params); +} + +GLboolean GL_APIENTRY glIsProgramPipelineEXT(GLuint pipeline) +{ + return GL_IsProgramPipelineEXT(pipeline); +} + +void GL_APIENTRY glProgramParameteriEXT(GLuint program, GLenum pname, GLint value) +{ + return GL_ProgramParameteriEXT(program, pname, value); +} + +void GL_APIENTRY glProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0) +{ + return GL_ProgramUniform1fEXT(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform1fvEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform1iEXT(GLuint program, GLint location, GLint v0) +{ + return GL_ProgramUniform1iEXT(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform1ivEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0) +{ + return GL_ProgramUniform1uiEXT(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform1uivEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1) +{ + return GL_ProgramUniform2fEXT(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform2fvEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1) +{ + return GL_ProgramUniform2iEXT(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform2ivEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1) +{ + return GL_ProgramUniform2uiEXT(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform2uivEXT(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) +{ + return GL_ProgramUniform3fEXT(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform3fvEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) +{ + return GL_ProgramUniform3iEXT(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform3ivEXT(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) +{ + return GL_ProgramUniform3uiEXT(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform3uivEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform4fEXT(GLuint program, + GLint location, + GLfloat v0, + GLfloat v1, + GLfloat v2, + GLfloat v3) +{ + return GL_ProgramUniform4fEXT(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4fvEXT(GLuint program, + GLint location, + GLsizei count, + const GLfloat *value) +{ + return GL_ProgramUniform4fvEXT(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) +{ + return GL_ProgramUniform4iEXT(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4ivEXT(GLuint program, + GLint location, + GLsizei count, + const GLint *value) +{ + return GL_ProgramUniform4ivEXT(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) +{ + return GL_ProgramUniform4uiEXT(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4uivEXT(GLuint program, + GLint location, + GLsizei count, + const GLuint *value) +{ + return GL_ProgramUniform4uivEXT(program, location, count, value); +} + +void GL_APIENTRY glProgramUniformMatrix2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x2fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x3fvEXT(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLfloat *value) +{ + return GL_ProgramUniformMatrix4x3fvEXT(program, location, count, transpose, value); +} + +void GL_APIENTRY glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages, GLuint program) +{ + return GL_UseProgramStagesEXT(pipeline, stages, program); +} + +void GL_APIENTRY glValidateProgramPipelineEXT(GLuint pipeline) +{ + return GL_ValidateProgramPipelineEXT(pipeline); +} + +// GL_EXT_shader_framebuffer_fetch + +// GL_EXT_shader_framebuffer_fetch_non_coherent +void GL_APIENTRY glFramebufferFetchBarrierEXT() +{ + return GL_FramebufferFetchBarrierEXT(); +} + +// GL_EXT_shader_io_blocks + +// GL_EXT_shader_non_constant_global_initializers + +// GL_EXT_shader_texture_lod + +// GL_EXT_shadow_samplers + +// GL_EXT_tessellation_shader +void GL_APIENTRY glPatchParameteriEXT(GLenum pname, GLint value) +{ + return GL_PatchParameteriEXT(pname, value); +} + +// GL_EXT_texture_border_clamp +void GL_APIENTRY glGetSamplerParameterIivEXT(GLuint sampler, GLenum pname, GLint *params) +{ + return GL_GetSamplerParameterIivEXT(sampler, pname, params); +} + +void GL_APIENTRY glGetSamplerParameterIuivEXT(GLuint sampler, GLenum pname, GLuint *params) +{ + return GL_GetSamplerParameterIuivEXT(sampler, pname, params); +} + +void GL_APIENTRY glGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetTexParameterIivEXT(target, pname, params); +} + +void GL_APIENTRY glGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params) +{ + return GL_GetTexParameterIuivEXT(target, pname, params); +} + +void GL_APIENTRY glSamplerParameterIivEXT(GLuint sampler, GLenum pname, const GLint *param) +{ + return GL_SamplerParameterIivEXT(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameterIuivEXT(GLuint sampler, GLenum pname, const GLuint *param) +{ + return GL_SamplerParameterIuivEXT(sampler, pname, param); +} + +void GL_APIENTRY glTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params) +{ + return GL_TexParameterIivEXT(target, pname, params); +} + +void GL_APIENTRY glTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params) +{ + return GL_TexParameterIuivEXT(target, pname, params); +} + +// GL_EXT_texture_buffer +void GL_APIENTRY glTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer) +{ + return GL_TexBufferEXT(target, internalformat, buffer); +} + +void GL_APIENTRY glTexBufferRangeEXT(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + return GL_TexBufferRangeEXT(target, internalformat, buffer, offset, size); +} + +// GL_EXT_texture_compression_bptc + +// GL_EXT_texture_compression_dxt1 + +// GL_EXT_texture_compression_rgtc + +// GL_EXT_texture_compression_s3tc + +// GL_EXT_texture_compression_s3tc_srgb + +// GL_EXT_texture_cube_map_array + +// GL_EXT_texture_filter_anisotropic + +// GL_EXT_texture_format_BGRA8888 + +// GL_EXT_texture_format_sRGB_override + +// GL_EXT_texture_norm16 + +// GL_EXT_texture_rg + +// GL_EXT_texture_sRGB_R8 + +// GL_EXT_texture_sRGB_RG8 + +// GL_EXT_texture_sRGB_decode + +// GL_EXT_texture_storage +void GL_APIENTRY glTexStorage1DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width) +{ + return GL_TexStorage1DEXT(target, levels, internalformat, width); +} + +void GL_APIENTRY glTexStorage2DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_TexStorage2DEXT(target, levels, internalformat, width, height); +} + +void GL_APIENTRY glTexStorage3DEXT(GLenum target, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + return GL_TexStorage3DEXT(target, levels, internalformat, width, height, depth); +} + +// GL_EXT_texture_type_2_10_10_10_REV + +// GL_EXT_unpack_subimage + +// GL_IMG_texture_compression_pvrtc + +// GL_IMG_texture_compression_pvrtc2 + +// GL_KHR_blend_equation_advanced +void GL_APIENTRY glBlendBarrierKHR() +{ + return GL_BlendBarrierKHR(); +} + +// GL_KHR_debug +void GL_APIENTRY glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback, const void *userParam) +{ + return GL_DebugMessageCallbackKHR(callback, userParam); +} + +void GL_APIENTRY glDebugMessageControlKHR(GLenum source, + GLenum type, + GLenum severity, + GLsizei count, + const GLuint *ids, + GLboolean enabled) +{ + return GL_DebugMessageControlKHR(source, type, severity, count, ids, enabled); +} + +void GL_APIENTRY glDebugMessageInsertKHR(GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + const GLchar *buf) +{ + return GL_DebugMessageInsertKHR(source, type, id, severity, length, buf); +} + +GLuint GL_APIENTRY glGetDebugMessageLogKHR(GLuint count, + GLsizei bufSize, + GLenum *sources, + GLenum *types, + GLuint *ids, + GLenum *severities, + GLsizei *lengths, + GLchar *messageLog) +{ + return GL_GetDebugMessageLogKHR(count, bufSize, sources, types, ids, severities, lengths, + messageLog); +} + +void GL_APIENTRY +glGetObjectLabelKHR(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label) +{ + return GL_GetObjectLabelKHR(identifier, name, bufSize, length, label); +} + +void GL_APIENTRY glGetObjectPtrLabelKHR(const void *ptr, + GLsizei bufSize, + GLsizei *length, + GLchar *label) +{ + return GL_GetObjectPtrLabelKHR(ptr, bufSize, length, label); +} + +void GL_APIENTRY glGetPointervKHR(GLenum pname, void **params) +{ + return GL_GetPointervKHR(pname, params); +} + +void GL_APIENTRY glObjectLabelKHR(GLenum identifier, + GLuint name, + GLsizei length, + const GLchar *label) +{ + return GL_ObjectLabelKHR(identifier, name, length, label); +} + +void GL_APIENTRY glObjectPtrLabelKHR(const void *ptr, GLsizei length, const GLchar *label) +{ + return GL_ObjectPtrLabelKHR(ptr, length, label); +} + +void GL_APIENTRY glPopDebugGroupKHR() +{ + return GL_PopDebugGroupKHR(); +} + +void GL_APIENTRY glPushDebugGroupKHR(GLenum source, + GLuint id, + GLsizei length, + const GLchar *message) +{ + return GL_PushDebugGroupKHR(source, id, length, message); +} + +// GL_KHR_no_error + +// GL_KHR_parallel_shader_compile +void GL_APIENTRY glMaxShaderCompilerThreadsKHR(GLuint count) +{ + return GL_MaxShaderCompilerThreadsKHR(count); +} + +// GL_KHR_robust_buffer_access_behavior + +// GL_KHR_texture_compression_astc_hdr + +// GL_KHR_texture_compression_astc_ldr + +// GL_KHR_texture_compression_astc_sliced_3d + +// GL_MESA_framebuffer_flip_y +void GL_APIENTRY glFramebufferParameteriMESA(GLenum target, GLenum pname, GLint param) +{ + return GL_FramebufferParameteriMESA(target, pname, param); +} + +void GL_APIENTRY glGetFramebufferParameterivMESA(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetFramebufferParameterivMESA(target, pname, params); +} + +// GL_NV_fence +void GL_APIENTRY glDeleteFencesNV(GLsizei n, const GLuint *fences) +{ + return GL_DeleteFencesNV(n, fences); +} + +void GL_APIENTRY glFinishFenceNV(GLuint fence) +{ + return GL_FinishFenceNV(fence); +} + +void GL_APIENTRY glGenFencesNV(GLsizei n, GLuint *fences) +{ + return GL_GenFencesNV(n, fences); +} + +void GL_APIENTRY glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) +{ + return GL_GetFenceivNV(fence, pname, params); +} + +GLboolean GL_APIENTRY glIsFenceNV(GLuint fence) +{ + return GL_IsFenceNV(fence); +} + +void GL_APIENTRY glSetFenceNV(GLuint fence, GLenum condition) +{ + return GL_SetFenceNV(fence, condition); +} + +GLboolean GL_APIENTRY glTestFenceNV(GLuint fence) +{ + return GL_TestFenceNV(fence); +} + +// GL_NV_framebuffer_blit +void GL_APIENTRY glBlitFramebufferNV(GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + return GL_BlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, + filter); +} + +// GL_NV_pixel_buffer_object + +// GL_NV_read_depth + +// GL_NV_read_depth_stencil + +// GL_NV_read_stencil + +// GL_NV_robustness_video_memory_purge + +// GL_NV_shader_noperspective_interpolation + +// GL_OES_EGL_image +void GL_APIENTRY glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + return GL_EGLImageTargetRenderbufferStorageOES(target, image); +} + +void GL_APIENTRY glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + return GL_EGLImageTargetTexture2DOES(target, image); +} + +// GL_OES_EGL_image_external + +// GL_OES_EGL_image_external_essl3 + +// GL_OES_compressed_ETC1_RGB8_texture + +// GL_OES_compressed_paletted_texture + +// GL_OES_copy_image +void GL_APIENTRY glCopyImageSubDataOES(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) +{ + return GL_CopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, + dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, + srcDepth); +} + +// GL_OES_depth24 + +// GL_OES_depth32 + +// GL_OES_depth_texture + +// GL_OES_draw_buffers_indexed +void GL_APIENTRY glBlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha) +{ + return GL_BlendEquationSeparateiOES(buf, modeRGB, modeAlpha); +} + +void GL_APIENTRY glBlendEquationiOES(GLuint buf, GLenum mode) +{ + return GL_BlendEquationiOES(buf, mode); +} + +void GL_APIENTRY +glBlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + return GL_BlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void GL_APIENTRY glBlendFunciOES(GLuint buf, GLenum src, GLenum dst) +{ + return GL_BlendFunciOES(buf, src, dst); +} + +void GL_APIENTRY glColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) +{ + return GL_ColorMaskiOES(index, r, g, b, a); +} + +void GL_APIENTRY glDisableiOES(GLenum target, GLuint index) +{ + return GL_DisableiOES(target, index); +} + +void GL_APIENTRY glEnableiOES(GLenum target, GLuint index) +{ + return GL_EnableiOES(target, index); +} + +GLboolean GL_APIENTRY glIsEnablediOES(GLenum target, GLuint index) +{ + return GL_IsEnablediOES(target, index); +} + +// GL_OES_draw_elements_base_vertex +void GL_APIENTRY glDrawElementsBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawElementsBaseVertexOES(mode, count, type, indices, basevertex); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertexOES(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex) +{ + return GL_DrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount, + basevertex); +} + +void GL_APIENTRY glDrawRangeElementsBaseVertexOES(GLenum mode, + GLuint start, + GLuint end, + GLsizei count, + GLenum type, + const void *indices, + GLint basevertex) +{ + return GL_DrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex); +} + +// GL_OES_draw_texture +void GL_APIENTRY glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) +{ + return GL_DrawTexfOES(x, y, z, width, height); +} + +void GL_APIENTRY glDrawTexfvOES(const GLfloat *coords) +{ + return GL_DrawTexfvOES(coords); +} + +void GL_APIENTRY glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) +{ + return GL_DrawTexiOES(x, y, z, width, height); +} + +void GL_APIENTRY glDrawTexivOES(const GLint *coords) +{ + return GL_DrawTexivOES(coords); +} + +void GL_APIENTRY glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) +{ + return GL_DrawTexsOES(x, y, z, width, height); +} + +void GL_APIENTRY glDrawTexsvOES(const GLshort *coords) +{ + return GL_DrawTexsvOES(coords); +} + +void GL_APIENTRY glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) +{ + return GL_DrawTexxOES(x, y, z, width, height); +} + +void GL_APIENTRY glDrawTexxvOES(const GLfixed *coords) +{ + return GL_DrawTexxvOES(coords); +} + +// GL_OES_element_index_uint + +// GL_OES_fbo_render_mipmap + +// GL_OES_framebuffer_object +void GL_APIENTRY glBindFramebufferOES(GLenum target, GLuint framebuffer) +{ + return GL_BindFramebufferOES(target, framebuffer); +} + +void GL_APIENTRY glBindRenderbufferOES(GLenum target, GLuint renderbuffer) +{ + return GL_BindRenderbufferOES(target, renderbuffer); +} + +GLenum GL_APIENTRY glCheckFramebufferStatusOES(GLenum target) +{ + return GL_CheckFramebufferStatusOES(target); +} + +void GL_APIENTRY glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers) +{ + return GL_DeleteFramebuffersOES(n, framebuffers); +} + +void GL_APIENTRY glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers) +{ + return GL_DeleteRenderbuffersOES(n, renderbuffers); +} + +void GL_APIENTRY glFramebufferRenderbufferOES(GLenum target, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer) +{ + return GL_FramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer); +} + +void GL_APIENTRY glFramebufferTexture2DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level) +{ + return GL_FramebufferTexture2DOES(target, attachment, textarget, texture, level); +} + +void GL_APIENTRY glGenFramebuffersOES(GLsizei n, GLuint *framebuffers) +{ + return GL_GenFramebuffersOES(n, framebuffers); +} + +void GL_APIENTRY glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) +{ + return GL_GenRenderbuffersOES(n, renderbuffers); +} + +void GL_APIENTRY glGenerateMipmapOES(GLenum target) +{ + return GL_GenerateMipmapOES(target); +} + +void GL_APIENTRY glGetFramebufferAttachmentParameterivOES(GLenum target, + GLenum attachment, + GLenum pname, + GLint *params) +{ + return GL_GetFramebufferAttachmentParameterivOES(target, attachment, pname, params); +} + +void GL_APIENTRY glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetRenderbufferParameterivOES(target, pname, params); +} + +GLboolean GL_APIENTRY glIsFramebufferOES(GLuint framebuffer) +{ + return GL_IsFramebufferOES(framebuffer); +} + +GLboolean GL_APIENTRY glIsRenderbufferOES(GLuint renderbuffer) +{ + return GL_IsRenderbufferOES(renderbuffer); +} + +void GL_APIENTRY glRenderbufferStorageOES(GLenum target, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_RenderbufferStorageOES(target, internalformat, width, height); +} + +// GL_OES_geometry_shader +void GL_APIENTRY glFramebufferTextureOES(GLenum target, + GLenum attachment, + GLuint texture, + GLint level) +{ + return GL_FramebufferTextureOES(target, attachment, texture, level); +} + +// GL_OES_get_program_binary +void GL_APIENTRY glGetProgramBinaryOES(GLuint program, + GLsizei bufSize, + GLsizei *length, + GLenum *binaryFormat, + void *binary) +{ + return GL_GetProgramBinaryOES(program, bufSize, length, binaryFormat, binary); +} + +void GL_APIENTRY glProgramBinaryOES(GLuint program, + GLenum binaryFormat, + const void *binary, + GLint length) +{ + return GL_ProgramBinaryOES(program, binaryFormat, binary, length); +} + +// GL_OES_mapbuffer +void GL_APIENTRY glGetBufferPointervOES(GLenum target, GLenum pname, void **params) +{ + return GL_GetBufferPointervOES(target, pname, params); +} + +void *GL_APIENTRY glMapBufferOES(GLenum target, GLenum access) +{ + return GL_MapBufferOES(target, access); +} + +GLboolean GL_APIENTRY glUnmapBufferOES(GLenum target) +{ + return GL_UnmapBufferOES(target); +} + +// GL_OES_matrix_palette +void GL_APIENTRY glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) +{ + return GL_CurrentPaletteMatrixOES(matrixpaletteindex); +} + +void GL_APIENTRY glLoadPaletteFromModelViewMatrixOES() +{ + return GL_LoadPaletteFromModelViewMatrixOES(); +} + +void GL_APIENTRY glMatrixIndexPointerOES(GLint size, + GLenum type, + GLsizei stride, + const void *pointer) +{ + return GL_MatrixIndexPointerOES(size, type, stride, pointer); +} + +void GL_APIENTRY glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_WeightPointerOES(size, type, stride, pointer); +} + +// GL_OES_packed_depth_stencil + +// GL_OES_point_size_array +void GL_APIENTRY glPointSizePointerOES(GLenum type, GLsizei stride, const void *pointer) +{ + return GL_PointSizePointerOES(type, stride, pointer); +} + +// GL_OES_point_sprite + +// GL_OES_primitive_bounding_box +void GL_APIENTRY glPrimitiveBoundingBoxOES(GLfloat minX, + GLfloat minY, + GLfloat minZ, + GLfloat minW, + GLfloat maxX, + GLfloat maxY, + GLfloat maxZ, + GLfloat maxW) +{ + return GL_PrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); +} + +// GL_OES_query_matrix +GLbitfield GL_APIENTRY glQueryMatrixxOES(GLfixed *mantissa, GLint *exponent) +{ + return GL_QueryMatrixxOES(mantissa, exponent); +} + +// GL_OES_rgb8_rgba8 + +// GL_OES_sample_shading +void GL_APIENTRY glMinSampleShadingOES(GLfloat value) +{ + return GL_MinSampleShadingOES(value); +} + +// GL_OES_sample_variables + +// GL_OES_shader_image_atomic + +// GL_OES_shader_io_blocks + +// GL_OES_shader_multisample_interpolation + +// GL_OES_standard_derivatives + +// GL_OES_surfaceless_context + +// GL_OES_texture_3D +void GL_APIENTRY glCompressedTexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexImage3DOES(target, level, internalformat, width, height, depth, border, + imageSize, data); +} + +void GL_APIENTRY glCompressedTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, data); +} + +void GL_APIENTRY glCopyTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_CopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void GL_APIENTRY glFramebufferTexture3DOES(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLint zoffset) +{ + return GL_FramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset); +} + +void GL_APIENTRY glTexImage3DOES(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexImage3DOES(target, level, internalformat, width, height, depth, border, format, + type, pixels); +} + +void GL_APIENTRY glTexSubImage3DOES(GLenum target, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, + format, type, pixels); +} + +// GL_OES_texture_border_clamp +void GL_APIENTRY glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint *params) +{ + return GL_GetSamplerParameterIivOES(sampler, pname, params); +} + +void GL_APIENTRY glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint *params) +{ + return GL_GetSamplerParameterIuivOES(sampler, pname, params); +} + +void GL_APIENTRY glGetTexParameterIivOES(GLenum target, GLenum pname, GLint *params) +{ + return GL_GetTexParameterIivOES(target, pname, params); +} + +void GL_APIENTRY glGetTexParameterIuivOES(GLenum target, GLenum pname, GLuint *params) +{ + return GL_GetTexParameterIuivOES(target, pname, params); +} + +void GL_APIENTRY glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint *param) +{ + return GL_SamplerParameterIivOES(sampler, pname, param); +} + +void GL_APIENTRY glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint *param) +{ + return GL_SamplerParameterIuivOES(sampler, pname, param); +} + +void GL_APIENTRY glTexParameterIivOES(GLenum target, GLenum pname, const GLint *params) +{ + return GL_TexParameterIivOES(target, pname, params); +} + +void GL_APIENTRY glTexParameterIuivOES(GLenum target, GLenum pname, const GLuint *params) +{ + return GL_TexParameterIuivOES(target, pname, params); +} + +// GL_OES_texture_buffer +void GL_APIENTRY glTexBufferOES(GLenum target, GLenum internalformat, GLuint buffer) +{ + return GL_TexBufferOES(target, internalformat, buffer); +} + +void GL_APIENTRY glTexBufferRangeOES(GLenum target, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + return GL_TexBufferRangeOES(target, internalformat, buffer, offset, size); +} + +// GL_OES_texture_compression_astc + +// GL_OES_texture_cube_map +void GL_APIENTRY glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) +{ + return GL_GetTexGenfvOES(coord, pname, params); +} + +void GL_APIENTRY glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) +{ + return GL_GetTexGenivOES(coord, pname, params); +} + +void GL_APIENTRY glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) +{ + return GL_GetTexGenxvOES(coord, pname, params); +} + +void GL_APIENTRY glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) +{ + return GL_TexGenfOES(coord, pname, param); +} + +void GL_APIENTRY glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) +{ + return GL_TexGenfvOES(coord, pname, params); +} + +void GL_APIENTRY glTexGeniOES(GLenum coord, GLenum pname, GLint param) +{ + return GL_TexGeniOES(coord, pname, param); +} + +void GL_APIENTRY glTexGenivOES(GLenum coord, GLenum pname, const GLint *params) +{ + return GL_TexGenivOES(coord, pname, params); +} + +void GL_APIENTRY glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) +{ + return GL_TexGenxOES(coord, pname, param); +} + +void GL_APIENTRY glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) +{ + return GL_TexGenxvOES(coord, pname, params); +} + +// GL_OES_texture_cube_map_array + +// GL_OES_texture_float + +// GL_OES_texture_float_linear + +// GL_OES_texture_half_float + +// GL_OES_texture_half_float_linear + +// GL_OES_texture_npot + +// GL_OES_texture_stencil8 + +// GL_OES_texture_storage_multisample_2d_array +void GL_APIENTRY glTexStorage3DMultisampleOES(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + return GL_TexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, + fixedsamplelocations); +} + +// GL_OES_vertex_array_object +void GL_APIENTRY glBindVertexArrayOES(GLuint array) +{ + return GL_BindVertexArrayOES(array); +} + +void GL_APIENTRY glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) +{ + return GL_DeleteVertexArraysOES(n, arrays); +} + +void GL_APIENTRY glGenVertexArraysOES(GLsizei n, GLuint *arrays) +{ + return GL_GenVertexArraysOES(n, arrays); +} + +GLboolean GL_APIENTRY glIsVertexArrayOES(GLuint array) +{ + return GL_IsVertexArrayOES(array); +} + +// GL_OES_vertex_half_float + +// GL_OES_vertex_type_10_10_10_2 + +// GL_OVR_multiview +void GL_APIENTRY glFramebufferTextureMultiviewOVR(GLenum target, + GLenum attachment, + GLuint texture, + GLint level, + GLint baseViewIndex, + GLsizei numViews) +{ + return GL_FramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, + numViews); +} + +// GL_OVR_multiview2 + +// GL_QCOM_shading_rate +void GL_APIENTRY glShadingRateQCOM(GLenum rate) +{ + return GL_ShadingRateQCOM(rate); +} + +#if defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND) + +// GL 1.0 +void GL_APIENTRY glAccum(GLenum op, GLfloat value) +{ + return GL_Accum(op, value); +} + +void GL_APIENTRY glBegin(GLenum mode) +{ + return GL_Begin(mode); +} + +void GL_APIENTRY glBitmap(GLsizei width, + GLsizei height, + GLfloat xorig, + GLfloat yorig, + GLfloat xmove, + GLfloat ymove, + const GLubyte *bitmap) +{ + return GL_Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap); +} + +void GL_APIENTRY glCallList(GLuint list) +{ + return GL_CallList(list); +} + +void GL_APIENTRY glCallLists(GLsizei n, GLenum type, const void *lists) +{ + return GL_CallLists(n, type, lists); +} + +void GL_APIENTRY glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + return GL_ClearAccum(red, green, blue, alpha); +} + +void GL_APIENTRY glClearDepth(GLdouble depth) +{ + return GL_ClearDepth(depth); +} + +void GL_APIENTRY glClearIndex(GLfloat c) +{ + return GL_ClearIndex(c); +} + +void GL_APIENTRY glClipPlane(GLenum plane, const GLdouble *equation) +{ + return GL_ClipPlane(plane, equation); +} + +void GL_APIENTRY glColor3b(GLbyte red, GLbyte green, GLbyte blue) +{ + return GL_Color3b(red, green, blue); +} + +void GL_APIENTRY glColor3bv(const GLbyte *v) +{ + return GL_Color3bv(v); +} + +void GL_APIENTRY glColor3d(GLdouble red, GLdouble green, GLdouble blue) +{ + return GL_Color3d(red, green, blue); +} + +void GL_APIENTRY glColor3dv(const GLdouble *v) +{ + return GL_Color3dv(v); +} + +void GL_APIENTRY glColor3f(GLfloat red, GLfloat green, GLfloat blue) +{ + return GL_Color3f(red, green, blue); +} + +void GL_APIENTRY glColor3fv(const GLfloat *v) +{ + return GL_Color3fv(v); +} + +void GL_APIENTRY glColor3i(GLint red, GLint green, GLint blue) +{ + return GL_Color3i(red, green, blue); +} + +void GL_APIENTRY glColor3iv(const GLint *v) +{ + return GL_Color3iv(v); +} + +void GL_APIENTRY glColor3s(GLshort red, GLshort green, GLshort blue) +{ + return GL_Color3s(red, green, blue); +} + +void GL_APIENTRY glColor3sv(const GLshort *v) +{ + return GL_Color3sv(v); +} + +void GL_APIENTRY glColor3ub(GLubyte red, GLubyte green, GLubyte blue) +{ + return GL_Color3ub(red, green, blue); +} + +void GL_APIENTRY glColor3ubv(const GLubyte *v) +{ + return GL_Color3ubv(v); +} + +void GL_APIENTRY glColor3ui(GLuint red, GLuint green, GLuint blue) +{ + return GL_Color3ui(red, green, blue); +} + +void GL_APIENTRY glColor3uiv(const GLuint *v) +{ + return GL_Color3uiv(v); +} + +void GL_APIENTRY glColor3us(GLushort red, GLushort green, GLushort blue) +{ + return GL_Color3us(red, green, blue); +} + +void GL_APIENTRY glColor3usv(const GLushort *v) +{ + return GL_Color3usv(v); +} + +void GL_APIENTRY glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) +{ + return GL_Color4b(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4bv(const GLbyte *v) +{ + return GL_Color4bv(v); +} + +void GL_APIENTRY glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) +{ + return GL_Color4d(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4dv(const GLdouble *v) +{ + return GL_Color4dv(v); +} + +void GL_APIENTRY glColor4fv(const GLfloat *v) +{ + return GL_Color4fv(v); +} + +void GL_APIENTRY glColor4i(GLint red, GLint green, GLint blue, GLint alpha) +{ + return GL_Color4i(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4iv(const GLint *v) +{ + return GL_Color4iv(v); +} + +void GL_APIENTRY glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) +{ + return GL_Color4s(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4sv(const GLshort *v) +{ + return GL_Color4sv(v); +} + +void GL_APIENTRY glColor4ubv(const GLubyte *v) +{ + return GL_Color4ubv(v); +} + +void GL_APIENTRY glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) +{ + return GL_Color4ui(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4uiv(const GLuint *v) +{ + return GL_Color4uiv(v); +} + +void GL_APIENTRY glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) +{ + return GL_Color4us(red, green, blue, alpha); +} + +void GL_APIENTRY glColor4usv(const GLushort *v) +{ + return GL_Color4usv(v); +} + +void GL_APIENTRY glColorMaterial(GLenum face, GLenum mode) +{ + return GL_ColorMaterial(face, mode); +} + +void GL_APIENTRY glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) +{ + return GL_CopyPixels(x, y, width, height, type); +} + +void GL_APIENTRY glDeleteLists(GLuint list, GLsizei range) +{ + return GL_DeleteLists(list, range); +} + +void GL_APIENTRY glDepthRange(GLdouble n, GLdouble f) +{ + return GL_DepthRange(n, f); +} + +void GL_APIENTRY glDrawBuffer(GLenum buf) +{ + return GL_DrawBuffer(buf); +} + +void GL_APIENTRY +glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels) +{ + return GL_DrawPixels(width, height, format, type, pixels); +} + +void GL_APIENTRY glEdgeFlag(GLboolean flag) +{ + return GL_EdgeFlag(flag); +} + +void GL_APIENTRY glEdgeFlagv(const GLboolean *flag) +{ + return GL_EdgeFlagv(flag); +} + +void GL_APIENTRY glEnd() +{ + return GL_End(); +} + +void GL_APIENTRY glEndList() +{ + return GL_EndList(); +} + +void GL_APIENTRY glEvalCoord1d(GLdouble u) +{ + return GL_EvalCoord1d(u); +} + +void GL_APIENTRY glEvalCoord1dv(const GLdouble *u) +{ + return GL_EvalCoord1dv(u); +} + +void GL_APIENTRY glEvalCoord1f(GLfloat u) +{ + return GL_EvalCoord1f(u); +} + +void GL_APIENTRY glEvalCoord1fv(const GLfloat *u) +{ + return GL_EvalCoord1fv(u); +} + +void GL_APIENTRY glEvalCoord2d(GLdouble u, GLdouble v) +{ + return GL_EvalCoord2d(u, v); +} + +void GL_APIENTRY glEvalCoord2dv(const GLdouble *u) +{ + return GL_EvalCoord2dv(u); +} + +void GL_APIENTRY glEvalCoord2f(GLfloat u, GLfloat v) +{ + return GL_EvalCoord2f(u, v); +} + +void GL_APIENTRY glEvalCoord2fv(const GLfloat *u) +{ + return GL_EvalCoord2fv(u); +} + +void GL_APIENTRY glEvalMesh1(GLenum mode, GLint i1, GLint i2) +{ + return GL_EvalMesh1(mode, i1, i2); +} + +void GL_APIENTRY glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) +{ + return GL_EvalMesh2(mode, i1, i2, j1, j2); +} + +void GL_APIENTRY glEvalPoint1(GLint i) +{ + return GL_EvalPoint1(i); +} + +void GL_APIENTRY glEvalPoint2(GLint i, GLint j) +{ + return GL_EvalPoint2(i, j); +} + +void GL_APIENTRY glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) +{ + return GL_FeedbackBuffer(size, type, buffer); +} + +void GL_APIENTRY glFogi(GLenum pname, GLint param) +{ + return GL_Fogi(pname, param); +} + +void GL_APIENTRY glFogiv(GLenum pname, const GLint *params) +{ + return GL_Fogiv(pname, params); +} + +void GL_APIENTRY glFrustum(GLdouble left, + GLdouble right, + GLdouble bottom, + GLdouble top, + GLdouble zNear, + GLdouble zFar) +{ + return GL_Frustum(left, right, bottom, top, zNear, zFar); +} + +GLuint GL_APIENTRY glGenLists(GLsizei range) +{ + return GL_GenLists(range); +} + +void GL_APIENTRY glGetClipPlane(GLenum plane, GLdouble *equation) +{ + return GL_GetClipPlane(plane, equation); +} + +void GL_APIENTRY glGetDoublev(GLenum pname, GLdouble *data) +{ + return GL_GetDoublev(pname, data); +} + +void GL_APIENTRY glGetLightiv(GLenum light, GLenum pname, GLint *params) +{ + return GL_GetLightiv(light, pname, params); +} + +void GL_APIENTRY glGetMapdv(GLenum target, GLenum query, GLdouble *v) +{ + return GL_GetMapdv(target, query, v); +} + +void GL_APIENTRY glGetMapfv(GLenum target, GLenum query, GLfloat *v) +{ + return GL_GetMapfv(target, query, v); +} + +void GL_APIENTRY glGetMapiv(GLenum target, GLenum query, GLint *v) +{ + return GL_GetMapiv(target, query, v); +} + +void GL_APIENTRY glGetMaterialiv(GLenum face, GLenum pname, GLint *params) +{ + return GL_GetMaterialiv(face, pname, params); +} + +void GL_APIENTRY glGetPixelMapfv(GLenum map, GLfloat *values) +{ + return GL_GetPixelMapfv(map, values); +} + +void GL_APIENTRY glGetPixelMapuiv(GLenum map, GLuint *values) +{ + return GL_GetPixelMapuiv(map, values); +} + +void GL_APIENTRY glGetPixelMapusv(GLenum map, GLushort *values) +{ + return GL_GetPixelMapusv(map, values); +} + +void GL_APIENTRY glGetPolygonStipple(GLubyte *mask) +{ + return GL_GetPolygonStipple(mask); +} + +void GL_APIENTRY glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) +{ + return GL_GetTexGendv(coord, pname, params); +} + +void GL_APIENTRY glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) +{ + return GL_GetTexGenfv(coord, pname, params); +} + +void GL_APIENTRY glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) +{ + return GL_GetTexGeniv(coord, pname, params); +} + +void GL_APIENTRY glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels) +{ + return GL_GetTexImage(target, level, format, type, pixels); +} + +void GL_APIENTRY glIndexMask(GLuint mask) +{ + return GL_IndexMask(mask); +} + +void GL_APIENTRY glIndexd(GLdouble c) +{ + return GL_Indexd(c); +} + +void GL_APIENTRY glIndexdv(const GLdouble *c) +{ + return GL_Indexdv(c); +} + +void GL_APIENTRY glIndexf(GLfloat c) +{ + return GL_Indexf(c); +} + +void GL_APIENTRY glIndexfv(const GLfloat *c) +{ + return GL_Indexfv(c); +} + +void GL_APIENTRY glIndexi(GLint c) +{ + return GL_Indexi(c); +} + +void GL_APIENTRY glIndexiv(const GLint *c) +{ + return GL_Indexiv(c); +} + +void GL_APIENTRY glIndexs(GLshort c) +{ + return GL_Indexs(c); +} + +void GL_APIENTRY glIndexsv(const GLshort *c) +{ + return GL_Indexsv(c); +} + +void GL_APIENTRY glInitNames() +{ + return GL_InitNames(); +} + +GLboolean GL_APIENTRY glIsList(GLuint list) +{ + return GL_IsList(list); +} + +void GL_APIENTRY glLightModeli(GLenum pname, GLint param) +{ + return GL_LightModeli(pname, param); +} + +void GL_APIENTRY glLightModeliv(GLenum pname, const GLint *params) +{ + return GL_LightModeliv(pname, params); +} + +void GL_APIENTRY glLighti(GLenum light, GLenum pname, GLint param) +{ + return GL_Lighti(light, pname, param); +} + +void GL_APIENTRY glLightiv(GLenum light, GLenum pname, const GLint *params) +{ + return GL_Lightiv(light, pname, params); +} + +void GL_APIENTRY glLineStipple(GLint factor, GLushort pattern) +{ + return GL_LineStipple(factor, pattern); +} + +void GL_APIENTRY glListBase(GLuint base) +{ + return GL_ListBase(base); +} + +void GL_APIENTRY glLoadMatrixd(const GLdouble *m) +{ + return GL_LoadMatrixd(m); +} + +void GL_APIENTRY glLoadName(GLuint name) +{ + return GL_LoadName(name); +} + +void GL_APIENTRY +glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) +{ + return GL_Map1d(target, u1, u2, stride, order, points); +} + +void GL_APIENTRY +glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) +{ + return GL_Map1f(target, u1, u2, stride, order, points); +} + +void GL_APIENTRY glMap2d(GLenum target, + GLdouble u1, + GLdouble u2, + GLint ustride, + GLint uorder, + GLdouble v1, + GLdouble v2, + GLint vstride, + GLint vorder, + const GLdouble *points) +{ + return GL_Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void GL_APIENTRY glMap2f(GLenum target, + GLfloat u1, + GLfloat u2, + GLint ustride, + GLint uorder, + GLfloat v1, + GLfloat v2, + GLint vstride, + GLint vorder, + const GLfloat *points) +{ + return GL_Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points); +} + +void GL_APIENTRY glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) +{ + return GL_MapGrid1d(un, u1, u2); +} + +void GL_APIENTRY glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) +{ + return GL_MapGrid1f(un, u1, u2); +} + +void GL_APIENTRY glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) +{ + return GL_MapGrid2d(un, u1, u2, vn, v1, v2); +} + +void GL_APIENTRY glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) +{ + return GL_MapGrid2f(un, u1, u2, vn, v1, v2); +} + +void GL_APIENTRY glMateriali(GLenum face, GLenum pname, GLint param) +{ + return GL_Materiali(face, pname, param); +} + +void GL_APIENTRY glMaterialiv(GLenum face, GLenum pname, const GLint *params) +{ + return GL_Materialiv(face, pname, params); +} + +void GL_APIENTRY glMultMatrixd(const GLdouble *m) +{ + return GL_MultMatrixd(m); +} + +void GL_APIENTRY glNewList(GLuint list, GLenum mode) +{ + return GL_NewList(list, mode); +} + +void GL_APIENTRY glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) +{ + return GL_Normal3b(nx, ny, nz); +} + +void GL_APIENTRY glNormal3bv(const GLbyte *v) +{ + return GL_Normal3bv(v); +} + +void GL_APIENTRY glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) +{ + return GL_Normal3d(nx, ny, nz); +} + +void GL_APIENTRY glNormal3dv(const GLdouble *v) +{ + return GL_Normal3dv(v); +} + +void GL_APIENTRY glNormal3fv(const GLfloat *v) +{ + return GL_Normal3fv(v); +} + +void GL_APIENTRY glNormal3i(GLint nx, GLint ny, GLint nz) +{ + return GL_Normal3i(nx, ny, nz); +} + +void GL_APIENTRY glNormal3iv(const GLint *v) +{ + return GL_Normal3iv(v); +} + +void GL_APIENTRY glNormal3s(GLshort nx, GLshort ny, GLshort nz) +{ + return GL_Normal3s(nx, ny, nz); +} + +void GL_APIENTRY glNormal3sv(const GLshort *v) +{ + return GL_Normal3sv(v); +} + +void GL_APIENTRY +glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) +{ + return GL_Ortho(left, right, bottom, top, zNear, zFar); +} + +void GL_APIENTRY glPassThrough(GLfloat token) +{ + return GL_PassThrough(token); +} + +void GL_APIENTRY glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values) +{ + return GL_PixelMapfv(map, mapsize, values); +} + +void GL_APIENTRY glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values) +{ + return GL_PixelMapuiv(map, mapsize, values); +} + +void GL_APIENTRY glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values) +{ + return GL_PixelMapusv(map, mapsize, values); +} + +void GL_APIENTRY glPixelStoref(GLenum pname, GLfloat param) +{ + return GL_PixelStoref(pname, param); +} + +void GL_APIENTRY glPixelTransferf(GLenum pname, GLfloat param) +{ + return GL_PixelTransferf(pname, param); +} + +void GL_APIENTRY glPixelTransferi(GLenum pname, GLint param) +{ + return GL_PixelTransferi(pname, param); +} + +void GL_APIENTRY glPixelZoom(GLfloat xfactor, GLfloat yfactor) +{ + return GL_PixelZoom(xfactor, yfactor); +} + +void GL_APIENTRY glPolygonMode(GLenum face, GLenum mode) +{ + return GL_PolygonMode(face, mode); +} + +void GL_APIENTRY glPolygonStipple(const GLubyte *mask) +{ + return GL_PolygonStipple(mask); +} + +void GL_APIENTRY glPopAttrib() +{ + return GL_PopAttrib(); +} + +void GL_APIENTRY glPopName() +{ + return GL_PopName(); +} + +void GL_APIENTRY glPushAttrib(GLbitfield mask) +{ + return GL_PushAttrib(mask); +} + +void GL_APIENTRY glPushName(GLuint name) +{ + return GL_PushName(name); +} + +void GL_APIENTRY glRasterPos2d(GLdouble x, GLdouble y) +{ + return GL_RasterPos2d(x, y); +} + +void GL_APIENTRY glRasterPos2dv(const GLdouble *v) +{ + return GL_RasterPos2dv(v); +} + +void GL_APIENTRY glRasterPos2f(GLfloat x, GLfloat y) +{ + return GL_RasterPos2f(x, y); +} + +void GL_APIENTRY glRasterPos2fv(const GLfloat *v) +{ + return GL_RasterPos2fv(v); +} + +void GL_APIENTRY glRasterPos2i(GLint x, GLint y) +{ + return GL_RasterPos2i(x, y); +} + +void GL_APIENTRY glRasterPos2iv(const GLint *v) +{ + return GL_RasterPos2iv(v); +} + +void GL_APIENTRY glRasterPos2s(GLshort x, GLshort y) +{ + return GL_RasterPos2s(x, y); +} + +void GL_APIENTRY glRasterPos2sv(const GLshort *v) +{ + return GL_RasterPos2sv(v); +} + +void GL_APIENTRY glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) +{ + return GL_RasterPos3d(x, y, z); +} + +void GL_APIENTRY glRasterPos3dv(const GLdouble *v) +{ + return GL_RasterPos3dv(v); +} + +void GL_APIENTRY glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) +{ + return GL_RasterPos3f(x, y, z); +} + +void GL_APIENTRY glRasterPos3fv(const GLfloat *v) +{ + return GL_RasterPos3fv(v); +} + +void GL_APIENTRY glRasterPos3i(GLint x, GLint y, GLint z) +{ + return GL_RasterPos3i(x, y, z); +} + +void GL_APIENTRY glRasterPos3iv(const GLint *v) +{ + return GL_RasterPos3iv(v); +} + +void GL_APIENTRY glRasterPos3s(GLshort x, GLshort y, GLshort z) +{ + return GL_RasterPos3s(x, y, z); +} + +void GL_APIENTRY glRasterPos3sv(const GLshort *v) +{ + return GL_RasterPos3sv(v); +} + +void GL_APIENTRY glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + return GL_RasterPos4d(x, y, z, w); +} + +void GL_APIENTRY glRasterPos4dv(const GLdouble *v) +{ + return GL_RasterPos4dv(v); +} + +void GL_APIENTRY glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + return GL_RasterPos4f(x, y, z, w); +} + +void GL_APIENTRY glRasterPos4fv(const GLfloat *v) +{ + return GL_RasterPos4fv(v); +} + +void GL_APIENTRY glRasterPos4i(GLint x, GLint y, GLint z, GLint w) +{ + return GL_RasterPos4i(x, y, z, w); +} + +void GL_APIENTRY glRasterPos4iv(const GLint *v) +{ + return GL_RasterPos4iv(v); +} + +void GL_APIENTRY glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) +{ + return GL_RasterPos4s(x, y, z, w); +} + +void GL_APIENTRY glRasterPos4sv(const GLshort *v) +{ + return GL_RasterPos4sv(v); +} + +void GL_APIENTRY glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) +{ + return GL_Rectd(x1, y1, x2, y2); +} + +void GL_APIENTRY glRectdv(const GLdouble *v1, const GLdouble *v2) +{ + return GL_Rectdv(v1, v2); +} + +void GL_APIENTRY glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) +{ + return GL_Rectf(x1, y1, x2, y2); +} + +void GL_APIENTRY glRectfv(const GLfloat *v1, const GLfloat *v2) +{ + return GL_Rectfv(v1, v2); +} + +void GL_APIENTRY glRecti(GLint x1, GLint y1, GLint x2, GLint y2) +{ + return GL_Recti(x1, y1, x2, y2); +} + +void GL_APIENTRY glRectiv(const GLint *v1, const GLint *v2) +{ + return GL_Rectiv(v1, v2); +} + +void GL_APIENTRY glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) +{ + return GL_Rects(x1, y1, x2, y2); +} + +void GL_APIENTRY glRectsv(const GLshort *v1, const GLshort *v2) +{ + return GL_Rectsv(v1, v2); +} + +GLint GL_APIENTRY glRenderMode(GLenum mode) +{ + return GL_RenderMode(mode); +} + +void GL_APIENTRY glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) +{ + return GL_Rotated(angle, x, y, z); +} + +void GL_APIENTRY glScaled(GLdouble x, GLdouble y, GLdouble z) +{ + return GL_Scaled(x, y, z); +} + +void GL_APIENTRY glSelectBuffer(GLsizei size, GLuint *buffer) +{ + return GL_SelectBuffer(size, buffer); +} + +void GL_APIENTRY glTexCoord1d(GLdouble s) +{ + return GL_TexCoord1d(s); +} + +void GL_APIENTRY glTexCoord1dv(const GLdouble *v) +{ + return GL_TexCoord1dv(v); +} + +void GL_APIENTRY glTexCoord1f(GLfloat s) +{ + return GL_TexCoord1f(s); +} + +void GL_APIENTRY glTexCoord1fv(const GLfloat *v) +{ + return GL_TexCoord1fv(v); +} + +void GL_APIENTRY glTexCoord1i(GLint s) +{ + return GL_TexCoord1i(s); +} + +void GL_APIENTRY glTexCoord1iv(const GLint *v) +{ + return GL_TexCoord1iv(v); +} + +void GL_APIENTRY glTexCoord1s(GLshort s) +{ + return GL_TexCoord1s(s); +} + +void GL_APIENTRY glTexCoord1sv(const GLshort *v) +{ + return GL_TexCoord1sv(v); +} + +void GL_APIENTRY glTexCoord2d(GLdouble s, GLdouble t) +{ + return GL_TexCoord2d(s, t); +} + +void GL_APIENTRY glTexCoord2dv(const GLdouble *v) +{ + return GL_TexCoord2dv(v); +} + +void GL_APIENTRY glTexCoord2f(GLfloat s, GLfloat t) +{ + return GL_TexCoord2f(s, t); +} + +void GL_APIENTRY glTexCoord2fv(const GLfloat *v) +{ + return GL_TexCoord2fv(v); +} + +void GL_APIENTRY glTexCoord2i(GLint s, GLint t) +{ + return GL_TexCoord2i(s, t); +} + +void GL_APIENTRY glTexCoord2iv(const GLint *v) +{ + return GL_TexCoord2iv(v); +} + +void GL_APIENTRY glTexCoord2s(GLshort s, GLshort t) +{ + return GL_TexCoord2s(s, t); +} + +void GL_APIENTRY glTexCoord2sv(const GLshort *v) +{ + return GL_TexCoord2sv(v); +} + +void GL_APIENTRY glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) +{ + return GL_TexCoord3d(s, t, r); +} + +void GL_APIENTRY glTexCoord3dv(const GLdouble *v) +{ + return GL_TexCoord3dv(v); +} + +void GL_APIENTRY glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) +{ + return GL_TexCoord3f(s, t, r); +} + +void GL_APIENTRY glTexCoord3fv(const GLfloat *v) +{ + return GL_TexCoord3fv(v); +} + +void GL_APIENTRY glTexCoord3i(GLint s, GLint t, GLint r) +{ + return GL_TexCoord3i(s, t, r); +} + +void GL_APIENTRY glTexCoord3iv(const GLint *v) +{ + return GL_TexCoord3iv(v); +} + +void GL_APIENTRY glTexCoord3s(GLshort s, GLshort t, GLshort r) +{ + return GL_TexCoord3s(s, t, r); +} + +void GL_APIENTRY glTexCoord3sv(const GLshort *v) +{ + return GL_TexCoord3sv(v); +} + +void GL_APIENTRY glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + return GL_TexCoord4d(s, t, r, q); +} + +void GL_APIENTRY glTexCoord4dv(const GLdouble *v) +{ + return GL_TexCoord4dv(v); +} + +void GL_APIENTRY glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + return GL_TexCoord4f(s, t, r, q); +} + +void GL_APIENTRY glTexCoord4fv(const GLfloat *v) +{ + return GL_TexCoord4fv(v); +} + +void GL_APIENTRY glTexCoord4i(GLint s, GLint t, GLint r, GLint q) +{ + return GL_TexCoord4i(s, t, r, q); +} + +void GL_APIENTRY glTexCoord4iv(const GLint *v) +{ + return GL_TexCoord4iv(v); +} + +void GL_APIENTRY glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) +{ + return GL_TexCoord4s(s, t, r, q); +} + +void GL_APIENTRY glTexCoord4sv(const GLshort *v) +{ + return GL_TexCoord4sv(v); +} + +void GL_APIENTRY glTexGend(GLenum coord, GLenum pname, GLdouble param) +{ + return GL_TexGend(coord, pname, param); +} + +void GL_APIENTRY glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) +{ + return GL_TexGendv(coord, pname, params); +} + +void GL_APIENTRY glTexGenf(GLenum coord, GLenum pname, GLfloat param) +{ + return GL_TexGenf(coord, pname, param); +} + +void GL_APIENTRY glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) +{ + return GL_TexGenfv(coord, pname, params); +} + +void GL_APIENTRY glTexGeni(GLenum coord, GLenum pname, GLint param) +{ + return GL_TexGeni(coord, pname, param); +} + +void GL_APIENTRY glTexGeniv(GLenum coord, GLenum pname, const GLint *params) +{ + return GL_TexGeniv(coord, pname, params); +} + +void GL_APIENTRY glTexImage1D(GLenum target, + GLint level, + GLint internalformat, + GLsizei width, + GLint border, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexImage1D(target, level, internalformat, width, border, format, type, pixels); +} + +void GL_APIENTRY glTranslated(GLdouble x, GLdouble y, GLdouble z) +{ + return GL_Translated(x, y, z); +} + +void GL_APIENTRY glVertex2d(GLdouble x, GLdouble y) +{ + return GL_Vertex2d(x, y); +} + +void GL_APIENTRY glVertex2dv(const GLdouble *v) +{ + return GL_Vertex2dv(v); +} + +void GL_APIENTRY glVertex2f(GLfloat x, GLfloat y) +{ + return GL_Vertex2f(x, y); +} + +void GL_APIENTRY glVertex2fv(const GLfloat *v) +{ + return GL_Vertex2fv(v); +} + +void GL_APIENTRY glVertex2i(GLint x, GLint y) +{ + return GL_Vertex2i(x, y); +} + +void GL_APIENTRY glVertex2iv(const GLint *v) +{ + return GL_Vertex2iv(v); +} + +void GL_APIENTRY glVertex2s(GLshort x, GLshort y) +{ + return GL_Vertex2s(x, y); +} + +void GL_APIENTRY glVertex2sv(const GLshort *v) +{ + return GL_Vertex2sv(v); +} + +void GL_APIENTRY glVertex3d(GLdouble x, GLdouble y, GLdouble z) +{ + return GL_Vertex3d(x, y, z); +} + +void GL_APIENTRY glVertex3dv(const GLdouble *v) +{ + return GL_Vertex3dv(v); +} + +void GL_APIENTRY glVertex3f(GLfloat x, GLfloat y, GLfloat z) +{ + return GL_Vertex3f(x, y, z); +} + +void GL_APIENTRY glVertex3fv(const GLfloat *v) +{ + return GL_Vertex3fv(v); +} + +void GL_APIENTRY glVertex3i(GLint x, GLint y, GLint z) +{ + return GL_Vertex3i(x, y, z); +} + +void GL_APIENTRY glVertex3iv(const GLint *v) +{ + return GL_Vertex3iv(v); +} + +void GL_APIENTRY glVertex3s(GLshort x, GLshort y, GLshort z) +{ + return GL_Vertex3s(x, y, z); +} + +void GL_APIENTRY glVertex3sv(const GLshort *v) +{ + return GL_Vertex3sv(v); +} + +void GL_APIENTRY glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + return GL_Vertex4d(x, y, z, w); +} + +void GL_APIENTRY glVertex4dv(const GLdouble *v) +{ + return GL_Vertex4dv(v); +} + +void GL_APIENTRY glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + return GL_Vertex4f(x, y, z, w); +} + +void GL_APIENTRY glVertex4fv(const GLfloat *v) +{ + return GL_Vertex4fv(v); +} + +void GL_APIENTRY glVertex4i(GLint x, GLint y, GLint z, GLint w) +{ + return GL_Vertex4i(x, y, z, w); +} + +void GL_APIENTRY glVertex4iv(const GLint *v) +{ + return GL_Vertex4iv(v); +} + +void GL_APIENTRY glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) +{ + return GL_Vertex4s(x, y, z, w); +} + +void GL_APIENTRY glVertex4sv(const GLshort *v) +{ + return GL_Vertex4sv(v); +} + +// GL 1.1 +GLboolean GL_APIENTRY glAreTexturesResident(GLsizei n, + const GLuint *textures, + GLboolean *residences) +{ + return GL_AreTexturesResident(n, textures, residences); +} + +void GL_APIENTRY glArrayElement(GLint i) +{ + return GL_ArrayElement(i); +} + +void GL_APIENTRY glCopyTexImage1D(GLenum target, + GLint level, + GLenum internalformat, + GLint x, + GLint y, + GLsizei width, + GLint border) +{ + return GL_CopyTexImage1D(target, level, internalformat, x, y, width, border); +} + +void GL_APIENTRY +glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + return GL_CopyTexSubImage1D(target, level, xoffset, x, y, width); +} + +void GL_APIENTRY glEdgeFlagPointer(GLsizei stride, const void *pointer) +{ + return GL_EdgeFlagPointer(stride, pointer); +} + +void GL_APIENTRY glIndexPointer(GLenum type, GLsizei stride, const void *pointer) +{ + return GL_IndexPointer(type, stride, pointer); +} + +void GL_APIENTRY glIndexub(GLubyte c) +{ + return GL_Indexub(c); +} + +void GL_APIENTRY glIndexubv(const GLubyte *c) +{ + return GL_Indexubv(c); +} + +void GL_APIENTRY glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer) +{ + return GL_InterleavedArrays(format, stride, pointer); +} + +void GL_APIENTRY glPopClientAttrib() +{ + return GL_PopClientAttrib(); +} + +void GL_APIENTRY glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities) +{ + return GL_PrioritizeTextures(n, textures, priorities); +} + +void GL_APIENTRY glPushClientAttrib(GLbitfield mask) +{ + return GL_PushClientAttrib(mask); +} + +void GL_APIENTRY glTexSubImage1D(GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TexSubImage1D(target, level, xoffset, width, format, type, pixels); +} + +// GL 1.2 + +// GL 1.3 +void GL_APIENTRY glCompressedTexImage1D(GLenum target, + GLint level, + GLenum internalformat, + GLsizei width, + GLint border, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data); +} + +void GL_APIENTRY glCompressedTexSubImage1D(GLenum target, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data); +} + +void GL_APIENTRY glGetCompressedTexImage(GLenum target, GLint level, void *img) +{ + return GL_GetCompressedTexImage(target, level, img); +} + +void GL_APIENTRY glLoadTransposeMatrixd(const GLdouble *m) +{ + return GL_LoadTransposeMatrixd(m); +} + +void GL_APIENTRY glLoadTransposeMatrixf(const GLfloat *m) +{ + return GL_LoadTransposeMatrixf(m); +} + +void GL_APIENTRY glMultTransposeMatrixd(const GLdouble *m) +{ + return GL_MultTransposeMatrixd(m); +} + +void GL_APIENTRY glMultTransposeMatrixf(const GLfloat *m) +{ + return GL_MultTransposeMatrixf(m); +} + +void GL_APIENTRY glMultiTexCoord1d(GLenum target, GLdouble s) +{ + return GL_MultiTexCoord1d(target, s); +} + +void GL_APIENTRY glMultiTexCoord1dv(GLenum target, const GLdouble *v) +{ + return GL_MultiTexCoord1dv(target, v); +} + +void GL_APIENTRY glMultiTexCoord1f(GLenum target, GLfloat s) +{ + return GL_MultiTexCoord1f(target, s); +} + +void GL_APIENTRY glMultiTexCoord1fv(GLenum target, const GLfloat *v) +{ + return GL_MultiTexCoord1fv(target, v); +} + +void GL_APIENTRY glMultiTexCoord1i(GLenum target, GLint s) +{ + return GL_MultiTexCoord1i(target, s); +} + +void GL_APIENTRY glMultiTexCoord1iv(GLenum target, const GLint *v) +{ + return GL_MultiTexCoord1iv(target, v); +} + +void GL_APIENTRY glMultiTexCoord1s(GLenum target, GLshort s) +{ + return GL_MultiTexCoord1s(target, s); +} + +void GL_APIENTRY glMultiTexCoord1sv(GLenum target, const GLshort *v) +{ + return GL_MultiTexCoord1sv(target, v); +} + +void GL_APIENTRY glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t) +{ + return GL_MultiTexCoord2d(target, s, t); +} + +void GL_APIENTRY glMultiTexCoord2dv(GLenum target, const GLdouble *v) +{ + return GL_MultiTexCoord2dv(target, v); +} + +void GL_APIENTRY glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t) +{ + return GL_MultiTexCoord2f(target, s, t); +} + +void GL_APIENTRY glMultiTexCoord2fv(GLenum target, const GLfloat *v) +{ + return GL_MultiTexCoord2fv(target, v); +} + +void GL_APIENTRY glMultiTexCoord2i(GLenum target, GLint s, GLint t) +{ + return GL_MultiTexCoord2i(target, s, t); +} + +void GL_APIENTRY glMultiTexCoord2iv(GLenum target, const GLint *v) +{ + return GL_MultiTexCoord2iv(target, v); +} + +void GL_APIENTRY glMultiTexCoord2s(GLenum target, GLshort s, GLshort t) +{ + return GL_MultiTexCoord2s(target, s, t); +} + +void GL_APIENTRY glMultiTexCoord2sv(GLenum target, const GLshort *v) +{ + return GL_MultiTexCoord2sv(target, v); +} + +void GL_APIENTRY glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r) +{ + return GL_MultiTexCoord3d(target, s, t, r); +} + +void GL_APIENTRY glMultiTexCoord3dv(GLenum target, const GLdouble *v) +{ + return GL_MultiTexCoord3dv(target, v); +} + +void GL_APIENTRY glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r) +{ + return GL_MultiTexCoord3f(target, s, t, r); +} + +void GL_APIENTRY glMultiTexCoord3fv(GLenum target, const GLfloat *v) +{ + return GL_MultiTexCoord3fv(target, v); +} + +void GL_APIENTRY glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r) +{ + return GL_MultiTexCoord3i(target, s, t, r); +} + +void GL_APIENTRY glMultiTexCoord3iv(GLenum target, const GLint *v) +{ + return GL_MultiTexCoord3iv(target, v); +} + +void GL_APIENTRY glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r) +{ + return GL_MultiTexCoord3s(target, s, t, r); +} + +void GL_APIENTRY glMultiTexCoord3sv(GLenum target, const GLshort *v) +{ + return GL_MultiTexCoord3sv(target, v); +} + +void GL_APIENTRY glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) +{ + return GL_MultiTexCoord4d(target, s, t, r, q); +} + +void GL_APIENTRY glMultiTexCoord4dv(GLenum target, const GLdouble *v) +{ + return GL_MultiTexCoord4dv(target, v); +} + +void GL_APIENTRY glMultiTexCoord4fv(GLenum target, const GLfloat *v) +{ + return GL_MultiTexCoord4fv(target, v); +} + +void GL_APIENTRY glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q) +{ + return GL_MultiTexCoord4i(target, s, t, r, q); +} + +void GL_APIENTRY glMultiTexCoord4iv(GLenum target, const GLint *v) +{ + return GL_MultiTexCoord4iv(target, v); +} + +void GL_APIENTRY glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) +{ + return GL_MultiTexCoord4s(target, s, t, r, q); +} + +void GL_APIENTRY glMultiTexCoord4sv(GLenum target, const GLshort *v) +{ + return GL_MultiTexCoord4sv(target, v); +} + +// GL 1.4 +void GL_APIENTRY glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer) +{ + return GL_FogCoordPointer(type, stride, pointer); +} + +void GL_APIENTRY glFogCoordd(GLdouble coord) +{ + return GL_FogCoordd(coord); +} + +void GL_APIENTRY glFogCoorddv(const GLdouble *coord) +{ + return GL_FogCoorddv(coord); +} + +void GL_APIENTRY glFogCoordf(GLfloat coord) +{ + return GL_FogCoordf(coord); +} + +void GL_APIENTRY glFogCoordfv(const GLfloat *coord) +{ + return GL_FogCoordfv(coord); +} + +void GL_APIENTRY glMultiDrawArrays(GLenum mode, + const GLint *first, + const GLsizei *count, + GLsizei drawcount) +{ + return GL_MultiDrawArrays(mode, first, count, drawcount); +} + +void GL_APIENTRY glMultiDrawElements(GLenum mode, + const GLsizei *count, + GLenum type, + const void *const *indices, + GLsizei drawcount) +{ + return GL_MultiDrawElements(mode, count, type, indices, drawcount); +} + +void GL_APIENTRY glPointParameteri(GLenum pname, GLint param) +{ + return GL_PointParameteri(pname, param); +} + +void GL_APIENTRY glPointParameteriv(GLenum pname, const GLint *params) +{ + return GL_PointParameteriv(pname, params); +} + +void GL_APIENTRY glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) +{ + return GL_SecondaryColor3b(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3bv(const GLbyte *v) +{ + return GL_SecondaryColor3bv(v); +} + +void GL_APIENTRY glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) +{ + return GL_SecondaryColor3d(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3dv(const GLdouble *v) +{ + return GL_SecondaryColor3dv(v); +} + +void GL_APIENTRY glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) +{ + return GL_SecondaryColor3f(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3fv(const GLfloat *v) +{ + return GL_SecondaryColor3fv(v); +} + +void GL_APIENTRY glSecondaryColor3i(GLint red, GLint green, GLint blue) +{ + return GL_SecondaryColor3i(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3iv(const GLint *v) +{ + return GL_SecondaryColor3iv(v); +} + +void GL_APIENTRY glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) +{ + return GL_SecondaryColor3s(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3sv(const GLshort *v) +{ + return GL_SecondaryColor3sv(v); +} + +void GL_APIENTRY glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) +{ + return GL_SecondaryColor3ub(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3ubv(const GLubyte *v) +{ + return GL_SecondaryColor3ubv(v); +} + +void GL_APIENTRY glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) +{ + return GL_SecondaryColor3ui(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3uiv(const GLuint *v) +{ + return GL_SecondaryColor3uiv(v); +} + +void GL_APIENTRY glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) +{ + return GL_SecondaryColor3us(red, green, blue); +} + +void GL_APIENTRY glSecondaryColor3usv(const GLushort *v) +{ + return GL_SecondaryColor3usv(v); +} + +void GL_APIENTRY glSecondaryColorPointer(GLint size, + GLenum type, + GLsizei stride, + const void *pointer) +{ + return GL_SecondaryColorPointer(size, type, stride, pointer); +} + +void GL_APIENTRY glWindowPos2d(GLdouble x, GLdouble y) +{ + return GL_WindowPos2d(x, y); +} + +void GL_APIENTRY glWindowPos2dv(const GLdouble *v) +{ + return GL_WindowPos2dv(v); +} + +void GL_APIENTRY glWindowPos2f(GLfloat x, GLfloat y) +{ + return GL_WindowPos2f(x, y); +} + +void GL_APIENTRY glWindowPos2fv(const GLfloat *v) +{ + return GL_WindowPos2fv(v); +} + +void GL_APIENTRY glWindowPos2i(GLint x, GLint y) +{ + return GL_WindowPos2i(x, y); +} + +void GL_APIENTRY glWindowPos2iv(const GLint *v) +{ + return GL_WindowPos2iv(v); +} + +void GL_APIENTRY glWindowPos2s(GLshort x, GLshort y) +{ + return GL_WindowPos2s(x, y); +} + +void GL_APIENTRY glWindowPos2sv(const GLshort *v) +{ + return GL_WindowPos2sv(v); +} + +void GL_APIENTRY glWindowPos3d(GLdouble x, GLdouble y, GLdouble z) +{ + return GL_WindowPos3d(x, y, z); +} + +void GL_APIENTRY glWindowPos3dv(const GLdouble *v) +{ + return GL_WindowPos3dv(v); +} + +void GL_APIENTRY glWindowPos3f(GLfloat x, GLfloat y, GLfloat z) +{ + return GL_WindowPos3f(x, y, z); +} + +void GL_APIENTRY glWindowPos3fv(const GLfloat *v) +{ + return GL_WindowPos3fv(v); +} + +void GL_APIENTRY glWindowPos3i(GLint x, GLint y, GLint z) +{ + return GL_WindowPos3i(x, y, z); +} + +void GL_APIENTRY glWindowPos3iv(const GLint *v) +{ + return GL_WindowPos3iv(v); +} + +void GL_APIENTRY glWindowPos3s(GLshort x, GLshort y, GLshort z) +{ + return GL_WindowPos3s(x, y, z); +} + +void GL_APIENTRY glWindowPos3sv(const GLshort *v) +{ + return GL_WindowPos3sv(v); +} + +// GL 1.5 +void GL_APIENTRY glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data) +{ + return GL_GetBufferSubData(target, offset, size, data); +} + +void GL_APIENTRY glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params) +{ + return GL_GetQueryObjectiv(id, pname, params); +} + +void *GL_APIENTRY glMapBuffer(GLenum target, GLenum access) +{ + return GL_MapBuffer(target, access); +} + +// GL 2.0 +void GL_APIENTRY glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params) +{ + return GL_GetVertexAttribdv(index, pname, params); +} + +void GL_APIENTRY glVertexAttrib1d(GLuint index, GLdouble x) +{ + return GL_VertexAttrib1d(index, x); +} + +void GL_APIENTRY glVertexAttrib1dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttrib1dv(index, v); +} + +void GL_APIENTRY glVertexAttrib1s(GLuint index, GLshort x) +{ + return GL_VertexAttrib1s(index, x); +} + +void GL_APIENTRY glVertexAttrib1sv(GLuint index, const GLshort *v) +{ + return GL_VertexAttrib1sv(index, v); +} + +void GL_APIENTRY glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y) +{ + return GL_VertexAttrib2d(index, x, y); +} + +void GL_APIENTRY glVertexAttrib2dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttrib2dv(index, v); +} + +void GL_APIENTRY glVertexAttrib2s(GLuint index, GLshort x, GLshort y) +{ + return GL_VertexAttrib2s(index, x, y); +} + +void GL_APIENTRY glVertexAttrib2sv(GLuint index, const GLshort *v) +{ + return GL_VertexAttrib2sv(index, v); +} + +void GL_APIENTRY glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + return GL_VertexAttrib3d(index, x, y, z); +} + +void GL_APIENTRY glVertexAttrib3dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttrib3dv(index, v); +} + +void GL_APIENTRY glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z) +{ + return GL_VertexAttrib3s(index, x, y, z); +} + +void GL_APIENTRY glVertexAttrib3sv(GLuint index, const GLshort *v) +{ + return GL_VertexAttrib3sv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Nbv(GLuint index, const GLbyte *v) +{ + return GL_VertexAttrib4Nbv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Niv(GLuint index, const GLint *v) +{ + return GL_VertexAttrib4Niv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Nsv(GLuint index, const GLshort *v) +{ + return GL_VertexAttrib4Nsv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) +{ + return GL_VertexAttrib4Nub(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttrib4Nubv(GLuint index, const GLubyte *v) +{ + return GL_VertexAttrib4Nubv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Nuiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttrib4Nuiv(index, v); +} + +void GL_APIENTRY glVertexAttrib4Nusv(GLuint index, const GLushort *v) +{ + return GL_VertexAttrib4Nusv(index, v); +} + +void GL_APIENTRY glVertexAttrib4bv(GLuint index, const GLbyte *v) +{ + return GL_VertexAttrib4bv(index, v); +} + +void GL_APIENTRY glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + return GL_VertexAttrib4d(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttrib4dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttrib4dv(index, v); +} + +void GL_APIENTRY glVertexAttrib4iv(GLuint index, const GLint *v) +{ + return GL_VertexAttrib4iv(index, v); +} + +void GL_APIENTRY glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) +{ + return GL_VertexAttrib4s(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttrib4sv(GLuint index, const GLshort *v) +{ + return GL_VertexAttrib4sv(index, v); +} + +void GL_APIENTRY glVertexAttrib4ubv(GLuint index, const GLubyte *v) +{ + return GL_VertexAttrib4ubv(index, v); +} + +void GL_APIENTRY glVertexAttrib4uiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttrib4uiv(index, v); +} + +void GL_APIENTRY glVertexAttrib4usv(GLuint index, const GLushort *v) +{ + return GL_VertexAttrib4usv(index, v); +} + +// GL 2.1 + +// GL 3.0 +void GL_APIENTRY glBeginConditionalRender(GLuint id, GLenum mode) +{ + return GL_BeginConditionalRender(id, mode); +} + +void GL_APIENTRY glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name) +{ + return GL_BindFragDataLocation(program, color, name); +} + +void GL_APIENTRY glClampColor(GLenum target, GLenum clamp) +{ + return GL_ClampColor(target, clamp); +} + +void GL_APIENTRY glEndConditionalRender() +{ + return GL_EndConditionalRender(); +} + +void GL_APIENTRY glFramebufferTexture1D(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level) +{ + return GL_FramebufferTexture1D(target, attachment, textarget, texture, level); +} + +void GL_APIENTRY glFramebufferTexture3D(GLenum target, + GLenum attachment, + GLenum textarget, + GLuint texture, + GLint level, + GLint zoffset) +{ + return GL_FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset); +} + +void GL_APIENTRY glVertexAttribI1i(GLuint index, GLint x) +{ + return GL_VertexAttribI1i(index, x); +} + +void GL_APIENTRY glVertexAttribI1iv(GLuint index, const GLint *v) +{ + return GL_VertexAttribI1iv(index, v); +} + +void GL_APIENTRY glVertexAttribI1ui(GLuint index, GLuint x) +{ + return GL_VertexAttribI1ui(index, x); +} + +void GL_APIENTRY glVertexAttribI1uiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttribI1uiv(index, v); +} + +void GL_APIENTRY glVertexAttribI2i(GLuint index, GLint x, GLint y) +{ + return GL_VertexAttribI2i(index, x, y); +} + +void GL_APIENTRY glVertexAttribI2iv(GLuint index, const GLint *v) +{ + return GL_VertexAttribI2iv(index, v); +} + +void GL_APIENTRY glVertexAttribI2ui(GLuint index, GLuint x, GLuint y) +{ + return GL_VertexAttribI2ui(index, x, y); +} + +void GL_APIENTRY glVertexAttribI2uiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttribI2uiv(index, v); +} + +void GL_APIENTRY glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z) +{ + return GL_VertexAttribI3i(index, x, y, z); +} + +void GL_APIENTRY glVertexAttribI3iv(GLuint index, const GLint *v) +{ + return GL_VertexAttribI3iv(index, v); +} + +void GL_APIENTRY glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z) +{ + return GL_VertexAttribI3ui(index, x, y, z); +} + +void GL_APIENTRY glVertexAttribI3uiv(GLuint index, const GLuint *v) +{ + return GL_VertexAttribI3uiv(index, v); +} + +void GL_APIENTRY glVertexAttribI4bv(GLuint index, const GLbyte *v) +{ + return GL_VertexAttribI4bv(index, v); +} + +void GL_APIENTRY glVertexAttribI4sv(GLuint index, const GLshort *v) +{ + return GL_VertexAttribI4sv(index, v); +} + +void GL_APIENTRY glVertexAttribI4ubv(GLuint index, const GLubyte *v) +{ + return GL_VertexAttribI4ubv(index, v); +} + +void GL_APIENTRY glVertexAttribI4usv(GLuint index, const GLushort *v) +{ + return GL_VertexAttribI4usv(index, v); +} + +// GL 3.1 +void GL_APIENTRY glGetActiveUniformName(GLuint program, + GLuint uniformIndex, + GLsizei bufSize, + GLsizei *length, + GLchar *uniformName) +{ + return GL_GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName); +} + +void GL_APIENTRY glPrimitiveRestartIndex(GLuint index) +{ + return GL_PrimitiveRestartIndex(index); +} + +// GL 3.2 +void GL_APIENTRY glMultiDrawElementsBaseVertex(GLenum mode, + const GLsizei *count, + GLenum type, + const void *const *indices, + GLsizei drawcount, + const GLint *basevertex) +{ + return GL_MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex); +} + +void GL_APIENTRY glProvokingVertex(GLenum mode) +{ + return GL_ProvokingVertex(mode); +} + +void GL_APIENTRY glTexImage2DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + return GL_TexImage2DMultisample(target, samples, internalformat, width, height, + fixedsamplelocations); +} + +void GL_APIENTRY glTexImage3DMultisample(GLenum target, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + return GL_TexImage3DMultisample(target, samples, internalformat, width, height, depth, + fixedsamplelocations); +} + +// GL 3.3 +void GL_APIENTRY glBindFragDataLocationIndexed(GLuint program, + GLuint colorNumber, + GLuint index, + const GLchar *name) +{ + return GL_BindFragDataLocationIndexed(program, colorNumber, index, name); +} + +void GL_APIENTRY glColorP3ui(GLenum type, GLuint color) +{ + return GL_ColorP3ui(type, color); +} + +void GL_APIENTRY glColorP3uiv(GLenum type, const GLuint *color) +{ + return GL_ColorP3uiv(type, color); +} + +void GL_APIENTRY glColorP4ui(GLenum type, GLuint color) +{ + return GL_ColorP4ui(type, color); +} + +void GL_APIENTRY glColorP4uiv(GLenum type, const GLuint *color) +{ + return GL_ColorP4uiv(type, color); +} + +GLint GL_APIENTRY glGetFragDataIndex(GLuint program, const GLchar *name) +{ + return GL_GetFragDataIndex(program, name); +} + +void GL_APIENTRY glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params) +{ + return GL_GetQueryObjecti64v(id, pname, params); +} + +void GL_APIENTRY glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params) +{ + return GL_GetQueryObjectui64v(id, pname, params); +} + +void GL_APIENTRY glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords) +{ + return GL_MultiTexCoordP1ui(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords) +{ + return GL_MultiTexCoordP1uiv(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords) +{ + return GL_MultiTexCoordP2ui(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords) +{ + return GL_MultiTexCoordP2uiv(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords) +{ + return GL_MultiTexCoordP3ui(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords) +{ + return GL_MultiTexCoordP3uiv(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords) +{ + return GL_MultiTexCoordP4ui(texture, type, coords); +} + +void GL_APIENTRY glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords) +{ + return GL_MultiTexCoordP4uiv(texture, type, coords); +} + +void GL_APIENTRY glNormalP3ui(GLenum type, GLuint coords) +{ + return GL_NormalP3ui(type, coords); +} + +void GL_APIENTRY glNormalP3uiv(GLenum type, const GLuint *coords) +{ + return GL_NormalP3uiv(type, coords); +} + +void GL_APIENTRY glQueryCounter(GLuint id, GLenum target) +{ + return GL_QueryCounter(id, target); +} + +void GL_APIENTRY glSecondaryColorP3ui(GLenum type, GLuint color) +{ + return GL_SecondaryColorP3ui(type, color); +} + +void GL_APIENTRY glSecondaryColorP3uiv(GLenum type, const GLuint *color) +{ + return GL_SecondaryColorP3uiv(type, color); +} + +void GL_APIENTRY glTexCoordP1ui(GLenum type, GLuint coords) +{ + return GL_TexCoordP1ui(type, coords); +} + +void GL_APIENTRY glTexCoordP1uiv(GLenum type, const GLuint *coords) +{ + return GL_TexCoordP1uiv(type, coords); +} + +void GL_APIENTRY glTexCoordP2ui(GLenum type, GLuint coords) +{ + return GL_TexCoordP2ui(type, coords); +} + +void GL_APIENTRY glTexCoordP2uiv(GLenum type, const GLuint *coords) +{ + return GL_TexCoordP2uiv(type, coords); +} + +void GL_APIENTRY glTexCoordP3ui(GLenum type, GLuint coords) +{ + return GL_TexCoordP3ui(type, coords); +} + +void GL_APIENTRY glTexCoordP3uiv(GLenum type, const GLuint *coords) +{ + return GL_TexCoordP3uiv(type, coords); +} + +void GL_APIENTRY glTexCoordP4ui(GLenum type, GLuint coords) +{ + return GL_TexCoordP4ui(type, coords); +} + +void GL_APIENTRY glTexCoordP4uiv(GLenum type, const GLuint *coords) +{ + return GL_TexCoordP4uiv(type, coords); +} + +void GL_APIENTRY glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) +{ + return GL_VertexAttribP1ui(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP1uiv(GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value) +{ + return GL_VertexAttribP1uiv(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) +{ + return GL_VertexAttribP2ui(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP2uiv(GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value) +{ + return GL_VertexAttribP2uiv(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) +{ + return GL_VertexAttribP3ui(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP3uiv(GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value) +{ + return GL_VertexAttribP3uiv(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value) +{ + return GL_VertexAttribP4ui(index, type, normalized, value); +} + +void GL_APIENTRY glVertexAttribP4uiv(GLuint index, + GLenum type, + GLboolean normalized, + const GLuint *value) +{ + return GL_VertexAttribP4uiv(index, type, normalized, value); +} + +void GL_APIENTRY glVertexP2ui(GLenum type, GLuint value) +{ + return GL_VertexP2ui(type, value); +} + +void GL_APIENTRY glVertexP2uiv(GLenum type, const GLuint *value) +{ + return GL_VertexP2uiv(type, value); +} + +void GL_APIENTRY glVertexP3ui(GLenum type, GLuint value) +{ + return GL_VertexP3ui(type, value); +} + +void GL_APIENTRY glVertexP3uiv(GLenum type, const GLuint *value) +{ + return GL_VertexP3uiv(type, value); +} + +void GL_APIENTRY glVertexP4ui(GLenum type, GLuint value) +{ + return GL_VertexP4ui(type, value); +} + +void GL_APIENTRY glVertexP4uiv(GLenum type, const GLuint *value) +{ + return GL_VertexP4uiv(type, value); +} + +// GL 4.0 +void GL_APIENTRY glBeginQueryIndexed(GLenum target, GLuint index, GLuint id) +{ + return GL_BeginQueryIndexed(target, index, id); +} + +void GL_APIENTRY glDrawTransformFeedback(GLenum mode, GLuint id) +{ + return GL_DrawTransformFeedback(mode, id); +} + +void GL_APIENTRY glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream) +{ + return GL_DrawTransformFeedbackStream(mode, id, stream); +} + +void GL_APIENTRY glEndQueryIndexed(GLenum target, GLuint index) +{ + return GL_EndQueryIndexed(target, index); +} + +void GL_APIENTRY glGetActiveSubroutineName(GLuint program, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name) +{ + return GL_GetActiveSubroutineName(program, shadertype, index, bufSize, length, name); +} + +void GL_APIENTRY glGetActiveSubroutineUniformName(GLuint program, + GLenum shadertype, + GLuint index, + GLsizei bufSize, + GLsizei *length, + GLchar *name) +{ + return GL_GetActiveSubroutineUniformName(program, shadertype, index, bufSize, length, name); +} + +void GL_APIENTRY glGetActiveSubroutineUniformiv(GLuint program, + GLenum shadertype, + GLuint index, + GLenum pname, + GLint *values) +{ + return GL_GetActiveSubroutineUniformiv(program, shadertype, index, pname, values); +} + +void GL_APIENTRY glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values) +{ + return GL_GetProgramStageiv(program, shadertype, pname, values); +} + +void GL_APIENTRY glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params) +{ + return GL_GetQueryIndexediv(target, index, pname, params); +} + +GLuint GL_APIENTRY glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name) +{ + return GL_GetSubroutineIndex(program, shadertype, name); +} + +GLint GL_APIENTRY glGetSubroutineUniformLocation(GLuint program, + GLenum shadertype, + const GLchar *name) +{ + return GL_GetSubroutineUniformLocation(program, shadertype, name); +} + +void GL_APIENTRY glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params) +{ + return GL_GetUniformSubroutineuiv(shadertype, location, params); +} + +void GL_APIENTRY glGetUniformdv(GLuint program, GLint location, GLdouble *params) +{ + return GL_GetUniformdv(program, location, params); +} + +void GL_APIENTRY glPatchParameterfv(GLenum pname, const GLfloat *values) +{ + return GL_PatchParameterfv(pname, values); +} + +void GL_APIENTRY glUniform1d(GLint location, GLdouble x) +{ + return GL_Uniform1d(location, x); +} + +void GL_APIENTRY glUniform1dv(GLint location, GLsizei count, const GLdouble *value) +{ + return GL_Uniform1dv(location, count, value); +} + +void GL_APIENTRY glUniform2d(GLint location, GLdouble x, GLdouble y) +{ + return GL_Uniform2d(location, x, y); +} + +void GL_APIENTRY glUniform2dv(GLint location, GLsizei count, const GLdouble *value) +{ + return GL_Uniform2dv(location, count, value); +} + +void GL_APIENTRY glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z) +{ + return GL_Uniform3d(location, x, y, z); +} + +void GL_APIENTRY glUniform3dv(GLint location, GLsizei count, const GLdouble *value) +{ + return GL_Uniform3dv(location, count, value); +} + +void GL_APIENTRY glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + return GL_Uniform4d(location, x, y, z, w); +} + +void GL_APIENTRY glUniform4dv(GLint location, GLsizei count, const GLdouble *value) +{ + return GL_Uniform4dv(location, count, value); +} + +void GL_APIENTRY glUniformMatrix2dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix2dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix2x3dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix2x3dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix2x4dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix2x4dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix3dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3x2dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix3x2dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix3x4dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix3x4dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix4dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4x2dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix4x2dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformMatrix4x3dv(GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_UniformMatrix4x3dv(location, count, transpose, value); +} + +void GL_APIENTRY glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices) +{ + return GL_UniformSubroutinesuiv(shadertype, count, indices); +} + +// GL 4.1 +void GL_APIENTRY glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v) +{ + return GL_DepthRangeArrayv(first, count, v); +} + +void GL_APIENTRY glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f) +{ + return GL_DepthRangeIndexed(index, n, f); +} + +void GL_APIENTRY glGetDoublei_v(GLenum target, GLuint index, GLdouble *data) +{ + return GL_GetDoublei_v(target, index, data); +} + +void GL_APIENTRY glGetFloati_v(GLenum target, GLuint index, GLfloat *data) +{ + return GL_GetFloati_v(target, index, data); +} + +void GL_APIENTRY glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params) +{ + return GL_GetVertexAttribLdv(index, pname, params); +} + +void GL_APIENTRY glProgramUniform1d(GLuint program, GLint location, GLdouble v0) +{ + return GL_ProgramUniform1d(program, location, v0); +} + +void GL_APIENTRY glProgramUniform1dv(GLuint program, + GLint location, + GLsizei count, + const GLdouble *value) +{ + return GL_ProgramUniform1dv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1) +{ + return GL_ProgramUniform2d(program, location, v0, v1); +} + +void GL_APIENTRY glProgramUniform2dv(GLuint program, + GLint location, + GLsizei count, + const GLdouble *value) +{ + return GL_ProgramUniform2dv(program, location, count, value); +} + +void GL_APIENTRY +glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) +{ + return GL_ProgramUniform3d(program, location, v0, v1, v2); +} + +void GL_APIENTRY glProgramUniform3dv(GLuint program, + GLint location, + GLsizei count, + const GLdouble *value) +{ + return GL_ProgramUniform3dv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniform4d(GLuint program, + GLint location, + GLdouble v0, + GLdouble v1, + GLdouble v2, + GLdouble v3) +{ + return GL_ProgramUniform4d(program, location, v0, v1, v2, v3); +} + +void GL_APIENTRY glProgramUniform4dv(GLuint program, + GLint location, + GLsizei count, + const GLdouble *value) +{ + return GL_ProgramUniform4dv(program, location, count, value); +} + +void GL_APIENTRY glProgramUniformMatrix2dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix2dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x3dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix2x3dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix2x4dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix2x4dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix3dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x2dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix3x2dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix3x4dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix3x4dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix4dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x2dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix4x2dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glProgramUniformMatrix4x3dv(GLuint program, + GLint location, + GLsizei count, + GLboolean transpose, + const GLdouble *value) +{ + return GL_ProgramUniformMatrix4x3dv(program, location, count, transpose, value); +} + +void GL_APIENTRY glScissorArrayv(GLuint first, GLsizei count, const GLint *v) +{ + return GL_ScissorArrayv(first, count, v); +} + +void GL_APIENTRY +glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) +{ + return GL_ScissorIndexed(index, left, bottom, width, height); +} + +void GL_APIENTRY glScissorIndexedv(GLuint index, const GLint *v) +{ + return GL_ScissorIndexedv(index, v); +} + +void GL_APIENTRY glVertexAttribL1d(GLuint index, GLdouble x) +{ + return GL_VertexAttribL1d(index, x); +} + +void GL_APIENTRY glVertexAttribL1dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttribL1dv(index, v); +} + +void GL_APIENTRY glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y) +{ + return GL_VertexAttribL2d(index, x, y); +} + +void GL_APIENTRY glVertexAttribL2dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttribL2dv(index, v); +} + +void GL_APIENTRY glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z) +{ + return GL_VertexAttribL3d(index, x, y, z); +} + +void GL_APIENTRY glVertexAttribL3dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttribL3dv(index, v); +} + +void GL_APIENTRY glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) +{ + return GL_VertexAttribL4d(index, x, y, z, w); +} + +void GL_APIENTRY glVertexAttribL4dv(GLuint index, const GLdouble *v) +{ + return GL_VertexAttribL4dv(index, v); +} + +void GL_APIENTRY +glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer) +{ + return GL_VertexAttribLPointer(index, size, type, stride, pointer); +} + +void GL_APIENTRY glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v) +{ + return GL_ViewportArrayv(first, count, v); +} + +void GL_APIENTRY glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) +{ + return GL_ViewportIndexedf(index, x, y, w, h); +} + +void GL_APIENTRY glViewportIndexedfv(GLuint index, const GLfloat *v) +{ + return GL_ViewportIndexedfv(index, v); +} + +// GL 4.2 +void GL_APIENTRY glDrawArraysInstancedBaseInstance(GLenum mode, + GLint first, + GLsizei count, + GLsizei instancecount, + GLuint baseinstance) +{ + return GL_DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance); +} + +void GL_APIENTRY glDrawElementsInstancedBaseInstance(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLuint baseinstance) +{ + return GL_DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, + baseinstance); +} + +void GL_APIENTRY glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, + GLsizei count, + GLenum type, + const void *indices, + GLsizei instancecount, + GLint basevertex, + GLuint baseinstance) +{ + return GL_DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, + basevertex, baseinstance); +} + +void GL_APIENTRY glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount) +{ + return GL_DrawTransformFeedbackInstanced(mode, id, instancecount); +} + +void GL_APIENTRY glDrawTransformFeedbackStreamInstanced(GLenum mode, + GLuint id, + GLuint stream, + GLsizei instancecount) +{ + return GL_DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount); +} + +void GL_APIENTRY glGetActiveAtomicCounterBufferiv(GLuint program, + GLuint bufferIndex, + GLenum pname, + GLint *params) +{ + return GL_GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params); +} + +void GL_APIENTRY glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) +{ + return GL_TexStorage1D(target, levels, internalformat, width); +} + +// GL 4.3 +void GL_APIENTRY glClearBufferData(GLenum target, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data) +{ + return GL_ClearBufferData(target, internalformat, format, type, data); +} + +void GL_APIENTRY glClearBufferSubData(GLenum target, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data) +{ + return GL_ClearBufferSubData(target, internalformat, offset, size, format, type, data); +} + +void GL_APIENTRY glGetInternalformati64v(GLenum target, + GLenum internalformat, + GLenum pname, + GLsizei count, + GLint64 *params) +{ + return GL_GetInternalformati64v(target, internalformat, pname, count, params); +} + +GLint GL_APIENTRY glGetProgramResourceLocationIndex(GLuint program, + GLenum programInterface, + const GLchar *name) +{ + return GL_GetProgramResourceLocationIndex(program, programInterface, name); +} + +void GL_APIENTRY glInvalidateBufferData(GLuint buffer) +{ + return GL_InvalidateBufferData(buffer); +} + +void GL_APIENTRY glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length) +{ + return GL_InvalidateBufferSubData(buffer, offset, length); +} + +void GL_APIENTRY glInvalidateTexImage(GLuint texture, GLint level) +{ + return GL_InvalidateTexImage(texture, level); +} + +void GL_APIENTRY glInvalidateTexSubImage(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + return GL_InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, + depth); +} + +void GL_APIENTRY glMultiDrawArraysIndirect(GLenum mode, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return GL_MultiDrawArraysIndirect(mode, indirect, drawcount, stride); +} + +void GL_APIENTRY glMultiDrawElementsIndirect(GLenum mode, + GLenum type, + const void *indirect, + GLsizei drawcount, + GLsizei stride) +{ + return GL_MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride); +} + +void GL_APIENTRY glShaderStorageBlockBinding(GLuint program, + GLuint storageBlockIndex, + GLuint storageBlockBinding) +{ + return GL_ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding); +} + +void GL_APIENTRY glTextureView(GLuint texture, + GLenum target, + GLuint origtexture, + GLenum internalformat, + GLuint minlevel, + GLuint numlevels, + GLuint minlayer, + GLuint numlayers) +{ + return GL_TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, + minlayer, numlayers); +} + +void GL_APIENTRY glVertexAttribLFormat(GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset) +{ + return GL_VertexAttribLFormat(attribindex, size, type, relativeoffset); +} + +// GL 4.4 +void GL_APIENTRY glBindBuffersBase(GLenum target, + GLuint first, + GLsizei count, + const GLuint *buffers) +{ + return GL_BindBuffersBase(target, first, count, buffers); +} + +void GL_APIENTRY glBindBuffersRange(GLenum target, + GLuint first, + GLsizei count, + const GLuint *buffers, + const GLintptr *offsets, + const GLsizeiptr *sizes) +{ + return GL_BindBuffersRange(target, first, count, buffers, offsets, sizes); +} + +void GL_APIENTRY glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + return GL_BindImageTextures(first, count, textures); +} + +void GL_APIENTRY glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers) +{ + return GL_BindSamplers(first, count, samplers); +} + +void GL_APIENTRY glBindTextures(GLuint first, GLsizei count, const GLuint *textures) +{ + return GL_BindTextures(first, count, textures); +} + +void GL_APIENTRY glBindVertexBuffers(GLuint first, + GLsizei count, + const GLuint *buffers, + const GLintptr *offsets, + const GLsizei *strides) +{ + return GL_BindVertexBuffers(first, count, buffers, offsets, strides); +} + +void GL_APIENTRY glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags) +{ + return GL_BufferStorage(target, size, data, flags); +} + +void GL_APIENTRY +glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data) +{ + return GL_ClearTexImage(texture, level, format, type, data); +} + +void GL_APIENTRY glClearTexSubImage(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *data) +{ + return GL_ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, + format, type, data); +} + +// GL 4.5 +void GL_APIENTRY glBindTextureUnit(GLuint unit, GLuint texture) +{ + return GL_BindTextureUnit(unit, texture); +} + +void GL_APIENTRY glBlitNamedFramebuffer(GLuint readFramebuffer, + GLuint drawFramebuffer, + GLint srcX0, + GLint srcY0, + GLint srcX1, + GLint srcY1, + GLint dstX0, + GLint dstY0, + GLint dstX1, + GLint dstY1, + GLbitfield mask, + GLenum filter) +{ + return GL_BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, + dstX0, dstY0, dstX1, dstY1, mask, filter); +} + +GLenum GL_APIENTRY glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target) +{ + return GL_CheckNamedFramebufferStatus(framebuffer, target); +} + +void GL_APIENTRY glClearNamedBufferData(GLuint buffer, + GLenum internalformat, + GLenum format, + GLenum type, + const void *data) +{ + return GL_ClearNamedBufferData(buffer, internalformat, format, type, data); +} + +void GL_APIENTRY glClearNamedBufferSubData(GLuint buffer, + GLenum internalformat, + GLintptr offset, + GLsizeiptr size, + GLenum format, + GLenum type, + const void *data) +{ + return GL_ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); +} + +void GL_APIENTRY glClearNamedFramebufferfi(GLuint framebuffer, + GLenum buffer, + GLint drawbuffer, + GLfloat depth, + GLint stencil) +{ + return GL_ClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil); +} + +void GL_APIENTRY glClearNamedFramebufferfv(GLuint framebuffer, + GLenum buffer, + GLint drawbuffer, + const GLfloat *value) +{ + return GL_ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value); +} + +void GL_APIENTRY glClearNamedFramebufferiv(GLuint framebuffer, + GLenum buffer, + GLint drawbuffer, + const GLint *value) +{ + return GL_ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value); +} + +void GL_APIENTRY glClearNamedFramebufferuiv(GLuint framebuffer, + GLenum buffer, + GLint drawbuffer, + const GLuint *value) +{ + return GL_ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value); +} + +void GL_APIENTRY glClipControl(GLenum origin, GLenum depth) +{ + return GL_ClipControl(origin, depth); +} + +void GL_APIENTRY glCompressedTextureSubImage1D(GLuint texture, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data); +} + +void GL_APIENTRY glCompressedTextureSubImage2D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, + imageSize, data); +} + +void GL_APIENTRY glCompressedTextureSubImage3D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLsizei imageSize, + const void *data) +{ + return GL_CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, + depth, format, imageSize, data); +} + +void GL_APIENTRY glCopyNamedBufferSubData(GLuint readBuffer, + GLuint writeBuffer, + GLintptr readOffset, + GLintptr writeOffset, + GLsizeiptr size) +{ + return GL_CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); +} + +void GL_APIENTRY +glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) +{ + return GL_CopyTextureSubImage1D(texture, level, xoffset, x, y, width); +} + +void GL_APIENTRY glCopyTextureSubImage2D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height); +} + +void GL_APIENTRY glCopyTextureSubImage3D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height); +} + +void GL_APIENTRY glCreateBuffers(GLsizei n, GLuint *buffers) +{ + return GL_CreateBuffers(n, buffers); +} + +void GL_APIENTRY glCreateFramebuffers(GLsizei n, GLuint *framebuffers) +{ + return GL_CreateFramebuffers(n, framebuffers); +} + +void GL_APIENTRY glCreateProgramPipelines(GLsizei n, GLuint *pipelines) +{ + return GL_CreateProgramPipelines(n, pipelines); +} + +void GL_APIENTRY glCreateQueries(GLenum target, GLsizei n, GLuint *ids) +{ + return GL_CreateQueries(target, n, ids); +} + +void GL_APIENTRY glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers) +{ + return GL_CreateRenderbuffers(n, renderbuffers); +} + +void GL_APIENTRY glCreateSamplers(GLsizei n, GLuint *samplers) +{ + return GL_CreateSamplers(n, samplers); +} + +void GL_APIENTRY glCreateTextures(GLenum target, GLsizei n, GLuint *textures) +{ + return GL_CreateTextures(target, n, textures); +} + +void GL_APIENTRY glCreateTransformFeedbacks(GLsizei n, GLuint *ids) +{ + return GL_CreateTransformFeedbacks(n, ids); +} + +void GL_APIENTRY glCreateVertexArrays(GLsizei n, GLuint *arrays) +{ + return GL_CreateVertexArrays(n, arrays); +} + +void GL_APIENTRY glDisableVertexArrayAttrib(GLuint vaobj, GLuint index) +{ + return GL_DisableVertexArrayAttrib(vaobj, index); +} + +void GL_APIENTRY glEnableVertexArrayAttrib(GLuint vaobj, GLuint index) +{ + return GL_EnableVertexArrayAttrib(vaobj, index); +} + +void GL_APIENTRY glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length) +{ + return GL_FlushMappedNamedBufferRange(buffer, offset, length); +} + +void GL_APIENTRY glGenerateTextureMipmap(GLuint texture) +{ + return GL_GenerateTextureMipmap(texture); +} + +void GL_APIENTRY glGetCompressedTextureImage(GLuint texture, + GLint level, + GLsizei bufSize, + void *pixels) +{ + return GL_GetCompressedTextureImage(texture, level, bufSize, pixels); +} + +void GL_APIENTRY glGetCompressedTextureSubImage(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLsizei bufSize, + void *pixels) +{ + return GL_GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, + depth, bufSize, pixels); +} + +void GL_APIENTRY glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params) +{ + return GL_GetNamedBufferParameteri64v(buffer, pname, params); +} + +void GL_APIENTRY glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params) +{ + return GL_GetNamedBufferParameteriv(buffer, pname, params); +} + +void GL_APIENTRY glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void **params) +{ + return GL_GetNamedBufferPointerv(buffer, pname, params); +} + +void GL_APIENTRY glGetNamedBufferSubData(GLuint buffer, + GLintptr offset, + GLsizeiptr size, + void *data) +{ + return GL_GetNamedBufferSubData(buffer, offset, size, data); +} + +void GL_APIENTRY glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, + GLenum attachment, + GLenum pname, + GLint *params) +{ + return GL_GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params); +} + +void GL_APIENTRY glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param) +{ + return GL_GetNamedFramebufferParameteriv(framebuffer, pname, param); +} + +void GL_APIENTRY glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params) +{ + return GL_GetNamedRenderbufferParameteriv(renderbuffer, pname, params); +} + +void GL_APIENTRY glGetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) +{ + return GL_GetQueryBufferObjecti64v(id, buffer, pname, offset); +} + +void GL_APIENTRY glGetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) +{ + return GL_GetQueryBufferObjectiv(id, buffer, pname, offset); +} + +void GL_APIENTRY glGetQueryBufferObjectui64v(GLuint id, + GLuint buffer, + GLenum pname, + GLintptr offset) +{ + return GL_GetQueryBufferObjectui64v(id, buffer, pname, offset); +} + +void GL_APIENTRY glGetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) +{ + return GL_GetQueryBufferObjectuiv(id, buffer, pname, offset); +} + +void GL_APIENTRY glGetTextureImage(GLuint texture, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels) +{ + return GL_GetTextureImage(texture, level, format, type, bufSize, pixels); +} + +void GL_APIENTRY glGetTextureLevelParameterfv(GLuint texture, + GLint level, + GLenum pname, + GLfloat *params) +{ + return GL_GetTextureLevelParameterfv(texture, level, pname, params); +} + +void GL_APIENTRY glGetTextureLevelParameteriv(GLuint texture, + GLint level, + GLenum pname, + GLint *params) +{ + return GL_GetTextureLevelParameteriv(texture, level, pname, params); +} + +void GL_APIENTRY glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params) +{ + return GL_GetTextureParameterIiv(texture, pname, params); +} + +void GL_APIENTRY glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params) +{ + return GL_GetTextureParameterIuiv(texture, pname, params); +} + +void GL_APIENTRY glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params) +{ + return GL_GetTextureParameterfv(texture, pname, params); +} + +void GL_APIENTRY glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params) +{ + return GL_GetTextureParameteriv(texture, pname, params); +} + +void GL_APIENTRY glGetTextureSubImage(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels) +{ + return GL_GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, + format, type, bufSize, pixels); +} + +void GL_APIENTRY glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param) +{ + return GL_GetTransformFeedbacki64_v(xfb, pname, index, param); +} + +void GL_APIENTRY glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param) +{ + return GL_GetTransformFeedbacki_v(xfb, pname, index, param); +} + +void GL_APIENTRY glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param) +{ + return GL_GetTransformFeedbackiv(xfb, pname, param); +} + +void GL_APIENTRY glGetVertexArrayIndexed64iv(GLuint vaobj, + GLuint index, + GLenum pname, + GLint64 *param) +{ + return GL_GetVertexArrayIndexed64iv(vaobj, index, pname, param); +} + +void GL_APIENTRY glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param) +{ + return GL_GetVertexArrayIndexediv(vaobj, index, pname, param); +} + +void GL_APIENTRY glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param) +{ + return GL_GetVertexArrayiv(vaobj, pname, param); +} + +void GL_APIENTRY +glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table) +{ + return GL_GetnColorTable(target, format, type, bufSize, table); +} + +void GL_APIENTRY glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels) +{ + return GL_GetnCompressedTexImage(target, lod, bufSize, pixels); +} + +void GL_APIENTRY +glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image) +{ + return GL_GetnConvolutionFilter(target, format, type, bufSize, image); +} + +void GL_APIENTRY glGetnHistogram(GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values) +{ + return GL_GetnHistogram(target, reset, format, type, bufSize, values); +} + +void GL_APIENTRY glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v) +{ + return GL_GetnMapdv(target, query, bufSize, v); +} + +void GL_APIENTRY glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v) +{ + return GL_GetnMapfv(target, query, bufSize, v); +} + +void GL_APIENTRY glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v) +{ + return GL_GetnMapiv(target, query, bufSize, v); +} + +void GL_APIENTRY glGetnMinmax(GLenum target, + GLboolean reset, + GLenum format, + GLenum type, + GLsizei bufSize, + void *values) +{ + return GL_GetnMinmax(target, reset, format, type, bufSize, values); +} + +void GL_APIENTRY glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values) +{ + return GL_GetnPixelMapfv(map, bufSize, values); +} + +void GL_APIENTRY glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values) +{ + return GL_GetnPixelMapuiv(map, bufSize, values); +} + +void GL_APIENTRY glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values) +{ + return GL_GetnPixelMapusv(map, bufSize, values); +} + +void GL_APIENTRY glGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern) +{ + return GL_GetnPolygonStipple(bufSize, pattern); +} + +void GL_APIENTRY glGetnSeparableFilter(GLenum target, + GLenum format, + GLenum type, + GLsizei rowBufSize, + void *row, + GLsizei columnBufSize, + void *column, + void *span) +{ + return GL_GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, + span); +} + +void GL_APIENTRY glGetnTexImage(GLenum target, + GLint level, + GLenum format, + GLenum type, + GLsizei bufSize, + void *pixels) +{ + return GL_GetnTexImage(target, level, format, type, bufSize, pixels); +} + +void GL_APIENTRY glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params) +{ + return GL_GetnUniformdv(program, location, bufSize, params); +} + +void GL_APIENTRY glInvalidateNamedFramebufferData(GLuint framebuffer, + GLsizei numAttachments, + const GLenum *attachments) +{ + return GL_InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments); +} + +void GL_APIENTRY glInvalidateNamedFramebufferSubData(GLuint framebuffer, + GLsizei numAttachments, + const GLenum *attachments, + GLint x, + GLint y, + GLsizei width, + GLsizei height) +{ + return GL_InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, + width, height); +} + +void *GL_APIENTRY glMapNamedBuffer(GLuint buffer, GLenum access) +{ + return GL_MapNamedBuffer(buffer, access); +} + +void *GL_APIENTRY glMapNamedBufferRange(GLuint buffer, + GLintptr offset, + GLsizeiptr length, + GLbitfield access) +{ + return GL_MapNamedBufferRange(buffer, offset, length, access); +} + +void GL_APIENTRY glNamedBufferData(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage) +{ + return GL_NamedBufferData(buffer, size, data, usage); +} + +void GL_APIENTRY glNamedBufferStorage(GLuint buffer, + GLsizeiptr size, + const void *data, + GLbitfield flags) +{ + return GL_NamedBufferStorage(buffer, size, data, flags); +} + +void GL_APIENTRY glNamedBufferSubData(GLuint buffer, + GLintptr offset, + GLsizeiptr size, + const void *data) +{ + return GL_NamedBufferSubData(buffer, offset, size, data); +} + +void GL_APIENTRY glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf) +{ + return GL_NamedFramebufferDrawBuffer(framebuffer, buf); +} + +void GL_APIENTRY glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs) +{ + return GL_NamedFramebufferDrawBuffers(framebuffer, n, bufs); +} + +void GL_APIENTRY glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param) +{ + return GL_NamedFramebufferParameteri(framebuffer, pname, param); +} + +void GL_APIENTRY glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src) +{ + return GL_NamedFramebufferReadBuffer(framebuffer, src); +} + +void GL_APIENTRY glNamedFramebufferRenderbuffer(GLuint framebuffer, + GLenum attachment, + GLenum renderbuffertarget, + GLuint renderbuffer) +{ + return GL_NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, + renderbuffer); +} + +void GL_APIENTRY glNamedFramebufferTexture(GLuint framebuffer, + GLenum attachment, + GLuint texture, + GLint level) +{ + return GL_NamedFramebufferTexture(framebuffer, attachment, texture, level); +} + +void GL_APIENTRY glNamedFramebufferTextureLayer(GLuint framebuffer, + GLenum attachment, + GLuint texture, + GLint level, + GLint layer) +{ + return GL_NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer); +} + +void GL_APIENTRY glNamedRenderbufferStorage(GLuint renderbuffer, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_NamedRenderbufferStorage(renderbuffer, internalformat, width, height); +} + +void GL_APIENTRY glNamedRenderbufferStorageMultisample(GLuint renderbuffer, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, + height); +} + +void GL_APIENTRY glTextureBarrier() +{ + return GL_TextureBarrier(); +} + +void GL_APIENTRY glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer) +{ + return GL_TextureBuffer(texture, internalformat, buffer); +} + +void GL_APIENTRY glTextureBufferRange(GLuint texture, + GLenum internalformat, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + return GL_TextureBufferRange(texture, internalformat, buffer, offset, size); +} + +void GL_APIENTRY glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params) +{ + return GL_TextureParameterIiv(texture, pname, params); +} + +void GL_APIENTRY glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params) +{ + return GL_TextureParameterIuiv(texture, pname, params); +} + +void GL_APIENTRY glTextureParameterf(GLuint texture, GLenum pname, GLfloat param) +{ + return GL_TextureParameterf(texture, pname, param); +} + +void GL_APIENTRY glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param) +{ + return GL_TextureParameterfv(texture, pname, param); +} + +void GL_APIENTRY glTextureParameteri(GLuint texture, GLenum pname, GLint param) +{ + return GL_TextureParameteri(texture, pname, param); +} + +void GL_APIENTRY glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param) +{ + return GL_TextureParameteriv(texture, pname, param); +} + +void GL_APIENTRY glTextureStorage1D(GLuint texture, + GLsizei levels, + GLenum internalformat, + GLsizei width) +{ + return GL_TextureStorage1D(texture, levels, internalformat, width); +} + +void GL_APIENTRY glTextureStorage2D(GLuint texture, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height) +{ + return GL_TextureStorage2D(texture, levels, internalformat, width, height); +} + +void GL_APIENTRY glTextureStorage2DMultisample(GLuint texture, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLboolean fixedsamplelocations) +{ + return GL_TextureStorage2DMultisample(texture, samples, internalformat, width, height, + fixedsamplelocations); +} + +void GL_APIENTRY glTextureStorage3D(GLuint texture, + GLsizei levels, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth) +{ + return GL_TextureStorage3D(texture, levels, internalformat, width, height, depth); +} + +void GL_APIENTRY glTextureStorage3DMultisample(GLuint texture, + GLsizei samples, + GLenum internalformat, + GLsizei width, + GLsizei height, + GLsizei depth, + GLboolean fixedsamplelocations) +{ + return GL_TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, + fixedsamplelocations); +} + +void GL_APIENTRY glTextureSubImage1D(GLuint texture, + GLint level, + GLint xoffset, + GLsizei width, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TextureSubImage1D(texture, level, xoffset, width, format, type, pixels); +} + +void GL_APIENTRY glTextureSubImage2D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLsizei width, + GLsizei height, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, + pixels); +} + +void GL_APIENTRY glTextureSubImage3D(GLuint texture, + GLint level, + GLint xoffset, + GLint yoffset, + GLint zoffset, + GLsizei width, + GLsizei height, + GLsizei depth, + GLenum format, + GLenum type, + const void *pixels) +{ + return GL_TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, + format, type, pixels); +} + +void GL_APIENTRY glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer) +{ + return GL_TransformFeedbackBufferBase(xfb, index, buffer); +} + +void GL_APIENTRY glTransformFeedbackBufferRange(GLuint xfb, + GLuint index, + GLuint buffer, + GLintptr offset, + GLsizeiptr size) +{ + return GL_TransformFeedbackBufferRange(xfb, index, buffer, offset, size); +} + +GLboolean GL_APIENTRY glUnmapNamedBuffer(GLuint buffer) +{ + return GL_UnmapNamedBuffer(buffer); +} + +void GL_APIENTRY glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex) +{ + return GL_VertexArrayAttribBinding(vaobj, attribindex, bindingindex); +} + +void GL_APIENTRY glVertexArrayAttribFormat(GLuint vaobj, + GLuint attribindex, + GLint size, + GLenum type, + GLboolean normalized, + GLuint relativeoffset) +{ + return GL_VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset); +} + +void GL_APIENTRY glVertexArrayAttribIFormat(GLuint vaobj, + GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset) +{ + return GL_VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset); +} + +void GL_APIENTRY glVertexArrayAttribLFormat(GLuint vaobj, + GLuint attribindex, + GLint size, + GLenum type, + GLuint relativeoffset) +{ + return GL_VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset); +} + +void GL_APIENTRY glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor) +{ + return GL_VertexArrayBindingDivisor(vaobj, bindingindex, divisor); +} + +void GL_APIENTRY glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer) +{ + return GL_VertexArrayElementBuffer(vaobj, buffer); +} + +void GL_APIENTRY glVertexArrayVertexBuffer(GLuint vaobj, + GLuint bindingindex, + GLuint buffer, + GLintptr offset, + GLsizei stride) +{ + return GL_VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride); +} + +void GL_APIENTRY glVertexArrayVertexBuffers(GLuint vaobj, + GLuint first, + GLsizei count, + const GLuint *buffers, + const GLintptr *offsets, + const GLsizei *strides) +{ + return GL_VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides); +} + +// GL 4.6 +void GL_APIENTRY glMultiDrawArraysIndirectCount(GLenum mode, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride) +{ + return GL_MultiDrawArraysIndirectCount(mode, indirect, drawcount, maxdrawcount, stride); +} + +void GL_APIENTRY glMultiDrawElementsIndirectCount(GLenum mode, + GLenum type, + const void *indirect, + GLintptr drawcount, + GLsizei maxdrawcount, + GLsizei stride) +{ + return GL_MultiDrawElementsIndirectCount(mode, type, indirect, drawcount, maxdrawcount, stride); +} + +void GL_APIENTRY glPolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp) +{ + return GL_PolygonOffsetClamp(factor, units, clamp); +} + +void GL_APIENTRY glSpecializeShader(GLuint shader, + const GLchar *pEntryPoint, + GLuint numSpecializationConstants, + const GLuint *pConstantIndex, + const GLuint *pConstantValue) +{ + return GL_SpecializeShader(shader, pEntryPoint, numSpecializationConstants, pConstantIndex, + pConstantValue); +} + +#endif // defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND) +} // extern "C" diff --git a/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def new file mode 100644 index 0000000000..c192344a35 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/libGLESv2_autogen.def @@ -0,0 +1,1362 @@ +; GENERATED FILE - DO NOT EDIT. +; Generated by generate_entry_points.py using data from Khronos and ANGLE XML files. +; +; 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. +LIBRARY libGLESv2 +EXPORTS + + ; OpenGL ES 2.0 + glActiveTexture + glAttachShader + glBindAttribLocation + glBindBuffer + glBindFramebuffer + glBindRenderbuffer + glBindTexture + glBlendColor + glBlendEquation + glBlendEquationSeparate + glBlendFunc + glBlendFuncSeparate + glBufferData + glBufferSubData + glCheckFramebufferStatus + glClear + glClearColor + glClearDepthf + glClearStencil + glColorMask + glCompileShader + glCompressedTexImage2D + glCompressedTexSubImage2D + glCopyTexImage2D + glCopyTexSubImage2D + glCreateProgram + glCreateShader + glCullFace + glDeleteBuffers + glDeleteFramebuffers + glDeleteProgram + glDeleteRenderbuffers + glDeleteShader + glDeleteTextures + glDepthFunc + glDepthMask + glDepthRangef + glDetachShader + glDisable + glDisableVertexAttribArray + glDrawArrays + glDrawElements + glEnable + glEnableVertexAttribArray + glFinish + glFlush + glFramebufferRenderbuffer + glFramebufferTexture2D + glFrontFace + glGenBuffers + glGenFramebuffers + glGenRenderbuffers + glGenTextures + glGenerateMipmap + glGetActiveAttrib + glGetActiveUniform + glGetAttachedShaders + glGetAttribLocation + glGetBooleanv + glGetBufferParameteriv + glGetError + glGetFloatv + glGetFramebufferAttachmentParameteriv + glGetIntegerv + glGetProgramInfoLog + glGetProgramiv + glGetRenderbufferParameteriv + glGetShaderInfoLog + glGetShaderPrecisionFormat + glGetShaderSource + glGetShaderiv + glGetString + glGetTexParameterfv + glGetTexParameteriv + glGetUniformLocation + glGetUniformfv + glGetUniformiv + glGetVertexAttribPointerv + glGetVertexAttribfv + glGetVertexAttribiv + glHint + glIsBuffer + glIsEnabled + glIsFramebuffer + glIsProgram + glIsRenderbuffer + glIsShader + glIsTexture + glLineWidth + glLinkProgram + glPixelStorei + glPolygonOffset + glReadPixels + glReleaseShaderCompiler + glRenderbufferStorage + glSampleCoverage + glScissor + glShaderBinary + glShaderSource + glStencilFunc + glStencilFuncSeparate + glStencilMask + glStencilMaskSeparate + glStencilOp + glStencilOpSeparate + glTexImage2D + glTexParameterf + glTexParameterfv + glTexParameteri + glTexParameteriv + glTexSubImage2D + glUniform1f + glUniform1fv + glUniform1i + glUniform1iv + glUniform2f + glUniform2fv + glUniform2i + glUniform2iv + glUniform3f + glUniform3fv + glUniform3i + glUniform3iv + glUniform4f + glUniform4fv + glUniform4i + glUniform4iv + glUniformMatrix2fv + glUniformMatrix3fv + glUniformMatrix4fv + glUseProgram + glValidateProgram + glVertexAttrib1f + glVertexAttrib1fv + glVertexAttrib2f + glVertexAttrib2fv + glVertexAttrib3f + glVertexAttrib3fv + glVertexAttrib4f + glVertexAttrib4fv + glVertexAttribPointer + glViewport + + ; OpenGL ES 3.0 + glBeginQuery + glBeginTransformFeedback + glBindBufferBase + glBindBufferRange + glBindSampler + glBindTransformFeedback + glBindVertexArray + glBlitFramebuffer + glClearBufferfi + glClearBufferfv + glClearBufferiv + glClearBufferuiv + glClientWaitSync + glCompressedTexImage3D + glCompressedTexSubImage3D + glCopyBufferSubData + glCopyTexSubImage3D + glDeleteQueries + glDeleteSamplers + glDeleteSync + glDeleteTransformFeedbacks + glDeleteVertexArrays + glDrawArraysInstanced + glDrawBuffers + glDrawElementsInstanced + glDrawRangeElements + glEndQuery + glEndTransformFeedback + glFenceSync + glFlushMappedBufferRange + glFramebufferTextureLayer + glGenQueries + glGenSamplers + glGenTransformFeedbacks + glGenVertexArrays + glGetActiveUniformBlockName + glGetActiveUniformBlockiv + glGetActiveUniformsiv + glGetBufferParameteri64v + glGetBufferPointerv + glGetFragDataLocation + glGetInteger64i_v + glGetInteger64v + glGetIntegeri_v + glGetInternalformativ + glGetProgramBinary + glGetQueryObjectuiv + glGetQueryiv + glGetSamplerParameterfv + glGetSamplerParameteriv + glGetStringi + glGetSynciv + glGetTransformFeedbackVarying + glGetUniformBlockIndex + glGetUniformIndices + glGetUniformuiv + glGetVertexAttribIiv + glGetVertexAttribIuiv + glInvalidateFramebuffer + glInvalidateSubFramebuffer + glIsQuery + glIsSampler + glIsSync + glIsTransformFeedback + glIsVertexArray + glMapBufferRange + glPauseTransformFeedback + glProgramBinary + glProgramParameteri + glReadBuffer + glRenderbufferStorageMultisample + glResumeTransformFeedback + glSamplerParameterf + glSamplerParameterfv + glSamplerParameteri + glSamplerParameteriv + glTexImage3D + glTexStorage2D + glTexStorage3D + glTexSubImage3D + glTransformFeedbackVaryings + glUniform1ui + glUniform1uiv + glUniform2ui + glUniform2uiv + glUniform3ui + glUniform3uiv + glUniform4ui + glUniform4uiv + glUniformBlockBinding + glUniformMatrix2x3fv + glUniformMatrix2x4fv + glUniformMatrix3x2fv + glUniformMatrix3x4fv + glUniformMatrix4x2fv + glUniformMatrix4x3fv + glUnmapBuffer + glVertexAttribDivisor + glVertexAttribI4i + glVertexAttribI4iv + glVertexAttribI4ui + glVertexAttribI4uiv + glVertexAttribIPointer + glWaitSync + + ; OpenGL ES 3.1 + glActiveShaderProgram + glBindImageTexture + glBindProgramPipeline + glBindVertexBuffer + glCreateShaderProgramv + glDeleteProgramPipelines + glDispatchCompute + glDispatchComputeIndirect + glDrawArraysIndirect + glDrawElementsIndirect + glFramebufferParameteri + glGenProgramPipelines + glGetBooleani_v + glGetFramebufferParameteriv + glGetMultisamplefv + glGetProgramInterfaceiv + glGetProgramPipelineInfoLog + glGetProgramPipelineiv + glGetProgramResourceIndex + glGetProgramResourceLocation + glGetProgramResourceName + glGetProgramResourceiv + glGetTexLevelParameterfv + glGetTexLevelParameteriv + glIsProgramPipeline + glMemoryBarrier + glMemoryBarrierByRegion + glProgramUniform1f + glProgramUniform1fv + glProgramUniform1i + glProgramUniform1iv + glProgramUniform1ui + glProgramUniform1uiv + glProgramUniform2f + glProgramUniform2fv + glProgramUniform2i + glProgramUniform2iv + glProgramUniform2ui + glProgramUniform2uiv + glProgramUniform3f + glProgramUniform3fv + glProgramUniform3i + glProgramUniform3iv + glProgramUniform3ui + glProgramUniform3uiv + glProgramUniform4f + glProgramUniform4fv + glProgramUniform4i + glProgramUniform4iv + glProgramUniform4ui + glProgramUniform4uiv + glProgramUniformMatrix2fv + glProgramUniformMatrix2x3fv + glProgramUniformMatrix2x4fv + glProgramUniformMatrix3fv + glProgramUniformMatrix3x2fv + glProgramUniformMatrix3x4fv + glProgramUniformMatrix4fv + glProgramUniformMatrix4x2fv + glProgramUniformMatrix4x3fv + glSampleMaski + glTexStorage2DMultisample + glUseProgramStages + glValidateProgramPipeline + glVertexAttribBinding + glVertexAttribFormat + glVertexAttribIFormat + glVertexBindingDivisor + + ; OpenGL ES 3.2 + glBlendBarrier + glBlendEquationSeparatei + glBlendEquationi + glBlendFuncSeparatei + glBlendFunci + glColorMaski + glCopyImageSubData + glDebugMessageCallback + glDebugMessageControl + glDebugMessageInsert + glDisablei + glDrawElementsBaseVertex + glDrawElementsInstancedBaseVertex + glDrawRangeElementsBaseVertex + glEnablei + glFramebufferTexture + glGetDebugMessageLog + glGetGraphicsResetStatus + glGetObjectLabel + glGetObjectPtrLabel + glGetPointerv + glGetSamplerParameterIiv + glGetSamplerParameterIuiv + glGetTexParameterIiv + glGetTexParameterIuiv + glGetnUniformfv + glGetnUniformiv + glGetnUniformuiv + glIsEnabledi + glMinSampleShading + glObjectLabel + glObjectPtrLabel + glPatchParameteri + glPopDebugGroup + glPrimitiveBoundingBox + glPushDebugGroup + glReadnPixels + glSamplerParameterIiv + glSamplerParameterIuiv + glTexBuffer + glTexBufferRange + glTexParameterIiv + glTexParameterIuiv + glTexStorage3DMultisample + + ; OpenGL ES 1.0 + glAlphaFunc + glAlphaFuncx + glClearColorx + glClearDepthx + glClientActiveTexture + glClipPlanef + glClipPlanex + glColor4f + glColor4ub + glColor4x + glColorPointer + glDepthRangex + glDisableClientState + glEnableClientState + glFogf + glFogfv + glFogx + glFogxv + glFrustumf + glFrustumx + glGetClipPlanef + glGetClipPlanex + glGetFixedv + glGetLightfv + glGetLightxv + glGetMaterialfv + glGetMaterialxv + glGetTexEnvfv + glGetTexEnviv + glGetTexEnvxv + glGetTexParameterxv + glLightModelf + glLightModelfv + glLightModelx + glLightModelxv + glLightf + glLightfv + glLightx + glLightxv + glLineWidthx + glLoadIdentity + glLoadMatrixf + glLoadMatrixx + glLogicOp + glMaterialf + glMaterialfv + glMaterialx + glMaterialxv + glMatrixMode + glMultMatrixf + glMultMatrixx + glMultiTexCoord4f + glMultiTexCoord4x + glNormal3f + glNormal3x + glNormalPointer + glOrthof + glOrthox + glPointParameterf + glPointParameterfv + glPointParameterx + glPointParameterxv + glPointSize + glPointSizex + glPolygonOffsetx + glPopMatrix + glPushMatrix + glRotatef + glRotatex + glSampleCoveragex + glScalef + glScalex + glShadeModel + glTexCoordPointer + glTexEnvf + glTexEnvfv + glTexEnvi + glTexEnviv + glTexEnvx + glTexEnvxv + glTexParameterx + glTexParameterxv + glTranslatef + glTranslatex + glVertexPointer + + ; GL_AMD_performance_monitor + glBeginPerfMonitorAMD + glDeletePerfMonitorsAMD + glEndPerfMonitorAMD + glGenPerfMonitorsAMD + glGetPerfMonitorCounterDataAMD + glGetPerfMonitorCounterInfoAMD + glGetPerfMonitorCounterStringAMD + glGetPerfMonitorCountersAMD + glGetPerfMonitorGroupStringAMD + glGetPerfMonitorGroupsAMD + glSelectPerfMonitorCountersAMD + + ; GL_ANDROID_extension_pack_es31a + + ; GL_ANGLE_base_vertex_base_instance + glDrawArraysInstancedBaseInstanceANGLE + glDrawElementsInstancedBaseVertexBaseInstanceANGLE + glMultiDrawArraysInstancedBaseInstanceANGLE + glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE + + ; GL_ANGLE_copy_texture_3d + glCopySubTexture3DANGLE + glCopyTexture3DANGLE + + ; GL_ANGLE_depth_texture + + ; GL_ANGLE_framebuffer_blit + glBlitFramebufferANGLE + + ; GL_ANGLE_framebuffer_multisample + glRenderbufferStorageMultisampleANGLE + + ; GL_ANGLE_get_image + glGetCompressedTexImageANGLE + glGetRenderbufferImageANGLE + glGetTexImageANGLE + + ; GL_ANGLE_get_tex_level_parameter + glGetTexLevelParameterfvANGLE + glGetTexLevelParameterivANGLE + + ; GL_ANGLE_instanced_arrays + glDrawArraysInstancedANGLE + glDrawElementsInstancedANGLE + glVertexAttribDivisorANGLE + + ; GL_ANGLE_logic_op + glLogicOpANGLE + + ; GL_ANGLE_memory_object_flags + glTexStorageMemFlags2DANGLE + glTexStorageMemFlags2DMultisampleANGLE + glTexStorageMemFlags3DANGLE + glTexStorageMemFlags3DMultisampleANGLE + + ; GL_ANGLE_memory_object_fuchsia + glImportMemoryZirconHandleANGLE + + ; GL_ANGLE_multi_draw + glMultiDrawArraysANGLE + glMultiDrawArraysInstancedANGLE + glMultiDrawElementsANGLE + glMultiDrawElementsInstancedANGLE + + ; GL_ANGLE_pack_reverse_row_order + + ; GL_ANGLE_program_binary + + ; GL_ANGLE_provoking_vertex + glProvokingVertexANGLE + + ; GL_ANGLE_request_extension + glDisableExtensionANGLE + glRequestExtensionANGLE + + ; GL_ANGLE_robust_client_memory + glCompressedTexImage2DRobustANGLE + glCompressedTexImage3DRobustANGLE + glCompressedTexSubImage2DRobustANGLE + glCompressedTexSubImage3DRobustANGLE + glGetActiveUniformBlockivRobustANGLE + glGetBooleani_vRobustANGLE + glGetBooleanvRobustANGLE + glGetBufferParameteri64vRobustANGLE + glGetBufferParameterivRobustANGLE + glGetBufferPointervRobustANGLE + glGetFloatvRobustANGLE + glGetFramebufferAttachmentParameterivRobustANGLE + glGetFramebufferParameterivRobustANGLE + glGetInteger64i_vRobustANGLE + glGetInteger64vRobustANGLE + glGetIntegeri_vRobustANGLE + glGetIntegervRobustANGLE + glGetInternalformativRobustANGLE + glGetMultisamplefvRobustANGLE + glGetPointervRobustANGLERobustANGLE + glGetProgramInterfaceivRobustANGLE + glGetProgramivRobustANGLE + glGetQueryObjecti64vRobustANGLE + glGetQueryObjectivRobustANGLE + glGetQueryObjectui64vRobustANGLE + glGetQueryObjectuivRobustANGLE + glGetQueryivRobustANGLE + glGetRenderbufferParameterivRobustANGLE + glGetSamplerParameterIivRobustANGLE + glGetSamplerParameterIuivRobustANGLE + glGetSamplerParameterfvRobustANGLE + glGetSamplerParameterivRobustANGLE + glGetShaderivRobustANGLE + glGetTexLevelParameterfvRobustANGLE + glGetTexLevelParameterivRobustANGLE + glGetTexParameterIivRobustANGLE + glGetTexParameterIuivRobustANGLE + glGetTexParameterfvRobustANGLE + glGetTexParameterivRobustANGLE + glGetUniformfvRobustANGLE + glGetUniformivRobustANGLE + glGetUniformuivRobustANGLE + glGetVertexAttribIivRobustANGLE + glGetVertexAttribIuivRobustANGLE + glGetVertexAttribPointervRobustANGLE + glGetVertexAttribfvRobustANGLE + glGetVertexAttribivRobustANGLE + glGetnUniformfvRobustANGLE + glGetnUniformivRobustANGLE + glGetnUniformuivRobustANGLE + glReadPixelsRobustANGLE + glReadnPixelsRobustANGLE + glSamplerParameterIivRobustANGLE + glSamplerParameterIuivRobustANGLE + glSamplerParameterfvRobustANGLE + glSamplerParameterivRobustANGLE + glTexImage2DRobustANGLE + glTexImage3DRobustANGLE + glTexParameterIivRobustANGLE + glTexParameterIuivRobustANGLE + glTexParameterfvRobustANGLE + glTexParameterivRobustANGLE + glTexSubImage2DRobustANGLE + glTexSubImage3DRobustANGLE + + ; GL_ANGLE_robust_resource_initialization + + ; GL_ANGLE_semaphore_fuchsia + glImportSemaphoreZirconHandleANGLE + + ; GL_ANGLE_shader_pixel_local_storage + glBeginPixelLocalStorageANGLE + glEndPixelLocalStorageANGLE + glFramebufferMemorylessPixelLocalStorageANGLE + glFramebufferTexturePixelLocalStorageANGLE + glPixelLocalStorageBarrierANGLE + + ; GL_ANGLE_texture_compression_dxt3 + + ; GL_ANGLE_texture_compression_dxt5 + + ; GL_ANGLE_texture_external_update + glInvalidateTextureANGLE + glTexImage2DExternalANGLE + + ; GL_ANGLE_texture_multisample + glGetMultisamplefvANGLE + glSampleMaskiANGLE + glTexStorage2DMultisampleANGLE + + ; GL_ANGLE_texture_usage + + ; GL_ANGLE_translated_shader_source + glGetTranslatedShaderSourceANGLE + + ; GL_ANGLE_vulkan_image + glAcquireTexturesANGLE + glReleaseTexturesANGLE + + ; GL_APPLE_clip_distance + + ; GL_ARB_sync + + ; GL_CHROMIUM_bind_uniform_location + glBindUniformLocationCHROMIUM + + ; GL_CHROMIUM_copy_compressed_texture + glCompressedCopyTextureCHROMIUM + + ; GL_CHROMIUM_copy_texture + glCopySubTextureCHROMIUM + glCopyTextureCHROMIUM + + ; GL_CHROMIUM_framebuffer_mixed_samples + glCoverageModulationCHROMIUM + + ; GL_CHROMIUM_lose_context + glLoseContextCHROMIUM + + ; GL_EXT_EGL_image_array + + ; GL_EXT_EGL_image_storage + glEGLImageTargetTexStorageEXT + glEGLImageTargetTextureStorageEXT + + ; GL_EXT_YUV_target + + ; GL_EXT_base_instance + glDrawArraysInstancedBaseInstanceEXT + glDrawElementsInstancedBaseInstanceEXT + glDrawElementsInstancedBaseVertexBaseInstanceEXT + + ; GL_EXT_blend_func_extended + glBindFragDataLocationEXT + glBindFragDataLocationIndexedEXT + glGetFragDataIndexEXT + glGetProgramResourceLocationIndexEXT + + ; GL_EXT_blend_minmax + + ; GL_EXT_buffer_storage + glBufferStorageEXT + + ; GL_EXT_clip_control + glClipControlEXT + + ; GL_EXT_clip_cull_distance + + ; GL_EXT_color_buffer_float + + ; GL_EXT_color_buffer_half_float + + ; GL_EXT_copy_image + glCopyImageSubDataEXT + + ; GL_EXT_debug_label + glGetObjectLabelEXT + glLabelObjectEXT + + ; GL_EXT_debug_marker + glInsertEventMarkerEXT + glPopGroupMarkerEXT + glPushGroupMarkerEXT + + ; GL_EXT_discard_framebuffer + glDiscardFramebufferEXT + + ; GL_EXT_disjoint_timer_query + glBeginQueryEXT + glDeleteQueriesEXT + glEndQueryEXT + glGenQueriesEXT + glGetInteger64vEXT + glGetQueryObjecti64vEXT + glGetQueryObjectivEXT + glGetQueryObjectui64vEXT + glGetQueryObjectuivEXT + glGetQueryivEXT + glIsQueryEXT + glQueryCounterEXT + + ; GL_EXT_draw_buffers + glDrawBuffersEXT + + ; GL_EXT_draw_buffers_indexed + glBlendEquationSeparateiEXT + glBlendEquationiEXT + glBlendFuncSeparateiEXT + glBlendFunciEXT + glColorMaskiEXT + glDisableiEXT + glEnableiEXT + glIsEnablediEXT + + ; GL_EXT_draw_elements_base_vertex + glDrawElementsBaseVertexEXT + glDrawElementsInstancedBaseVertexEXT + glDrawRangeElementsBaseVertexEXT + glMultiDrawElementsBaseVertexEXT + + ; GL_EXT_external_buffer + glBufferStorageExternalEXT + glNamedBufferStorageExternalEXT + + ; GL_EXT_float_blend + + ; GL_EXT_geometry_shader + glFramebufferTextureEXT + + ; GL_EXT_gpu_shader5 + + ; GL_EXT_instanced_arrays + glDrawArraysInstancedEXT + glDrawElementsInstancedEXT + glVertexAttribDivisorEXT + + ; GL_EXT_map_buffer_range + glFlushMappedBufferRangeEXT + glMapBufferRangeEXT + + ; GL_EXT_memory_object + glBufferStorageMemEXT + glCreateMemoryObjectsEXT + glDeleteMemoryObjectsEXT + glGetMemoryObjectParameterivEXT + glGetUnsignedBytei_vEXT + glGetUnsignedBytevEXT + glIsMemoryObjectEXT + glMemoryObjectParameterivEXT + glTexStorageMem2DEXT + glTexStorageMem2DMultisampleEXT + glTexStorageMem3DEXT + glTexStorageMem3DMultisampleEXT + + ; GL_EXT_memory_object_fd + glImportMemoryFdEXT + + ; GL_EXT_multi_draw_indirect + glMultiDrawArraysIndirectEXT + glMultiDrawElementsIndirectEXT + + ; GL_EXT_multisampled_render_to_texture + glFramebufferTexture2DMultisampleEXT + glRenderbufferStorageMultisampleEXT + + ; GL_EXT_multisampled_render_to_texture2 + + ; GL_EXT_occlusion_query_boolean + + ; GL_EXT_primitive_bounding_box + glPrimitiveBoundingBoxEXT + + ; GL_EXT_protected_textures + + ; GL_EXT_pvrtc_sRGB + + ; GL_EXT_read_format_bgra + + ; GL_EXT_robustness + glGetGraphicsResetStatusEXT + glGetnUniformfvEXT + glGetnUniformivEXT + glReadnPixelsEXT + + ; GL_EXT_sRGB + + ; GL_EXT_sRGB_write_control + + ; GL_EXT_semaphore + glDeleteSemaphoresEXT + glGenSemaphoresEXT + glGetSemaphoreParameterui64vEXT + glIsSemaphoreEXT + glSemaphoreParameterui64vEXT + glSignalSemaphoreEXT + glWaitSemaphoreEXT + + ; GL_EXT_semaphore_fd + glImportSemaphoreFdEXT + + ; GL_EXT_separate_shader_objects + glActiveShaderProgramEXT + glBindProgramPipelineEXT + glCreateShaderProgramvEXT + glDeleteProgramPipelinesEXT + glGenProgramPipelinesEXT + glGetProgramPipelineInfoLogEXT + glGetProgramPipelineivEXT + glIsProgramPipelineEXT + glProgramParameteriEXT + glProgramUniform1fEXT + glProgramUniform1fvEXT + glProgramUniform1iEXT + glProgramUniform1ivEXT + glProgramUniform1uiEXT + glProgramUniform1uivEXT + glProgramUniform2fEXT + glProgramUniform2fvEXT + glProgramUniform2iEXT + glProgramUniform2ivEXT + glProgramUniform2uiEXT + glProgramUniform2uivEXT + glProgramUniform3fEXT + glProgramUniform3fvEXT + glProgramUniform3iEXT + glProgramUniform3ivEXT + glProgramUniform3uiEXT + glProgramUniform3uivEXT + glProgramUniform4fEXT + glProgramUniform4fvEXT + glProgramUniform4iEXT + glProgramUniform4ivEXT + glProgramUniform4uiEXT + glProgramUniform4uivEXT + glProgramUniformMatrix2fvEXT + glProgramUniformMatrix2x3fvEXT + glProgramUniformMatrix2x4fvEXT + glProgramUniformMatrix3fvEXT + glProgramUniformMatrix3x2fvEXT + glProgramUniformMatrix3x4fvEXT + glProgramUniformMatrix4fvEXT + glProgramUniformMatrix4x2fvEXT + glProgramUniformMatrix4x3fvEXT + glUseProgramStagesEXT + glValidateProgramPipelineEXT + + ; GL_EXT_shader_framebuffer_fetch + + ; GL_EXT_shader_framebuffer_fetch_non_coherent + glFramebufferFetchBarrierEXT + + ; GL_EXT_shader_io_blocks + + ; GL_EXT_shader_non_constant_global_initializers + + ; GL_EXT_shader_texture_lod + + ; GL_EXT_shadow_samplers + + ; GL_EXT_tessellation_shader + glPatchParameteriEXT + + ; GL_EXT_texture_border_clamp + glGetSamplerParameterIivEXT + glGetSamplerParameterIuivEXT + glGetTexParameterIivEXT + glGetTexParameterIuivEXT + glSamplerParameterIivEXT + glSamplerParameterIuivEXT + glTexParameterIivEXT + glTexParameterIuivEXT + + ; GL_EXT_texture_buffer + glTexBufferEXT + glTexBufferRangeEXT + + ; GL_EXT_texture_compression_bptc + + ; GL_EXT_texture_compression_dxt1 + + ; GL_EXT_texture_compression_rgtc + + ; GL_EXT_texture_compression_s3tc + + ; GL_EXT_texture_compression_s3tc_srgb + + ; GL_EXT_texture_cube_map_array + + ; GL_EXT_texture_filter_anisotropic + + ; GL_EXT_texture_format_BGRA8888 + + ; GL_EXT_texture_format_sRGB_override + + ; GL_EXT_texture_norm16 + + ; GL_EXT_texture_rg + + ; GL_EXT_texture_sRGB_R8 + + ; GL_EXT_texture_sRGB_RG8 + + ; GL_EXT_texture_sRGB_decode + + ; GL_EXT_texture_storage + glTexStorage1DEXT + glTexStorage2DEXT + glTexStorage3DEXT + + ; GL_EXT_texture_type_2_10_10_10_REV + + ; GL_EXT_unpack_subimage + + ; GL_IMG_texture_compression_pvrtc + + ; GL_IMG_texture_compression_pvrtc2 + + ; GL_KHR_blend_equation_advanced + glBlendBarrierKHR + + ; GL_KHR_debug + glDebugMessageCallbackKHR + glDebugMessageControlKHR + glDebugMessageInsertKHR + glGetDebugMessageLogKHR + glGetObjectLabelKHR + glGetObjectPtrLabelKHR + glGetPointervKHR + glObjectLabelKHR + glObjectPtrLabelKHR + glPopDebugGroupKHR + glPushDebugGroupKHR + + ; GL_KHR_no_error + + ; GL_KHR_parallel_shader_compile + glMaxShaderCompilerThreadsKHR + + ; GL_KHR_robust_buffer_access_behavior + + ; GL_KHR_texture_compression_astc_hdr + + ; GL_KHR_texture_compression_astc_ldr + + ; GL_KHR_texture_compression_astc_sliced_3d + + ; GL_MESA_framebuffer_flip_y + glFramebufferParameteriMESA + glGetFramebufferParameterivMESA + + ; GL_NV_fence + glDeleteFencesNV + glFinishFenceNV + glGenFencesNV + glGetFenceivNV + glIsFenceNV + glSetFenceNV + glTestFenceNV + + ; GL_NV_framebuffer_blit + glBlitFramebufferNV + + ; GL_NV_pixel_buffer_object + + ; GL_NV_read_depth + + ; GL_NV_read_depth_stencil + + ; GL_NV_read_stencil + + ; GL_NV_robustness_video_memory_purge + + ; GL_NV_shader_noperspective_interpolation + + ; GL_OES_EGL_image + glEGLImageTargetRenderbufferStorageOES + glEGLImageTargetTexture2DOES + + ; GL_OES_EGL_image_external + + ; GL_OES_EGL_image_external_essl3 + + ; GL_OES_compressed_ETC1_RGB8_texture + + ; GL_OES_compressed_paletted_texture + + ; GL_OES_copy_image + glCopyImageSubDataOES + + ; GL_OES_depth24 + + ; GL_OES_depth32 + + ; GL_OES_depth_texture + + ; GL_OES_draw_buffers_indexed + glBlendEquationSeparateiOES + glBlendEquationiOES + glBlendFuncSeparateiOES + glBlendFunciOES + glColorMaskiOES + glDisableiOES + glEnableiOES + glIsEnablediOES + + ; GL_OES_draw_elements_base_vertex + glDrawElementsBaseVertexOES + glDrawElementsInstancedBaseVertexOES + glDrawRangeElementsBaseVertexOES + + ; GL_OES_draw_texture + glDrawTexfOES + glDrawTexfvOES + glDrawTexiOES + glDrawTexivOES + glDrawTexsOES + glDrawTexsvOES + glDrawTexxOES + glDrawTexxvOES + + ; GL_OES_element_index_uint + + ; GL_OES_fbo_render_mipmap + + ; GL_OES_framebuffer_object + glBindFramebufferOES + glBindRenderbufferOES + glCheckFramebufferStatusOES + glDeleteFramebuffersOES + glDeleteRenderbuffersOES + glFramebufferRenderbufferOES + glFramebufferTexture2DOES + glGenFramebuffersOES + glGenRenderbuffersOES + glGenerateMipmapOES + glGetFramebufferAttachmentParameterivOES + glGetRenderbufferParameterivOES + glIsFramebufferOES + glIsRenderbufferOES + glRenderbufferStorageOES + + ; GL_OES_geometry_shader + glFramebufferTextureOES + + ; GL_OES_get_program_binary + glGetProgramBinaryOES + glProgramBinaryOES + + ; GL_OES_mapbuffer + glGetBufferPointervOES + glMapBufferOES + glUnmapBufferOES + + ; GL_OES_matrix_palette + glCurrentPaletteMatrixOES + glLoadPaletteFromModelViewMatrixOES + glMatrixIndexPointerOES + glWeightPointerOES + + ; GL_OES_packed_depth_stencil + + ; GL_OES_point_size_array + glPointSizePointerOES + + ; GL_OES_point_sprite + + ; GL_OES_primitive_bounding_box + glPrimitiveBoundingBoxOES + + ; GL_OES_query_matrix + glQueryMatrixxOES + + ; GL_OES_rgb8_rgba8 + + ; GL_OES_sample_shading + glMinSampleShadingOES + + ; GL_OES_sample_variables + + ; GL_OES_shader_image_atomic + + ; GL_OES_shader_io_blocks + + ; GL_OES_shader_multisample_interpolation + + ; GL_OES_standard_derivatives + + ; GL_OES_surfaceless_context + + ; GL_OES_texture_3D + glCompressedTexImage3DOES + glCompressedTexSubImage3DOES + glCopyTexSubImage3DOES + glFramebufferTexture3DOES + glTexImage3DOES + glTexSubImage3DOES + + ; GL_OES_texture_border_clamp + glGetSamplerParameterIivOES + glGetSamplerParameterIuivOES + glGetTexParameterIivOES + glGetTexParameterIuivOES + glSamplerParameterIivOES + glSamplerParameterIuivOES + glTexParameterIivOES + glTexParameterIuivOES + + ; GL_OES_texture_buffer + glTexBufferOES + glTexBufferRangeOES + + ; GL_OES_texture_compression_astc + + ; GL_OES_texture_cube_map + glGetTexGenfvOES + glGetTexGenivOES + glGetTexGenxvOES + glTexGenfOES + glTexGenfvOES + glTexGeniOES + glTexGenivOES + glTexGenxOES + glTexGenxvOES + + ; GL_OES_texture_cube_map_array + + ; GL_OES_texture_float + + ; GL_OES_texture_float_linear + + ; GL_OES_texture_half_float + + ; GL_OES_texture_half_float_linear + + ; GL_OES_texture_npot + + ; GL_OES_texture_stencil8 + + ; GL_OES_texture_storage_multisample_2d_array + glTexStorage3DMultisampleOES + + ; GL_OES_vertex_array_object + glBindVertexArrayOES + glDeleteVertexArraysOES + glGenVertexArraysOES + glIsVertexArrayOES + + ; GL_OES_vertex_half_float + + ; GL_OES_vertex_type_10_10_10_2 + + ; GL_OVR_multiview + glFramebufferTextureMultiviewOVR + + ; GL_OVR_multiview2 + + ; GL_QCOM_shading_rate + glShadingRateQCOM + + ; EGL 1.0 + EGL_ChooseConfig + EGL_CopyBuffers + EGL_CreateContext + EGL_CreatePbufferSurface + EGL_CreatePixmapSurface + EGL_CreateWindowSurface + EGL_DestroyContext + EGL_DestroySurface + EGL_GetConfigAttrib + EGL_GetConfigs + EGL_GetCurrentDisplay + EGL_GetCurrentSurface + EGL_GetDisplay + EGL_GetError + EGL_GetProcAddress + EGL_Initialize + EGL_MakeCurrent + EGL_QueryContext + EGL_QueryString + EGL_QuerySurface + EGL_SwapBuffers + EGL_Terminate + EGL_WaitGL + EGL_WaitNative + + ; EGL 1.1 + EGL_BindTexImage + EGL_ReleaseTexImage + EGL_SurfaceAttrib + EGL_SwapInterval + + ; EGL 1.2 + EGL_BindAPI + EGL_CreatePbufferFromClientBuffer + EGL_QueryAPI + EGL_ReleaseThread + EGL_WaitClient + + ; EGL 1.4 + EGL_GetCurrentContext + + ; EGL 1.5 + EGL_ClientWaitSync + EGL_CreateImage + EGL_CreatePlatformPixmapSurface + EGL_CreatePlatformWindowSurface + EGL_CreateSync + EGL_DestroyImage + EGL_DestroySync + EGL_GetPlatformDisplay + EGL_GetSyncAttrib + EGL_WaitSync + + ; EGL_ANDROID_blob_cache + EGL_SetBlobCacheFuncsANDROID + + ; EGL_ANDROID_create_native_client_buffer + EGL_CreateNativeClientBufferANDROID + + ; EGL_ANDROID_get_frame_timestamps + EGL_GetCompositorTimingANDROID + EGL_GetCompositorTimingSupportedANDROID + EGL_GetFrameTimestampSupportedANDROID + EGL_GetFrameTimestampsANDROID + EGL_GetNextFrameIdANDROID + + ; EGL_ANDROID_get_native_client_buffer + EGL_GetNativeClientBufferANDROID + + ; EGL_ANDROID_native_fence_sync + EGL_DupNativeFenceFDANDROID + + ; EGL_ANDROID_presentation_time + EGL_PresentationTimeANDROID + + ; EGL_ANGLE_device_creation + EGL_CreateDeviceANGLE + EGL_ReleaseDeviceANGLE + + ; EGL_ANGLE_feature_control + EGL_QueryDisplayAttribANGLE + EGL_QueryStringiANGLE + + ; EGL_ANGLE_metal_shared_event_sync + EGL_CopyMetalSharedEventANGLE + + ; EGL_ANGLE_power_preference + EGL_ForceGPUSwitchANGLE + EGL_HandleGPUSwitchANGLE + EGL_ReacquireHighPowerGPUANGLE + EGL_ReleaseHighPowerGPUANGLE + + ; EGL_ANGLE_prepare_swap_buffers + EGL_PrepareSwapBuffersANGLE + + ; EGL_ANGLE_program_cache_control + EGL_ProgramCacheGetAttribANGLE + EGL_ProgramCachePopulateANGLE + EGL_ProgramCacheQueryANGLE + EGL_ProgramCacheResizeANGLE + + ; EGL_ANGLE_query_surface_pointer + EGL_QuerySurfacePointerANGLE + + ; EGL_ANGLE_stream_producer_d3d_texture + EGL_CreateStreamProducerD3DTextureANGLE + EGL_StreamPostD3DTextureANGLE + + ; EGL_ANGLE_swap_with_frame_token + EGL_SwapBuffersWithFrameTokenANGLE + + ; EGL_ANGLE_sync_control_rate + EGL_GetMscRateANGLE + + ; EGL_ANGLE_vulkan_image + EGL_ExportVkImageANGLE + + ; EGL_CHROMIUM_sync_control + EGL_GetSyncValuesCHROMIUM + + ; EGL_EXT_device_query + EGL_QueryDeviceAttribEXT + EGL_QueryDeviceStringEXT + EGL_QueryDisplayAttribEXT + + ; EGL_EXT_image_dma_buf_import_modifiers + EGL_QueryDmaBufFormatsEXT + EGL_QueryDmaBufModifiersEXT + + ; EGL_EXT_platform_base + EGL_CreatePlatformPixmapSurfaceEXT + EGL_CreatePlatformWindowSurfaceEXT + EGL_GetPlatformDisplayEXT + + ; EGL_KHR_debug + EGL_DebugMessageControlKHR + EGL_LabelObjectKHR + EGL_QueryDebugKHR + + ; EGL_KHR_fence_sync + EGL_ClientWaitSyncKHR + EGL_CreateSyncKHR + EGL_DestroySyncKHR + EGL_GetSyncAttribKHR + + ; EGL_KHR_image + EGL_CreateImageKHR + EGL_DestroyImageKHR + + ; EGL_KHR_lock_surface3 + EGL_LockSurfaceKHR + EGL_QuerySurface64KHR + EGL_UnlockSurfaceKHR + + ; EGL_KHR_partial_update + EGL_SetDamageRegionKHR + + ; EGL_KHR_reusable_sync + EGL_SignalSyncKHR + + ; EGL_KHR_stream + EGL_CreateStreamKHR + EGL_DestroyStreamKHR + EGL_QueryStreamKHR + EGL_QueryStreamu64KHR + EGL_StreamAttribKHR + + ; EGL_KHR_stream_consumer_gltexture + EGL_StreamConsumerAcquireKHR + EGL_StreamConsumerGLTextureExternalKHR + EGL_StreamConsumerReleaseKHR + + ; EGL_KHR_swap_buffers_with_damage + EGL_SwapBuffersWithDamageKHR + + ; EGL_KHR_wait_sync + EGL_WaitSyncKHR + + ; EGL_NV_post_sub_buffer + EGL_PostSubBufferNV + + ; EGL_NV_stream_consumer_gltexture_yuv + EGL_StreamConsumerGLTextureExternalAttribsNV diff --git a/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h b/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h new file mode 100644 index 0000000000..d4960b7728 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/proc_table_egl.h @@ -0,0 +1,25 @@ +// +// Copyright 2017 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. +// +// getProcAddress loader table: +// Mapping from a string entry point name to function address. +// + +#ifndef LIBGLESV2_PROC_TABLE_H_ +#define LIBGLESV2_PROC_TABLE_H_ + +#include <EGL/egl.h> +#include <stddef.h> +#include <utility> + +namespace egl +{ +using ProcEntry = std::pair<const char *, __eglMustCastToProperFunctionPointerType>; + +extern const ProcEntry g_procTable[]; +extern const size_t g_numProcs; +} // namespace egl + +#endif // LIBGLESV2_PROC_TABLE_H_ diff --git a/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp b/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp new file mode 100644 index 0000000000..3b77295b56 --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/proc_table_egl_autogen.cpp @@ -0,0 +1,1623 @@ +// GENERATED FILE - DO NOT EDIT. +// Generated by gen_proc_table.py using data from gl.xml, gl_angle_ext.xml, egl.xml, +// egl_angle_ext.xml. +// +// Copyright 2019 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// getProcAddress loader table: +// Mapping from a string entry point name to function address. +// + +#include "libGLESv2/proc_table_egl.h" + +#include "libGLESv2/entry_points_egl_autogen.h" +#include "libGLESv2/entry_points_egl_ext_autogen.h" +#include "libGLESv2/entry_points_gles_1_0_autogen.h" +#include "libGLESv2/entry_points_gles_2_0_autogen.h" +#include "libGLESv2/entry_points_gles_3_0_autogen.h" +#include "libGLESv2/entry_points_gles_3_1_autogen.h" +#include "libGLESv2/entry_points_gles_3_2_autogen.h" +#include "libGLESv2/entry_points_gles_ext_autogen.h" +#include "platform/PlatformMethods.h" + +#if defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND) +# include "libGLESv2/entry_points_gl_1_autogen.h" +# include "libGLESv2/entry_points_gl_2_autogen.h" +# include "libGLESv2/entry_points_gl_3_autogen.h" +# include "libGLESv2/entry_points_gl_4_autogen.h" +#endif + +#include <iterator> + +#define P(FUNC) reinterpret_cast<__eglMustCastToProperFunctionPointerType>(FUNC) + +#if defined(ANGLE_ENABLE_GL_DESKTOP_FRONTEND) +# define DESKTOP_ONLY(func, angleFunc) {func, P(angleFunc)}, +#else +# define DESKTOP_ONLY(func, angleFunc) +#endif + +namespace egl +{ +// clang-format off +const ProcEntry g_procTable[] = { + {"ANGLEGetDisplayPlatform", P(ANGLEGetDisplayPlatform)}, + {"ANGLEResetDisplayPlatform", P(ANGLEResetDisplayPlatform)}, + {"eglBindAPI", P(EGL_BindAPI)}, + {"eglBindTexImage", P(EGL_BindTexImage)}, + {"eglChooseConfig", P(EGL_ChooseConfig)}, + {"eglClientWaitSync", P(EGL_ClientWaitSync)}, + {"eglClientWaitSyncKHR", P(EGL_ClientWaitSyncKHR)}, + {"eglCopyBuffers", P(EGL_CopyBuffers)}, + {"eglCopyMetalSharedEventANGLE", P(EGL_CopyMetalSharedEventANGLE)}, + {"eglCreateContext", P(EGL_CreateContext)}, + {"eglCreateDeviceANGLE", P(EGL_CreateDeviceANGLE)}, + {"eglCreateImage", P(EGL_CreateImage)}, + {"eglCreateImageKHR", P(EGL_CreateImageKHR)}, + {"eglCreateNativeClientBufferANDROID", P(EGL_CreateNativeClientBufferANDROID)}, + {"eglCreatePbufferFromClientBuffer", P(EGL_CreatePbufferFromClientBuffer)}, + {"eglCreatePbufferSurface", P(EGL_CreatePbufferSurface)}, + {"eglCreatePixmapSurface", P(EGL_CreatePixmapSurface)}, + {"eglCreatePlatformPixmapSurface", P(EGL_CreatePlatformPixmapSurface)}, + {"eglCreatePlatformPixmapSurfaceEXT", P(EGL_CreatePlatformPixmapSurfaceEXT)}, + {"eglCreatePlatformWindowSurface", P(EGL_CreatePlatformWindowSurface)}, + {"eglCreatePlatformWindowSurfaceEXT", P(EGL_CreatePlatformWindowSurfaceEXT)}, + {"eglCreateStreamKHR", P(EGL_CreateStreamKHR)}, + {"eglCreateStreamProducerD3DTextureANGLE", P(EGL_CreateStreamProducerD3DTextureANGLE)}, + {"eglCreateSync", P(EGL_CreateSync)}, + {"eglCreateSyncKHR", P(EGL_CreateSyncKHR)}, + {"eglCreateWindowSurface", P(EGL_CreateWindowSurface)}, + {"eglDebugMessageControlKHR", P(EGL_DebugMessageControlKHR)}, + {"eglDestroyContext", P(EGL_DestroyContext)}, + {"eglDestroyImage", P(EGL_DestroyImage)}, + {"eglDestroyImageKHR", P(EGL_DestroyImageKHR)}, + {"eglDestroyStreamKHR", P(EGL_DestroyStreamKHR)}, + {"eglDestroySurface", P(EGL_DestroySurface)}, + {"eglDestroySync", P(EGL_DestroySync)}, + {"eglDestroySyncKHR", P(EGL_DestroySyncKHR)}, + {"eglDupNativeFenceFDANDROID", P(EGL_DupNativeFenceFDANDROID)}, + {"eglExportVkImageANGLE", P(EGL_ExportVkImageANGLE)}, + {"eglForceGPUSwitchANGLE", P(EGL_ForceGPUSwitchANGLE)}, + {"eglGetCompositorTimingANDROID", P(EGL_GetCompositorTimingANDROID)}, + {"eglGetCompositorTimingSupportedANDROID", P(EGL_GetCompositorTimingSupportedANDROID)}, + {"eglGetConfigAttrib", P(EGL_GetConfigAttrib)}, + {"eglGetConfigs", P(EGL_GetConfigs)}, + {"eglGetCurrentContext", P(EGL_GetCurrentContext)}, + {"eglGetCurrentDisplay", P(EGL_GetCurrentDisplay)}, + {"eglGetCurrentSurface", P(EGL_GetCurrentSurface)}, + {"eglGetDisplay", P(EGL_GetDisplay)}, + {"eglGetError", P(EGL_GetError)}, + {"eglGetFrameTimestampSupportedANDROID", P(EGL_GetFrameTimestampSupportedANDROID)}, + {"eglGetFrameTimestampsANDROID", P(EGL_GetFrameTimestampsANDROID)}, + {"eglGetMscRateANGLE", P(EGL_GetMscRateANGLE)}, + {"eglGetNativeClientBufferANDROID", P(EGL_GetNativeClientBufferANDROID)}, + {"eglGetNextFrameIdANDROID", P(EGL_GetNextFrameIdANDROID)}, + {"eglGetPlatformDisplay", P(EGL_GetPlatformDisplay)}, + {"eglGetPlatformDisplayEXT", P(EGL_GetPlatformDisplayEXT)}, + {"eglGetProcAddress", P(EGL_GetProcAddress)}, + {"eglGetSyncAttrib", P(EGL_GetSyncAttrib)}, + {"eglGetSyncAttribKHR", P(EGL_GetSyncAttribKHR)}, + {"eglGetSyncValuesCHROMIUM", P(EGL_GetSyncValuesCHROMIUM)}, + {"eglHandleGPUSwitchANGLE", P(EGL_HandleGPUSwitchANGLE)}, + {"eglInitialize", P(EGL_Initialize)}, + {"eglLabelObjectKHR", P(EGL_LabelObjectKHR)}, + {"eglLockSurfaceKHR", P(EGL_LockSurfaceKHR)}, + {"eglMakeCurrent", P(EGL_MakeCurrent)}, + {"eglPostSubBufferNV", P(EGL_PostSubBufferNV)}, + {"eglPrepareSwapBuffersANGLE", P(EGL_PrepareSwapBuffersANGLE)}, + {"eglPresentationTimeANDROID", P(EGL_PresentationTimeANDROID)}, + {"eglProgramCacheGetAttribANGLE", P(EGL_ProgramCacheGetAttribANGLE)}, + {"eglProgramCachePopulateANGLE", P(EGL_ProgramCachePopulateANGLE)}, + {"eglProgramCacheQueryANGLE", P(EGL_ProgramCacheQueryANGLE)}, + {"eglProgramCacheResizeANGLE", P(EGL_ProgramCacheResizeANGLE)}, + {"eglQueryAPI", P(EGL_QueryAPI)}, + {"eglQueryContext", P(EGL_QueryContext)}, + {"eglQueryDebugKHR", P(EGL_QueryDebugKHR)}, + {"eglQueryDeviceAttribEXT", P(EGL_QueryDeviceAttribEXT)}, + {"eglQueryDeviceStringEXT", P(EGL_QueryDeviceStringEXT)}, + {"eglQueryDisplayAttribANGLE", P(EGL_QueryDisplayAttribANGLE)}, + {"eglQueryDisplayAttribEXT", P(EGL_QueryDisplayAttribEXT)}, + {"eglQueryDmaBufFormatsEXT", P(EGL_QueryDmaBufFormatsEXT)}, + {"eglQueryDmaBufModifiersEXT", P(EGL_QueryDmaBufModifiersEXT)}, + {"eglQueryStreamKHR", P(EGL_QueryStreamKHR)}, + {"eglQueryStreamu64KHR", P(EGL_QueryStreamu64KHR)}, + {"eglQueryString", P(EGL_QueryString)}, + {"eglQueryStringiANGLE", P(EGL_QueryStringiANGLE)}, + {"eglQuerySurface", P(EGL_QuerySurface)}, + {"eglQuerySurface64KHR", P(EGL_QuerySurface64KHR)}, + {"eglQuerySurfacePointerANGLE", P(EGL_QuerySurfacePointerANGLE)}, + {"eglReacquireHighPowerGPUANGLE", P(EGL_ReacquireHighPowerGPUANGLE)}, + {"eglReleaseDeviceANGLE", P(EGL_ReleaseDeviceANGLE)}, + {"eglReleaseHighPowerGPUANGLE", P(EGL_ReleaseHighPowerGPUANGLE)}, + {"eglReleaseTexImage", P(EGL_ReleaseTexImage)}, + {"eglReleaseThread", P(EGL_ReleaseThread)}, + {"eglSetBlobCacheFuncsANDROID", P(EGL_SetBlobCacheFuncsANDROID)}, + {"eglSetDamageRegionKHR", P(EGL_SetDamageRegionKHR)}, + {"eglSignalSyncKHR", P(EGL_SignalSyncKHR)}, + {"eglStreamAttribKHR", P(EGL_StreamAttribKHR)}, + {"eglStreamConsumerAcquireKHR", P(EGL_StreamConsumerAcquireKHR)}, + {"eglStreamConsumerGLTextureExternalAttribsNV", P(EGL_StreamConsumerGLTextureExternalAttribsNV)}, + {"eglStreamConsumerGLTextureExternalKHR", P(EGL_StreamConsumerGLTextureExternalKHR)}, + {"eglStreamConsumerReleaseKHR", P(EGL_StreamConsumerReleaseKHR)}, + {"eglStreamPostD3DTextureANGLE", P(EGL_StreamPostD3DTextureANGLE)}, + {"eglSurfaceAttrib", P(EGL_SurfaceAttrib)}, + {"eglSwapBuffers", P(EGL_SwapBuffers)}, + {"eglSwapBuffersWithDamageKHR", P(EGL_SwapBuffersWithDamageKHR)}, + {"eglSwapBuffersWithFrameTokenANGLE", P(EGL_SwapBuffersWithFrameTokenANGLE)}, + {"eglSwapInterval", P(EGL_SwapInterval)}, + {"eglTerminate", P(EGL_Terminate)}, + {"eglUnlockSurfaceKHR", P(EGL_UnlockSurfaceKHR)}, + {"eglWaitClient", P(EGL_WaitClient)}, + {"eglWaitGL", P(EGL_WaitGL)}, + {"eglWaitNative", P(EGL_WaitNative)}, + {"eglWaitSync", P(EGL_WaitSync)}, + {"eglWaitSyncKHR", P(EGL_WaitSyncKHR)}, + DESKTOP_ONLY("glAccum", GL_Accum) + {"glAcquireTexturesANGLE", P(GL_AcquireTexturesANGLE)}, + {"glActiveShaderProgram", P(GL_ActiveShaderProgram)}, + {"glActiveShaderProgramEXT", P(GL_ActiveShaderProgramEXT)}, + {"glActiveTexture", P(GL_ActiveTexture)}, + {"glAlphaFunc", P(GL_AlphaFunc)}, + {"glAlphaFuncx", P(GL_AlphaFuncx)}, + DESKTOP_ONLY("glAreTexturesResident", GL_AreTexturesResident) + DESKTOP_ONLY("glArrayElement", GL_ArrayElement) + {"glAttachShader", P(GL_AttachShader)}, + DESKTOP_ONLY("glBegin", GL_Begin) + DESKTOP_ONLY("glBeginConditionalRender", GL_BeginConditionalRender) + {"glBeginPerfMonitorAMD", P(GL_BeginPerfMonitorAMD)}, + {"glBeginPixelLocalStorageANGLE", P(GL_BeginPixelLocalStorageANGLE)}, + {"glBeginQuery", P(GL_BeginQuery)}, + {"glBeginQueryEXT", P(GL_BeginQueryEXT)}, + DESKTOP_ONLY("glBeginQueryIndexed", GL_BeginQueryIndexed) + {"glBeginTransformFeedback", P(GL_BeginTransformFeedback)}, + {"glBindAttribLocation", P(GL_BindAttribLocation)}, + {"glBindBuffer", P(GL_BindBuffer)}, + {"glBindBufferBase", P(GL_BindBufferBase)}, + {"glBindBufferRange", P(GL_BindBufferRange)}, + DESKTOP_ONLY("glBindBuffersBase", GL_BindBuffersBase) + DESKTOP_ONLY("glBindBuffersRange", GL_BindBuffersRange) + DESKTOP_ONLY("glBindFragDataLocation", GL_BindFragDataLocation) + {"glBindFragDataLocationEXT", P(GL_BindFragDataLocationEXT)}, + DESKTOP_ONLY("glBindFragDataLocationIndexed", GL_BindFragDataLocationIndexed) + {"glBindFragDataLocationIndexedEXT", P(GL_BindFragDataLocationIndexedEXT)}, + {"glBindFramebuffer", P(GL_BindFramebuffer)}, + {"glBindFramebufferOES", P(GL_BindFramebufferOES)}, + {"glBindImageTexture", P(GL_BindImageTexture)}, + DESKTOP_ONLY("glBindImageTextures", GL_BindImageTextures) + {"glBindProgramPipeline", P(GL_BindProgramPipeline)}, + {"glBindProgramPipelineEXT", P(GL_BindProgramPipelineEXT)}, + {"glBindRenderbuffer", P(GL_BindRenderbuffer)}, + {"glBindRenderbufferOES", P(GL_BindRenderbufferOES)}, + {"glBindSampler", P(GL_BindSampler)}, + DESKTOP_ONLY("glBindSamplers", GL_BindSamplers) + {"glBindTexture", P(GL_BindTexture)}, + DESKTOP_ONLY("glBindTextureUnit", GL_BindTextureUnit) + DESKTOP_ONLY("glBindTextures", GL_BindTextures) + {"glBindTransformFeedback", P(GL_BindTransformFeedback)}, + {"glBindUniformLocationCHROMIUM", P(GL_BindUniformLocationCHROMIUM)}, + {"glBindVertexArray", P(GL_BindVertexArray)}, + {"glBindVertexArrayOES", P(GL_BindVertexArrayOES)}, + {"glBindVertexBuffer", P(GL_BindVertexBuffer)}, + DESKTOP_ONLY("glBindVertexBuffers", GL_BindVertexBuffers) + DESKTOP_ONLY("glBitmap", GL_Bitmap) + {"glBlendBarrier", P(GL_BlendBarrier)}, + {"glBlendBarrierKHR", P(GL_BlendBarrierKHR)}, + {"glBlendColor", P(GL_BlendColor)}, + {"glBlendEquation", P(GL_BlendEquation)}, + {"glBlendEquationSeparate", P(GL_BlendEquationSeparate)}, + {"glBlendEquationSeparatei", P(GL_BlendEquationSeparatei)}, + {"glBlendEquationSeparateiEXT", P(GL_BlendEquationSeparateiEXT)}, + {"glBlendEquationSeparateiOES", P(GL_BlendEquationSeparateiOES)}, + {"glBlendEquationi", P(GL_BlendEquationi)}, + {"glBlendEquationiEXT", P(GL_BlendEquationiEXT)}, + {"glBlendEquationiOES", P(GL_BlendEquationiOES)}, + {"glBlendFunc", P(GL_BlendFunc)}, + {"glBlendFuncSeparate", P(GL_BlendFuncSeparate)}, + {"glBlendFuncSeparatei", P(GL_BlendFuncSeparatei)}, + {"glBlendFuncSeparateiEXT", P(GL_BlendFuncSeparateiEXT)}, + {"glBlendFuncSeparateiOES", P(GL_BlendFuncSeparateiOES)}, + {"glBlendFunci", P(GL_BlendFunci)}, + {"glBlendFunciEXT", P(GL_BlendFunciEXT)}, + {"glBlendFunciOES", P(GL_BlendFunciOES)}, + {"glBlitFramebuffer", P(GL_BlitFramebuffer)}, + {"glBlitFramebufferANGLE", P(GL_BlitFramebufferANGLE)}, + {"glBlitFramebufferNV", P(GL_BlitFramebufferNV)}, + DESKTOP_ONLY("glBlitNamedFramebuffer", GL_BlitNamedFramebuffer) + {"glBufferData", P(GL_BufferData)}, + DESKTOP_ONLY("glBufferStorage", GL_BufferStorage) + {"glBufferStorageEXT", P(GL_BufferStorageEXT)}, + {"glBufferStorageExternalEXT", P(GL_BufferStorageExternalEXT)}, + {"glBufferStorageMemEXT", P(GL_BufferStorageMemEXT)}, + {"glBufferSubData", P(GL_BufferSubData)}, + DESKTOP_ONLY("glCallList", GL_CallList) + DESKTOP_ONLY("glCallLists", GL_CallLists) + {"glCheckFramebufferStatus", P(GL_CheckFramebufferStatus)}, + {"glCheckFramebufferStatusOES", P(GL_CheckFramebufferStatusOES)}, + DESKTOP_ONLY("glCheckNamedFramebufferStatus", GL_CheckNamedFramebufferStatus) + DESKTOP_ONLY("glClampColor", GL_ClampColor) + {"glClear", P(GL_Clear)}, + DESKTOP_ONLY("glClearAccum", GL_ClearAccum) + DESKTOP_ONLY("glClearBufferData", GL_ClearBufferData) + DESKTOP_ONLY("glClearBufferSubData", GL_ClearBufferSubData) + {"glClearBufferfi", P(GL_ClearBufferfi)}, + {"glClearBufferfv", P(GL_ClearBufferfv)}, + {"glClearBufferiv", P(GL_ClearBufferiv)}, + {"glClearBufferuiv", P(GL_ClearBufferuiv)}, + {"glClearColor", P(GL_ClearColor)}, + {"glClearColorx", P(GL_ClearColorx)}, + DESKTOP_ONLY("glClearDepth", GL_ClearDepth) + {"glClearDepthf", P(GL_ClearDepthf)}, + {"glClearDepthx", P(GL_ClearDepthx)}, + DESKTOP_ONLY("glClearIndex", GL_ClearIndex) + DESKTOP_ONLY("glClearNamedBufferData", GL_ClearNamedBufferData) + DESKTOP_ONLY("glClearNamedBufferSubData", GL_ClearNamedBufferSubData) + DESKTOP_ONLY("glClearNamedFramebufferfi", GL_ClearNamedFramebufferfi) + DESKTOP_ONLY("glClearNamedFramebufferfv", GL_ClearNamedFramebufferfv) + DESKTOP_ONLY("glClearNamedFramebufferiv", GL_ClearNamedFramebufferiv) + DESKTOP_ONLY("glClearNamedFramebufferuiv", GL_ClearNamedFramebufferuiv) + {"glClearStencil", P(GL_ClearStencil)}, + DESKTOP_ONLY("glClearTexImage", GL_ClearTexImage) + DESKTOP_ONLY("glClearTexSubImage", GL_ClearTexSubImage) + {"glClientActiveTexture", P(GL_ClientActiveTexture)}, + {"glClientWaitSync", P(GL_ClientWaitSync)}, + DESKTOP_ONLY("glClipControl", GL_ClipControl) + {"glClipControlEXT", P(GL_ClipControlEXT)}, + DESKTOP_ONLY("glClipPlane", GL_ClipPlane) + {"glClipPlanef", P(GL_ClipPlanef)}, + {"glClipPlanex", P(GL_ClipPlanex)}, + DESKTOP_ONLY("glColor3b", GL_Color3b) + DESKTOP_ONLY("glColor3bv", GL_Color3bv) + DESKTOP_ONLY("glColor3d", GL_Color3d) + DESKTOP_ONLY("glColor3dv", GL_Color3dv) + DESKTOP_ONLY("glColor3f", GL_Color3f) + DESKTOP_ONLY("glColor3fv", GL_Color3fv) + DESKTOP_ONLY("glColor3i", GL_Color3i) + DESKTOP_ONLY("glColor3iv", GL_Color3iv) + DESKTOP_ONLY("glColor3s", GL_Color3s) + DESKTOP_ONLY("glColor3sv", GL_Color3sv) + DESKTOP_ONLY("glColor3ub", GL_Color3ub) + DESKTOP_ONLY("glColor3ubv", GL_Color3ubv) + DESKTOP_ONLY("glColor3ui", GL_Color3ui) + DESKTOP_ONLY("glColor3uiv", GL_Color3uiv) + DESKTOP_ONLY("glColor3us", GL_Color3us) + DESKTOP_ONLY("glColor3usv", GL_Color3usv) + DESKTOP_ONLY("glColor4b", GL_Color4b) + DESKTOP_ONLY("glColor4bv", GL_Color4bv) + DESKTOP_ONLY("glColor4d", GL_Color4d) + DESKTOP_ONLY("glColor4dv", GL_Color4dv) + {"glColor4f", P(GL_Color4f)}, + DESKTOP_ONLY("glColor4fv", GL_Color4fv) + DESKTOP_ONLY("glColor4i", GL_Color4i) + DESKTOP_ONLY("glColor4iv", GL_Color4iv) + DESKTOP_ONLY("glColor4s", GL_Color4s) + DESKTOP_ONLY("glColor4sv", GL_Color4sv) + {"glColor4ub", P(GL_Color4ub)}, + DESKTOP_ONLY("glColor4ubv", GL_Color4ubv) + DESKTOP_ONLY("glColor4ui", GL_Color4ui) + DESKTOP_ONLY("glColor4uiv", GL_Color4uiv) + DESKTOP_ONLY("glColor4us", GL_Color4us) + DESKTOP_ONLY("glColor4usv", GL_Color4usv) + {"glColor4x", P(GL_Color4x)}, + {"glColorMask", P(GL_ColorMask)}, + {"glColorMaski", P(GL_ColorMaski)}, + {"glColorMaskiEXT", P(GL_ColorMaskiEXT)}, + {"glColorMaskiOES", P(GL_ColorMaskiOES)}, + DESKTOP_ONLY("glColorMaterial", GL_ColorMaterial) + DESKTOP_ONLY("glColorP3ui", GL_ColorP3ui) + DESKTOP_ONLY("glColorP3uiv", GL_ColorP3uiv) + DESKTOP_ONLY("glColorP4ui", GL_ColorP4ui) + DESKTOP_ONLY("glColorP4uiv", GL_ColorP4uiv) + {"glColorPointer", P(GL_ColorPointer)}, + {"glCompileShader", P(GL_CompileShader)}, + {"glCompressedCopyTextureCHROMIUM", P(GL_CompressedCopyTextureCHROMIUM)}, + DESKTOP_ONLY("glCompressedTexImage1D", GL_CompressedTexImage1D) + {"glCompressedTexImage2D", P(GL_CompressedTexImage2D)}, + {"glCompressedTexImage2DRobustANGLE", P(GL_CompressedTexImage2DRobustANGLE)}, + {"glCompressedTexImage3D", P(GL_CompressedTexImage3D)}, + {"glCompressedTexImage3DOES", P(GL_CompressedTexImage3DOES)}, + {"glCompressedTexImage3DRobustANGLE", P(GL_CompressedTexImage3DRobustANGLE)}, + DESKTOP_ONLY("glCompressedTexSubImage1D", GL_CompressedTexSubImage1D) + {"glCompressedTexSubImage2D", P(GL_CompressedTexSubImage2D)}, + {"glCompressedTexSubImage2DRobustANGLE", P(GL_CompressedTexSubImage2DRobustANGLE)}, + {"glCompressedTexSubImage3D", P(GL_CompressedTexSubImage3D)}, + {"glCompressedTexSubImage3DOES", P(GL_CompressedTexSubImage3DOES)}, + {"glCompressedTexSubImage3DRobustANGLE", P(GL_CompressedTexSubImage3DRobustANGLE)}, + DESKTOP_ONLY("glCompressedTextureSubImage1D", GL_CompressedTextureSubImage1D) + DESKTOP_ONLY("glCompressedTextureSubImage2D", GL_CompressedTextureSubImage2D) + DESKTOP_ONLY("glCompressedTextureSubImage3D", GL_CompressedTextureSubImage3D) + {"glCopyBufferSubData", P(GL_CopyBufferSubData)}, + {"glCopyImageSubData", P(GL_CopyImageSubData)}, + {"glCopyImageSubDataEXT", P(GL_CopyImageSubDataEXT)}, + {"glCopyImageSubDataOES", P(GL_CopyImageSubDataOES)}, + DESKTOP_ONLY("glCopyNamedBufferSubData", GL_CopyNamedBufferSubData) + DESKTOP_ONLY("glCopyPixels", GL_CopyPixels) + {"glCopySubTexture3DANGLE", P(GL_CopySubTexture3DANGLE)}, + {"glCopySubTextureCHROMIUM", P(GL_CopySubTextureCHROMIUM)}, + DESKTOP_ONLY("glCopyTexImage1D", GL_CopyTexImage1D) + {"glCopyTexImage2D", P(GL_CopyTexImage2D)}, + DESKTOP_ONLY("glCopyTexSubImage1D", GL_CopyTexSubImage1D) + {"glCopyTexSubImage2D", P(GL_CopyTexSubImage2D)}, + {"glCopyTexSubImage3D", P(GL_CopyTexSubImage3D)}, + {"glCopyTexSubImage3DOES", P(GL_CopyTexSubImage3DOES)}, + {"glCopyTexture3DANGLE", P(GL_CopyTexture3DANGLE)}, + {"glCopyTextureCHROMIUM", P(GL_CopyTextureCHROMIUM)}, + DESKTOP_ONLY("glCopyTextureSubImage1D", GL_CopyTextureSubImage1D) + DESKTOP_ONLY("glCopyTextureSubImage2D", GL_CopyTextureSubImage2D) + DESKTOP_ONLY("glCopyTextureSubImage3D", GL_CopyTextureSubImage3D) + {"glCoverageModulationCHROMIUM", P(GL_CoverageModulationCHROMIUM)}, + DESKTOP_ONLY("glCreateBuffers", GL_CreateBuffers) + DESKTOP_ONLY("glCreateFramebuffers", GL_CreateFramebuffers) + {"glCreateMemoryObjectsEXT", P(GL_CreateMemoryObjectsEXT)}, + {"glCreateProgram", P(GL_CreateProgram)}, + DESKTOP_ONLY("glCreateProgramPipelines", GL_CreateProgramPipelines) + DESKTOP_ONLY("glCreateQueries", GL_CreateQueries) + DESKTOP_ONLY("glCreateRenderbuffers", GL_CreateRenderbuffers) + DESKTOP_ONLY("glCreateSamplers", GL_CreateSamplers) + {"glCreateShader", P(GL_CreateShader)}, + {"glCreateShaderProgramv", P(GL_CreateShaderProgramv)}, + {"glCreateShaderProgramvEXT", P(GL_CreateShaderProgramvEXT)}, + DESKTOP_ONLY("glCreateTextures", GL_CreateTextures) + DESKTOP_ONLY("glCreateTransformFeedbacks", GL_CreateTransformFeedbacks) + DESKTOP_ONLY("glCreateVertexArrays", GL_CreateVertexArrays) + {"glCullFace", P(GL_CullFace)}, + {"glCurrentPaletteMatrixOES", P(GL_CurrentPaletteMatrixOES)}, + {"glDebugMessageCallback", P(GL_DebugMessageCallback)}, + {"glDebugMessageCallbackKHR", P(GL_DebugMessageCallbackKHR)}, + {"glDebugMessageControl", P(GL_DebugMessageControl)}, + {"glDebugMessageControlKHR", P(GL_DebugMessageControlKHR)}, + {"glDebugMessageInsert", P(GL_DebugMessageInsert)}, + {"glDebugMessageInsertKHR", P(GL_DebugMessageInsertKHR)}, + {"glDeleteBuffers", P(GL_DeleteBuffers)}, + {"glDeleteFencesNV", P(GL_DeleteFencesNV)}, + {"glDeleteFramebuffers", P(GL_DeleteFramebuffers)}, + {"glDeleteFramebuffersOES", P(GL_DeleteFramebuffersOES)}, + DESKTOP_ONLY("glDeleteLists", GL_DeleteLists) + {"glDeleteMemoryObjectsEXT", P(GL_DeleteMemoryObjectsEXT)}, + {"glDeletePerfMonitorsAMD", P(GL_DeletePerfMonitorsAMD)}, + {"glDeleteProgram", P(GL_DeleteProgram)}, + {"glDeleteProgramPipelines", P(GL_DeleteProgramPipelines)}, + {"glDeleteProgramPipelinesEXT", P(GL_DeleteProgramPipelinesEXT)}, + {"glDeleteQueries", P(GL_DeleteQueries)}, + {"glDeleteQueriesEXT", P(GL_DeleteQueriesEXT)}, + {"glDeleteRenderbuffers", P(GL_DeleteRenderbuffers)}, + {"glDeleteRenderbuffersOES", P(GL_DeleteRenderbuffersOES)}, + {"glDeleteSamplers", P(GL_DeleteSamplers)}, + {"glDeleteSemaphoresEXT", P(GL_DeleteSemaphoresEXT)}, + {"glDeleteShader", P(GL_DeleteShader)}, + {"glDeleteSync", P(GL_DeleteSync)}, + {"glDeleteTextures", P(GL_DeleteTextures)}, + {"glDeleteTransformFeedbacks", P(GL_DeleteTransformFeedbacks)}, + {"glDeleteVertexArrays", P(GL_DeleteVertexArrays)}, + {"glDeleteVertexArraysOES", P(GL_DeleteVertexArraysOES)}, + {"glDepthFunc", P(GL_DepthFunc)}, + {"glDepthMask", P(GL_DepthMask)}, + DESKTOP_ONLY("glDepthRange", GL_DepthRange) + DESKTOP_ONLY("glDepthRangeArrayv", GL_DepthRangeArrayv) + DESKTOP_ONLY("glDepthRangeIndexed", GL_DepthRangeIndexed) + {"glDepthRangef", P(GL_DepthRangef)}, + {"glDepthRangex", P(GL_DepthRangex)}, + {"glDetachShader", P(GL_DetachShader)}, + {"glDisable", P(GL_Disable)}, + {"glDisableClientState", P(GL_DisableClientState)}, + {"glDisableExtensionANGLE", P(GL_DisableExtensionANGLE)}, + DESKTOP_ONLY("glDisableVertexArrayAttrib", GL_DisableVertexArrayAttrib) + {"glDisableVertexAttribArray", P(GL_DisableVertexAttribArray)}, + {"glDisablei", P(GL_Disablei)}, + {"glDisableiEXT", P(GL_DisableiEXT)}, + {"glDisableiOES", P(GL_DisableiOES)}, + {"glDiscardFramebufferEXT", P(GL_DiscardFramebufferEXT)}, + {"glDispatchCompute", P(GL_DispatchCompute)}, + {"glDispatchComputeIndirect", P(GL_DispatchComputeIndirect)}, + {"glDrawArrays", P(GL_DrawArrays)}, + {"glDrawArraysIndirect", P(GL_DrawArraysIndirect)}, + {"glDrawArraysInstanced", P(GL_DrawArraysInstanced)}, + {"glDrawArraysInstancedANGLE", P(GL_DrawArraysInstancedANGLE)}, + DESKTOP_ONLY("glDrawArraysInstancedBaseInstance", GL_DrawArraysInstancedBaseInstance) + {"glDrawArraysInstancedBaseInstanceANGLE", P(GL_DrawArraysInstancedBaseInstanceANGLE)}, + {"glDrawArraysInstancedBaseInstanceEXT", P(GL_DrawArraysInstancedBaseInstanceEXT)}, + {"glDrawArraysInstancedEXT", P(GL_DrawArraysInstancedEXT)}, + DESKTOP_ONLY("glDrawBuffer", GL_DrawBuffer) + {"glDrawBuffers", P(GL_DrawBuffers)}, + {"glDrawBuffersEXT", P(GL_DrawBuffersEXT)}, + {"glDrawElements", P(GL_DrawElements)}, + {"glDrawElementsBaseVertex", P(GL_DrawElementsBaseVertex)}, + {"glDrawElementsBaseVertexEXT", P(GL_DrawElementsBaseVertexEXT)}, + {"glDrawElementsBaseVertexOES", P(GL_DrawElementsBaseVertexOES)}, + {"glDrawElementsIndirect", P(GL_DrawElementsIndirect)}, + {"glDrawElementsInstanced", P(GL_DrawElementsInstanced)}, + {"glDrawElementsInstancedANGLE", P(GL_DrawElementsInstancedANGLE)}, + DESKTOP_ONLY("glDrawElementsInstancedBaseInstance", GL_DrawElementsInstancedBaseInstance) + {"glDrawElementsInstancedBaseInstanceEXT", P(GL_DrawElementsInstancedBaseInstanceEXT)}, + {"glDrawElementsInstancedBaseVertex", P(GL_DrawElementsInstancedBaseVertex)}, + DESKTOP_ONLY("glDrawElementsInstancedBaseVertexBaseInstance", GL_DrawElementsInstancedBaseVertexBaseInstance) + {"glDrawElementsInstancedBaseVertexBaseInstanceANGLE", P(GL_DrawElementsInstancedBaseVertexBaseInstanceANGLE)}, + {"glDrawElementsInstancedBaseVertexBaseInstanceEXT", P(GL_DrawElementsInstancedBaseVertexBaseInstanceEXT)}, + {"glDrawElementsInstancedBaseVertexEXT", P(GL_DrawElementsInstancedBaseVertexEXT)}, + {"glDrawElementsInstancedBaseVertexOES", P(GL_DrawElementsInstancedBaseVertexOES)}, + {"glDrawElementsInstancedEXT", P(GL_DrawElementsInstancedEXT)}, + DESKTOP_ONLY("glDrawPixels", GL_DrawPixels) + {"glDrawRangeElements", P(GL_DrawRangeElements)}, + {"glDrawRangeElementsBaseVertex", P(GL_DrawRangeElementsBaseVertex)}, + {"glDrawRangeElementsBaseVertexEXT", P(GL_DrawRangeElementsBaseVertexEXT)}, + {"glDrawRangeElementsBaseVertexOES", P(GL_DrawRangeElementsBaseVertexOES)}, + {"glDrawTexfOES", P(GL_DrawTexfOES)}, + {"glDrawTexfvOES", P(GL_DrawTexfvOES)}, + {"glDrawTexiOES", P(GL_DrawTexiOES)}, + {"glDrawTexivOES", P(GL_DrawTexivOES)}, + {"glDrawTexsOES", P(GL_DrawTexsOES)}, + {"glDrawTexsvOES", P(GL_DrawTexsvOES)}, + {"glDrawTexxOES", P(GL_DrawTexxOES)}, + {"glDrawTexxvOES", P(GL_DrawTexxvOES)}, + DESKTOP_ONLY("glDrawTransformFeedback", GL_DrawTransformFeedback) + DESKTOP_ONLY("glDrawTransformFeedbackInstanced", GL_DrawTransformFeedbackInstanced) + DESKTOP_ONLY("glDrawTransformFeedbackStream", GL_DrawTransformFeedbackStream) + DESKTOP_ONLY("glDrawTransformFeedbackStreamInstanced", GL_DrawTransformFeedbackStreamInstanced) + {"glEGLImageTargetRenderbufferStorageOES", P(GL_EGLImageTargetRenderbufferStorageOES)}, + {"glEGLImageTargetTexStorageEXT", P(GL_EGLImageTargetTexStorageEXT)}, + {"glEGLImageTargetTexture2DOES", P(GL_EGLImageTargetTexture2DOES)}, + {"glEGLImageTargetTextureStorageEXT", P(GL_EGLImageTargetTextureStorageEXT)}, + DESKTOP_ONLY("glEdgeFlag", GL_EdgeFlag) + DESKTOP_ONLY("glEdgeFlagPointer", GL_EdgeFlagPointer) + DESKTOP_ONLY("glEdgeFlagv", GL_EdgeFlagv) + {"glEnable", P(GL_Enable)}, + {"glEnableClientState", P(GL_EnableClientState)}, + DESKTOP_ONLY("glEnableVertexArrayAttrib", GL_EnableVertexArrayAttrib) + {"glEnableVertexAttribArray", P(GL_EnableVertexAttribArray)}, + {"glEnablei", P(GL_Enablei)}, + {"glEnableiEXT", P(GL_EnableiEXT)}, + {"glEnableiOES", P(GL_EnableiOES)}, + DESKTOP_ONLY("glEnd", GL_End) + DESKTOP_ONLY("glEndConditionalRender", GL_EndConditionalRender) + DESKTOP_ONLY("glEndList", GL_EndList) + {"glEndPerfMonitorAMD", P(GL_EndPerfMonitorAMD)}, + {"glEndPixelLocalStorageANGLE", P(GL_EndPixelLocalStorageANGLE)}, + {"glEndQuery", P(GL_EndQuery)}, + {"glEndQueryEXT", P(GL_EndQueryEXT)}, + DESKTOP_ONLY("glEndQueryIndexed", GL_EndQueryIndexed) + {"glEndTransformFeedback", P(GL_EndTransformFeedback)}, + DESKTOP_ONLY("glEvalCoord1d", GL_EvalCoord1d) + DESKTOP_ONLY("glEvalCoord1dv", GL_EvalCoord1dv) + DESKTOP_ONLY("glEvalCoord1f", GL_EvalCoord1f) + DESKTOP_ONLY("glEvalCoord1fv", GL_EvalCoord1fv) + DESKTOP_ONLY("glEvalCoord2d", GL_EvalCoord2d) + DESKTOP_ONLY("glEvalCoord2dv", GL_EvalCoord2dv) + DESKTOP_ONLY("glEvalCoord2f", GL_EvalCoord2f) + DESKTOP_ONLY("glEvalCoord2fv", GL_EvalCoord2fv) + DESKTOP_ONLY("glEvalMesh1", GL_EvalMesh1) + DESKTOP_ONLY("glEvalMesh2", GL_EvalMesh2) + DESKTOP_ONLY("glEvalPoint1", GL_EvalPoint1) + DESKTOP_ONLY("glEvalPoint2", GL_EvalPoint2) + DESKTOP_ONLY("glFeedbackBuffer", GL_FeedbackBuffer) + {"glFenceSync", P(GL_FenceSync)}, + {"glFinish", P(GL_Finish)}, + {"glFinishFenceNV", P(GL_FinishFenceNV)}, + {"glFlush", P(GL_Flush)}, + {"glFlushMappedBufferRange", P(GL_FlushMappedBufferRange)}, + {"glFlushMappedBufferRangeEXT", P(GL_FlushMappedBufferRangeEXT)}, + DESKTOP_ONLY("glFlushMappedNamedBufferRange", GL_FlushMappedNamedBufferRange) + DESKTOP_ONLY("glFogCoordPointer", GL_FogCoordPointer) + DESKTOP_ONLY("glFogCoordd", GL_FogCoordd) + DESKTOP_ONLY("glFogCoorddv", GL_FogCoorddv) + DESKTOP_ONLY("glFogCoordf", GL_FogCoordf) + DESKTOP_ONLY("glFogCoordfv", GL_FogCoordfv) + {"glFogf", P(GL_Fogf)}, + {"glFogfv", P(GL_Fogfv)}, + DESKTOP_ONLY("glFogi", GL_Fogi) + DESKTOP_ONLY("glFogiv", GL_Fogiv) + {"glFogx", P(GL_Fogx)}, + {"glFogxv", P(GL_Fogxv)}, + {"glFramebufferFetchBarrierEXT", P(GL_FramebufferFetchBarrierEXT)}, + {"glFramebufferMemorylessPixelLocalStorageANGLE", P(GL_FramebufferMemorylessPixelLocalStorageANGLE)}, + {"glFramebufferParameteri", P(GL_FramebufferParameteri)}, + {"glFramebufferParameteriMESA", P(GL_FramebufferParameteriMESA)}, + {"glFramebufferRenderbuffer", P(GL_FramebufferRenderbuffer)}, + {"glFramebufferRenderbufferOES", P(GL_FramebufferRenderbufferOES)}, + {"glFramebufferTexture", P(GL_FramebufferTexture)}, + DESKTOP_ONLY("glFramebufferTexture1D", GL_FramebufferTexture1D) + {"glFramebufferTexture2D", P(GL_FramebufferTexture2D)}, + {"glFramebufferTexture2DMultisampleEXT", P(GL_FramebufferTexture2DMultisampleEXT)}, + {"glFramebufferTexture2DOES", P(GL_FramebufferTexture2DOES)}, + DESKTOP_ONLY("glFramebufferTexture3D", GL_FramebufferTexture3D) + {"glFramebufferTexture3DOES", P(GL_FramebufferTexture3DOES)}, + {"glFramebufferTextureEXT", P(GL_FramebufferTextureEXT)}, + {"glFramebufferTextureLayer", P(GL_FramebufferTextureLayer)}, + {"glFramebufferTextureMultiviewOVR", P(GL_FramebufferTextureMultiviewOVR)}, + {"glFramebufferTextureOES", P(GL_FramebufferTextureOES)}, + {"glFramebufferTexturePixelLocalStorageANGLE", P(GL_FramebufferTexturePixelLocalStorageANGLE)}, + {"glFrontFace", P(GL_FrontFace)}, + DESKTOP_ONLY("glFrustum", GL_Frustum) + {"glFrustumf", P(GL_Frustumf)}, + {"glFrustumx", P(GL_Frustumx)}, + {"glGenBuffers", P(GL_GenBuffers)}, + {"glGenFencesNV", P(GL_GenFencesNV)}, + {"glGenFramebuffers", P(GL_GenFramebuffers)}, + {"glGenFramebuffersOES", P(GL_GenFramebuffersOES)}, + DESKTOP_ONLY("glGenLists", GL_GenLists) + {"glGenPerfMonitorsAMD", P(GL_GenPerfMonitorsAMD)}, + {"glGenProgramPipelines", P(GL_GenProgramPipelines)}, + {"glGenProgramPipelinesEXT", P(GL_GenProgramPipelinesEXT)}, + {"glGenQueries", P(GL_GenQueries)}, + {"glGenQueriesEXT", P(GL_GenQueriesEXT)}, + {"glGenRenderbuffers", P(GL_GenRenderbuffers)}, + {"glGenRenderbuffersOES", P(GL_GenRenderbuffersOES)}, + {"glGenSamplers", P(GL_GenSamplers)}, + {"glGenSemaphoresEXT", P(GL_GenSemaphoresEXT)}, + {"glGenTextures", P(GL_GenTextures)}, + {"glGenTransformFeedbacks", P(GL_GenTransformFeedbacks)}, + {"glGenVertexArrays", P(GL_GenVertexArrays)}, + {"glGenVertexArraysOES", P(GL_GenVertexArraysOES)}, + {"glGenerateMipmap", P(GL_GenerateMipmap)}, + {"glGenerateMipmapOES", P(GL_GenerateMipmapOES)}, + DESKTOP_ONLY("glGenerateTextureMipmap", GL_GenerateTextureMipmap) + DESKTOP_ONLY("glGetActiveAtomicCounterBufferiv", GL_GetActiveAtomicCounterBufferiv) + {"glGetActiveAttrib", P(GL_GetActiveAttrib)}, + DESKTOP_ONLY("glGetActiveSubroutineName", GL_GetActiveSubroutineName) + DESKTOP_ONLY("glGetActiveSubroutineUniformName", GL_GetActiveSubroutineUniformName) + DESKTOP_ONLY("glGetActiveSubroutineUniformiv", GL_GetActiveSubroutineUniformiv) + {"glGetActiveUniform", P(GL_GetActiveUniform)}, + {"glGetActiveUniformBlockName", P(GL_GetActiveUniformBlockName)}, + {"glGetActiveUniformBlockiv", P(GL_GetActiveUniformBlockiv)}, + {"glGetActiveUniformBlockivRobustANGLE", P(GL_GetActiveUniformBlockivRobustANGLE)}, + DESKTOP_ONLY("glGetActiveUniformName", GL_GetActiveUniformName) + {"glGetActiveUniformsiv", P(GL_GetActiveUniformsiv)}, + {"glGetAttachedShaders", P(GL_GetAttachedShaders)}, + {"glGetAttribLocation", P(GL_GetAttribLocation)}, + {"glGetBooleani_v", P(GL_GetBooleani_v)}, + {"glGetBooleani_vRobustANGLE", P(GL_GetBooleani_vRobustANGLE)}, + {"glGetBooleanv", P(GL_GetBooleanv)}, + {"glGetBooleanvRobustANGLE", P(GL_GetBooleanvRobustANGLE)}, + {"glGetBufferParameteri64v", P(GL_GetBufferParameteri64v)}, + {"glGetBufferParameteri64vRobustANGLE", P(GL_GetBufferParameteri64vRobustANGLE)}, + {"glGetBufferParameteriv", P(GL_GetBufferParameteriv)}, + {"glGetBufferParameterivRobustANGLE", P(GL_GetBufferParameterivRobustANGLE)}, + {"glGetBufferPointerv", P(GL_GetBufferPointerv)}, + {"glGetBufferPointervOES", P(GL_GetBufferPointervOES)}, + {"glGetBufferPointervRobustANGLE", P(GL_GetBufferPointervRobustANGLE)}, + DESKTOP_ONLY("glGetBufferSubData", GL_GetBufferSubData) + DESKTOP_ONLY("glGetClipPlane", GL_GetClipPlane) + {"glGetClipPlanef", P(GL_GetClipPlanef)}, + {"glGetClipPlanex", P(GL_GetClipPlanex)}, + DESKTOP_ONLY("glGetCompressedTexImage", GL_GetCompressedTexImage) + {"glGetCompressedTexImageANGLE", P(GL_GetCompressedTexImageANGLE)}, + DESKTOP_ONLY("glGetCompressedTextureImage", GL_GetCompressedTextureImage) + DESKTOP_ONLY("glGetCompressedTextureSubImage", GL_GetCompressedTextureSubImage) + {"glGetDebugMessageLog", P(GL_GetDebugMessageLog)}, + {"glGetDebugMessageLogKHR", P(GL_GetDebugMessageLogKHR)}, + DESKTOP_ONLY("glGetDoublei_v", GL_GetDoublei_v) + DESKTOP_ONLY("glGetDoublev", GL_GetDoublev) + {"glGetError", P(GL_GetError)}, + {"glGetFenceivNV", P(GL_GetFenceivNV)}, + {"glGetFixedv", P(GL_GetFixedv)}, + DESKTOP_ONLY("glGetFloati_v", GL_GetFloati_v) + {"glGetFloatv", P(GL_GetFloatv)}, + {"glGetFloatvRobustANGLE", P(GL_GetFloatvRobustANGLE)}, + DESKTOP_ONLY("glGetFragDataIndex", GL_GetFragDataIndex) + {"glGetFragDataIndexEXT", P(GL_GetFragDataIndexEXT)}, + {"glGetFragDataLocation", P(GL_GetFragDataLocation)}, + {"glGetFramebufferAttachmentParameteriv", P(GL_GetFramebufferAttachmentParameteriv)}, + {"glGetFramebufferAttachmentParameterivOES", P(GL_GetFramebufferAttachmentParameterivOES)}, + {"glGetFramebufferAttachmentParameterivRobustANGLE", P(GL_GetFramebufferAttachmentParameterivRobustANGLE)}, + {"glGetFramebufferParameteriv", P(GL_GetFramebufferParameteriv)}, + {"glGetFramebufferParameterivMESA", P(GL_GetFramebufferParameterivMESA)}, + {"glGetFramebufferParameterivRobustANGLE", P(GL_GetFramebufferParameterivRobustANGLE)}, + {"glGetGraphicsResetStatus", P(GL_GetGraphicsResetStatus)}, + {"glGetGraphicsResetStatusEXT", P(GL_GetGraphicsResetStatusEXT)}, + {"glGetInteger64i_v", P(GL_GetInteger64i_v)}, + {"glGetInteger64i_vRobustANGLE", P(GL_GetInteger64i_vRobustANGLE)}, + {"glGetInteger64v", P(GL_GetInteger64v)}, + {"glGetInteger64vEXT", P(GL_GetInteger64vEXT)}, + {"glGetInteger64vRobustANGLE", P(GL_GetInteger64vRobustANGLE)}, + {"glGetIntegeri_v", P(GL_GetIntegeri_v)}, + {"glGetIntegeri_vRobustANGLE", P(GL_GetIntegeri_vRobustANGLE)}, + {"glGetIntegerv", P(GL_GetIntegerv)}, + {"glGetIntegervRobustANGLE", P(GL_GetIntegervRobustANGLE)}, + DESKTOP_ONLY("glGetInternalformati64v", GL_GetInternalformati64v) + {"glGetInternalformativ", P(GL_GetInternalformativ)}, + {"glGetInternalformativRobustANGLE", P(GL_GetInternalformativRobustANGLE)}, + {"glGetLightfv", P(GL_GetLightfv)}, + DESKTOP_ONLY("glGetLightiv", GL_GetLightiv) + {"glGetLightxv", P(GL_GetLightxv)}, + DESKTOP_ONLY("glGetMapdv", GL_GetMapdv) + DESKTOP_ONLY("glGetMapfv", GL_GetMapfv) + DESKTOP_ONLY("glGetMapiv", GL_GetMapiv) + {"glGetMaterialfv", P(GL_GetMaterialfv)}, + DESKTOP_ONLY("glGetMaterialiv", GL_GetMaterialiv) + {"glGetMaterialxv", P(GL_GetMaterialxv)}, + {"glGetMemoryObjectParameterivEXT", P(GL_GetMemoryObjectParameterivEXT)}, + {"glGetMultisamplefv", P(GL_GetMultisamplefv)}, + {"glGetMultisamplefvANGLE", P(GL_GetMultisamplefvANGLE)}, + {"glGetMultisamplefvRobustANGLE", P(GL_GetMultisamplefvRobustANGLE)}, + DESKTOP_ONLY("glGetNamedBufferParameteri64v", GL_GetNamedBufferParameteri64v) + DESKTOP_ONLY("glGetNamedBufferParameteriv", GL_GetNamedBufferParameteriv) + DESKTOP_ONLY("glGetNamedBufferPointerv", GL_GetNamedBufferPointerv) + DESKTOP_ONLY("glGetNamedBufferSubData", GL_GetNamedBufferSubData) + DESKTOP_ONLY("glGetNamedFramebufferAttachmentParameteriv", GL_GetNamedFramebufferAttachmentParameteriv) + DESKTOP_ONLY("glGetNamedFramebufferParameteriv", GL_GetNamedFramebufferParameteriv) + DESKTOP_ONLY("glGetNamedRenderbufferParameteriv", GL_GetNamedRenderbufferParameteriv) + {"glGetObjectLabel", P(GL_GetObjectLabel)}, + {"glGetObjectLabelEXT", P(GL_GetObjectLabelEXT)}, + {"glGetObjectLabelKHR", P(GL_GetObjectLabelKHR)}, + {"glGetObjectPtrLabel", P(GL_GetObjectPtrLabel)}, + {"glGetObjectPtrLabelKHR", P(GL_GetObjectPtrLabelKHR)}, + {"glGetPerfMonitorCounterDataAMD", P(GL_GetPerfMonitorCounterDataAMD)}, + {"glGetPerfMonitorCounterInfoAMD", P(GL_GetPerfMonitorCounterInfoAMD)}, + {"glGetPerfMonitorCounterStringAMD", P(GL_GetPerfMonitorCounterStringAMD)}, + {"glGetPerfMonitorCountersAMD", P(GL_GetPerfMonitorCountersAMD)}, + {"glGetPerfMonitorGroupStringAMD", P(GL_GetPerfMonitorGroupStringAMD)}, + {"glGetPerfMonitorGroupsAMD", P(GL_GetPerfMonitorGroupsAMD)}, + DESKTOP_ONLY("glGetPixelMapfv", GL_GetPixelMapfv) + DESKTOP_ONLY("glGetPixelMapuiv", GL_GetPixelMapuiv) + DESKTOP_ONLY("glGetPixelMapusv", GL_GetPixelMapusv) + {"glGetPointerv", P(GL_GetPointerv)}, + {"glGetPointervKHR", P(GL_GetPointervKHR)}, + {"glGetPointervRobustANGLERobustANGLE", P(GL_GetPointervRobustANGLERobustANGLE)}, + DESKTOP_ONLY("glGetPolygonStipple", GL_GetPolygonStipple) + {"glGetProgramBinary", P(GL_GetProgramBinary)}, + {"glGetProgramBinaryOES", P(GL_GetProgramBinaryOES)}, + {"glGetProgramInfoLog", P(GL_GetProgramInfoLog)}, + {"glGetProgramInterfaceiv", P(GL_GetProgramInterfaceiv)}, + {"glGetProgramInterfaceivRobustANGLE", P(GL_GetProgramInterfaceivRobustANGLE)}, + {"glGetProgramPipelineInfoLog", P(GL_GetProgramPipelineInfoLog)}, + {"glGetProgramPipelineInfoLogEXT", P(GL_GetProgramPipelineInfoLogEXT)}, + {"glGetProgramPipelineiv", P(GL_GetProgramPipelineiv)}, + {"glGetProgramPipelineivEXT", P(GL_GetProgramPipelineivEXT)}, + {"glGetProgramResourceIndex", P(GL_GetProgramResourceIndex)}, + {"glGetProgramResourceLocation", P(GL_GetProgramResourceLocation)}, + DESKTOP_ONLY("glGetProgramResourceLocationIndex", GL_GetProgramResourceLocationIndex) + {"glGetProgramResourceLocationIndexEXT", P(GL_GetProgramResourceLocationIndexEXT)}, + {"glGetProgramResourceName", P(GL_GetProgramResourceName)}, + {"glGetProgramResourceiv", P(GL_GetProgramResourceiv)}, + DESKTOP_ONLY("glGetProgramStageiv", GL_GetProgramStageiv) + {"glGetProgramiv", P(GL_GetProgramiv)}, + {"glGetProgramivRobustANGLE", P(GL_GetProgramivRobustANGLE)}, + DESKTOP_ONLY("glGetQueryBufferObjecti64v", GL_GetQueryBufferObjecti64v) + DESKTOP_ONLY("glGetQueryBufferObjectiv", GL_GetQueryBufferObjectiv) + DESKTOP_ONLY("glGetQueryBufferObjectui64v", GL_GetQueryBufferObjectui64v) + DESKTOP_ONLY("glGetQueryBufferObjectuiv", GL_GetQueryBufferObjectuiv) + DESKTOP_ONLY("glGetQueryIndexediv", GL_GetQueryIndexediv) + DESKTOP_ONLY("glGetQueryObjecti64v", GL_GetQueryObjecti64v) + {"glGetQueryObjecti64vEXT", P(GL_GetQueryObjecti64vEXT)}, + {"glGetQueryObjecti64vRobustANGLE", P(GL_GetQueryObjecti64vRobustANGLE)}, + DESKTOP_ONLY("glGetQueryObjectiv", GL_GetQueryObjectiv) + {"glGetQueryObjectivEXT", P(GL_GetQueryObjectivEXT)}, + {"glGetQueryObjectivRobustANGLE", P(GL_GetQueryObjectivRobustANGLE)}, + DESKTOP_ONLY("glGetQueryObjectui64v", GL_GetQueryObjectui64v) + {"glGetQueryObjectui64vEXT", P(GL_GetQueryObjectui64vEXT)}, + {"glGetQueryObjectui64vRobustANGLE", P(GL_GetQueryObjectui64vRobustANGLE)}, + {"glGetQueryObjectuiv", P(GL_GetQueryObjectuiv)}, + {"glGetQueryObjectuivEXT", P(GL_GetQueryObjectuivEXT)}, + {"glGetQueryObjectuivRobustANGLE", P(GL_GetQueryObjectuivRobustANGLE)}, + {"glGetQueryiv", P(GL_GetQueryiv)}, + {"glGetQueryivEXT", P(GL_GetQueryivEXT)}, + {"glGetQueryivRobustANGLE", P(GL_GetQueryivRobustANGLE)}, + {"glGetRenderbufferImageANGLE", P(GL_GetRenderbufferImageANGLE)}, + {"glGetRenderbufferParameteriv", P(GL_GetRenderbufferParameteriv)}, + {"glGetRenderbufferParameterivOES", P(GL_GetRenderbufferParameterivOES)}, + {"glGetRenderbufferParameterivRobustANGLE", P(GL_GetRenderbufferParameterivRobustANGLE)}, + {"glGetSamplerParameterIiv", P(GL_GetSamplerParameterIiv)}, + {"glGetSamplerParameterIivEXT", P(GL_GetSamplerParameterIivEXT)}, + {"glGetSamplerParameterIivOES", P(GL_GetSamplerParameterIivOES)}, + {"glGetSamplerParameterIivRobustANGLE", P(GL_GetSamplerParameterIivRobustANGLE)}, + {"glGetSamplerParameterIuiv", P(GL_GetSamplerParameterIuiv)}, + {"glGetSamplerParameterIuivEXT", P(GL_GetSamplerParameterIuivEXT)}, + {"glGetSamplerParameterIuivOES", P(GL_GetSamplerParameterIuivOES)}, + {"glGetSamplerParameterIuivRobustANGLE", P(GL_GetSamplerParameterIuivRobustANGLE)}, + {"glGetSamplerParameterfv", P(GL_GetSamplerParameterfv)}, + {"glGetSamplerParameterfvRobustANGLE", P(GL_GetSamplerParameterfvRobustANGLE)}, + {"glGetSamplerParameteriv", P(GL_GetSamplerParameteriv)}, + {"glGetSamplerParameterivRobustANGLE", P(GL_GetSamplerParameterivRobustANGLE)}, + {"glGetSemaphoreParameterui64vEXT", P(GL_GetSemaphoreParameterui64vEXT)}, + {"glGetShaderInfoLog", P(GL_GetShaderInfoLog)}, + {"glGetShaderPrecisionFormat", P(GL_GetShaderPrecisionFormat)}, + {"glGetShaderSource", P(GL_GetShaderSource)}, + {"glGetShaderiv", P(GL_GetShaderiv)}, + {"glGetShaderivRobustANGLE", P(GL_GetShaderivRobustANGLE)}, + {"glGetString", P(GL_GetString)}, + {"glGetStringi", P(GL_GetStringi)}, + DESKTOP_ONLY("glGetSubroutineIndex", GL_GetSubroutineIndex) + DESKTOP_ONLY("glGetSubroutineUniformLocation", GL_GetSubroutineUniformLocation) + {"glGetSynciv", P(GL_GetSynciv)}, + {"glGetTexEnvfv", P(GL_GetTexEnvfv)}, + {"glGetTexEnviv", P(GL_GetTexEnviv)}, + {"glGetTexEnvxv", P(GL_GetTexEnvxv)}, + DESKTOP_ONLY("glGetTexGendv", GL_GetTexGendv) + DESKTOP_ONLY("glGetTexGenfv", GL_GetTexGenfv) + {"glGetTexGenfvOES", P(GL_GetTexGenfvOES)}, + DESKTOP_ONLY("glGetTexGeniv", GL_GetTexGeniv) + {"glGetTexGenivOES", P(GL_GetTexGenivOES)}, + {"glGetTexGenxvOES", P(GL_GetTexGenxvOES)}, + DESKTOP_ONLY("glGetTexImage", GL_GetTexImage) + {"glGetTexImageANGLE", P(GL_GetTexImageANGLE)}, + {"glGetTexLevelParameterfv", P(GL_GetTexLevelParameterfv)}, + {"glGetTexLevelParameterfvANGLE", P(GL_GetTexLevelParameterfvANGLE)}, + {"glGetTexLevelParameterfvRobustANGLE", P(GL_GetTexLevelParameterfvRobustANGLE)}, + {"glGetTexLevelParameteriv", P(GL_GetTexLevelParameteriv)}, + {"glGetTexLevelParameterivANGLE", P(GL_GetTexLevelParameterivANGLE)}, + {"glGetTexLevelParameterivRobustANGLE", P(GL_GetTexLevelParameterivRobustANGLE)}, + {"glGetTexParameterIiv", P(GL_GetTexParameterIiv)}, + {"glGetTexParameterIivEXT", P(GL_GetTexParameterIivEXT)}, + {"glGetTexParameterIivOES", P(GL_GetTexParameterIivOES)}, + {"glGetTexParameterIivRobustANGLE", P(GL_GetTexParameterIivRobustANGLE)}, + {"glGetTexParameterIuiv", P(GL_GetTexParameterIuiv)}, + {"glGetTexParameterIuivEXT", P(GL_GetTexParameterIuivEXT)}, + {"glGetTexParameterIuivOES", P(GL_GetTexParameterIuivOES)}, + {"glGetTexParameterIuivRobustANGLE", P(GL_GetTexParameterIuivRobustANGLE)}, + {"glGetTexParameterfv", P(GL_GetTexParameterfv)}, + {"glGetTexParameterfvRobustANGLE", P(GL_GetTexParameterfvRobustANGLE)}, + {"glGetTexParameteriv", P(GL_GetTexParameteriv)}, + {"glGetTexParameterivRobustANGLE", P(GL_GetTexParameterivRobustANGLE)}, + {"glGetTexParameterxv", P(GL_GetTexParameterxv)}, + DESKTOP_ONLY("glGetTextureImage", GL_GetTextureImage) + DESKTOP_ONLY("glGetTextureLevelParameterfv", GL_GetTextureLevelParameterfv) + DESKTOP_ONLY("glGetTextureLevelParameteriv", GL_GetTextureLevelParameteriv) + DESKTOP_ONLY("glGetTextureParameterIiv", GL_GetTextureParameterIiv) + DESKTOP_ONLY("glGetTextureParameterIuiv", GL_GetTextureParameterIuiv) + DESKTOP_ONLY("glGetTextureParameterfv", GL_GetTextureParameterfv) + DESKTOP_ONLY("glGetTextureParameteriv", GL_GetTextureParameteriv) + DESKTOP_ONLY("glGetTextureSubImage", GL_GetTextureSubImage) + {"glGetTransformFeedbackVarying", P(GL_GetTransformFeedbackVarying)}, + DESKTOP_ONLY("glGetTransformFeedbacki64_v", GL_GetTransformFeedbacki64_v) + DESKTOP_ONLY("glGetTransformFeedbacki_v", GL_GetTransformFeedbacki_v) + DESKTOP_ONLY("glGetTransformFeedbackiv", GL_GetTransformFeedbackiv) + {"glGetTranslatedShaderSourceANGLE", P(GL_GetTranslatedShaderSourceANGLE)}, + {"glGetUniformBlockIndex", P(GL_GetUniformBlockIndex)}, + {"glGetUniformIndices", P(GL_GetUniformIndices)}, + {"glGetUniformLocation", P(GL_GetUniformLocation)}, + DESKTOP_ONLY("glGetUniformSubroutineuiv", GL_GetUniformSubroutineuiv) + DESKTOP_ONLY("glGetUniformdv", GL_GetUniformdv) + {"glGetUniformfv", P(GL_GetUniformfv)}, + {"glGetUniformfvRobustANGLE", P(GL_GetUniformfvRobustANGLE)}, + {"glGetUniformiv", P(GL_GetUniformiv)}, + {"glGetUniformivRobustANGLE", P(GL_GetUniformivRobustANGLE)}, + {"glGetUniformuiv", P(GL_GetUniformuiv)}, + {"glGetUniformuivRobustANGLE", P(GL_GetUniformuivRobustANGLE)}, + {"glGetUnsignedBytei_vEXT", P(GL_GetUnsignedBytei_vEXT)}, + {"glGetUnsignedBytevEXT", P(GL_GetUnsignedBytevEXT)}, + DESKTOP_ONLY("glGetVertexArrayIndexed64iv", GL_GetVertexArrayIndexed64iv) + DESKTOP_ONLY("glGetVertexArrayIndexediv", GL_GetVertexArrayIndexediv) + DESKTOP_ONLY("glGetVertexArrayiv", GL_GetVertexArrayiv) + {"glGetVertexAttribIiv", P(GL_GetVertexAttribIiv)}, + {"glGetVertexAttribIivRobustANGLE", P(GL_GetVertexAttribIivRobustANGLE)}, + {"glGetVertexAttribIuiv", P(GL_GetVertexAttribIuiv)}, + {"glGetVertexAttribIuivRobustANGLE", P(GL_GetVertexAttribIuivRobustANGLE)}, + DESKTOP_ONLY("glGetVertexAttribLdv", GL_GetVertexAttribLdv) + {"glGetVertexAttribPointerv", P(GL_GetVertexAttribPointerv)}, + {"glGetVertexAttribPointervRobustANGLE", P(GL_GetVertexAttribPointervRobustANGLE)}, + DESKTOP_ONLY("glGetVertexAttribdv", GL_GetVertexAttribdv) + {"glGetVertexAttribfv", P(GL_GetVertexAttribfv)}, + {"glGetVertexAttribfvRobustANGLE", P(GL_GetVertexAttribfvRobustANGLE)}, + {"glGetVertexAttribiv", P(GL_GetVertexAttribiv)}, + {"glGetVertexAttribivRobustANGLE", P(GL_GetVertexAttribivRobustANGLE)}, + DESKTOP_ONLY("glGetnColorTable", GL_GetnColorTable) + DESKTOP_ONLY("glGetnCompressedTexImage", GL_GetnCompressedTexImage) + DESKTOP_ONLY("glGetnConvolutionFilter", GL_GetnConvolutionFilter) + DESKTOP_ONLY("glGetnHistogram", GL_GetnHistogram) + DESKTOP_ONLY("glGetnMapdv", GL_GetnMapdv) + DESKTOP_ONLY("glGetnMapfv", GL_GetnMapfv) + DESKTOP_ONLY("glGetnMapiv", GL_GetnMapiv) + DESKTOP_ONLY("glGetnMinmax", GL_GetnMinmax) + DESKTOP_ONLY("glGetnPixelMapfv", GL_GetnPixelMapfv) + DESKTOP_ONLY("glGetnPixelMapuiv", GL_GetnPixelMapuiv) + DESKTOP_ONLY("glGetnPixelMapusv", GL_GetnPixelMapusv) + DESKTOP_ONLY("glGetnPolygonStipple", GL_GetnPolygonStipple) + DESKTOP_ONLY("glGetnSeparableFilter", GL_GetnSeparableFilter) + DESKTOP_ONLY("glGetnTexImage", GL_GetnTexImage) + DESKTOP_ONLY("glGetnUniformdv", GL_GetnUniformdv) + {"glGetnUniformfv", P(GL_GetnUniformfv)}, + {"glGetnUniformfvEXT", P(GL_GetnUniformfvEXT)}, + {"glGetnUniformfvRobustANGLE", P(GL_GetnUniformfvRobustANGLE)}, + {"glGetnUniformiv", P(GL_GetnUniformiv)}, + {"glGetnUniformivEXT", P(GL_GetnUniformivEXT)}, + {"glGetnUniformivRobustANGLE", P(GL_GetnUniformivRobustANGLE)}, + {"glGetnUniformuiv", P(GL_GetnUniformuiv)}, + {"glGetnUniformuivRobustANGLE", P(GL_GetnUniformuivRobustANGLE)}, + {"glHint", P(GL_Hint)}, + {"glImportMemoryFdEXT", P(GL_ImportMemoryFdEXT)}, + {"glImportMemoryZirconHandleANGLE", P(GL_ImportMemoryZirconHandleANGLE)}, + {"glImportSemaphoreFdEXT", P(GL_ImportSemaphoreFdEXT)}, + {"glImportSemaphoreZirconHandleANGLE", P(GL_ImportSemaphoreZirconHandleANGLE)}, + DESKTOP_ONLY("glIndexMask", GL_IndexMask) + DESKTOP_ONLY("glIndexPointer", GL_IndexPointer) + DESKTOP_ONLY("glIndexd", GL_Indexd) + DESKTOP_ONLY("glIndexdv", GL_Indexdv) + DESKTOP_ONLY("glIndexf", GL_Indexf) + DESKTOP_ONLY("glIndexfv", GL_Indexfv) + DESKTOP_ONLY("glIndexi", GL_Indexi) + DESKTOP_ONLY("glIndexiv", GL_Indexiv) + DESKTOP_ONLY("glIndexs", GL_Indexs) + DESKTOP_ONLY("glIndexsv", GL_Indexsv) + DESKTOP_ONLY("glIndexub", GL_Indexub) + DESKTOP_ONLY("glIndexubv", GL_Indexubv) + DESKTOP_ONLY("glInitNames", GL_InitNames) + {"glInsertEventMarkerEXT", P(GL_InsertEventMarkerEXT)}, + DESKTOP_ONLY("glInterleavedArrays", GL_InterleavedArrays) + DESKTOP_ONLY("glInvalidateBufferData", GL_InvalidateBufferData) + DESKTOP_ONLY("glInvalidateBufferSubData", GL_InvalidateBufferSubData) + {"glInvalidateFramebuffer", P(GL_InvalidateFramebuffer)}, + DESKTOP_ONLY("glInvalidateNamedFramebufferData", GL_InvalidateNamedFramebufferData) + DESKTOP_ONLY("glInvalidateNamedFramebufferSubData", GL_InvalidateNamedFramebufferSubData) + {"glInvalidateSubFramebuffer", P(GL_InvalidateSubFramebuffer)}, + DESKTOP_ONLY("glInvalidateTexImage", GL_InvalidateTexImage) + DESKTOP_ONLY("glInvalidateTexSubImage", GL_InvalidateTexSubImage) + {"glInvalidateTextureANGLE", P(GL_InvalidateTextureANGLE)}, + {"glIsBuffer", P(GL_IsBuffer)}, + {"glIsEnabled", P(GL_IsEnabled)}, + {"glIsEnabledi", P(GL_IsEnabledi)}, + {"glIsEnablediEXT", P(GL_IsEnablediEXT)}, + {"glIsEnablediOES", P(GL_IsEnablediOES)}, + {"glIsFenceNV", P(GL_IsFenceNV)}, + {"glIsFramebuffer", P(GL_IsFramebuffer)}, + {"glIsFramebufferOES", P(GL_IsFramebufferOES)}, + DESKTOP_ONLY("glIsList", GL_IsList) + {"glIsMemoryObjectEXT", P(GL_IsMemoryObjectEXT)}, + {"glIsProgram", P(GL_IsProgram)}, + {"glIsProgramPipeline", P(GL_IsProgramPipeline)}, + {"glIsProgramPipelineEXT", P(GL_IsProgramPipelineEXT)}, + {"glIsQuery", P(GL_IsQuery)}, + {"glIsQueryEXT", P(GL_IsQueryEXT)}, + {"glIsRenderbuffer", P(GL_IsRenderbuffer)}, + {"glIsRenderbufferOES", P(GL_IsRenderbufferOES)}, + {"glIsSampler", P(GL_IsSampler)}, + {"glIsSemaphoreEXT", P(GL_IsSemaphoreEXT)}, + {"glIsShader", P(GL_IsShader)}, + {"glIsSync", P(GL_IsSync)}, + {"glIsTexture", P(GL_IsTexture)}, + {"glIsTransformFeedback", P(GL_IsTransformFeedback)}, + {"glIsVertexArray", P(GL_IsVertexArray)}, + {"glIsVertexArrayOES", P(GL_IsVertexArrayOES)}, + {"glLabelObjectEXT", P(GL_LabelObjectEXT)}, + {"glLightModelf", P(GL_LightModelf)}, + {"glLightModelfv", P(GL_LightModelfv)}, + DESKTOP_ONLY("glLightModeli", GL_LightModeli) + DESKTOP_ONLY("glLightModeliv", GL_LightModeliv) + {"glLightModelx", P(GL_LightModelx)}, + {"glLightModelxv", P(GL_LightModelxv)}, + {"glLightf", P(GL_Lightf)}, + {"glLightfv", P(GL_Lightfv)}, + DESKTOP_ONLY("glLighti", GL_Lighti) + DESKTOP_ONLY("glLightiv", GL_Lightiv) + {"glLightx", P(GL_Lightx)}, + {"glLightxv", P(GL_Lightxv)}, + DESKTOP_ONLY("glLineStipple", GL_LineStipple) + {"glLineWidth", P(GL_LineWidth)}, + {"glLineWidthx", P(GL_LineWidthx)}, + {"glLinkProgram", P(GL_LinkProgram)}, + DESKTOP_ONLY("glListBase", GL_ListBase) + {"glLoadIdentity", P(GL_LoadIdentity)}, + DESKTOP_ONLY("glLoadMatrixd", GL_LoadMatrixd) + {"glLoadMatrixf", P(GL_LoadMatrixf)}, + {"glLoadMatrixx", P(GL_LoadMatrixx)}, + DESKTOP_ONLY("glLoadName", GL_LoadName) + {"glLoadPaletteFromModelViewMatrixOES", P(GL_LoadPaletteFromModelViewMatrixOES)}, + DESKTOP_ONLY("glLoadTransposeMatrixd", GL_LoadTransposeMatrixd) + DESKTOP_ONLY("glLoadTransposeMatrixf", GL_LoadTransposeMatrixf) + {"glLogicOp", P(GL_LogicOp)}, + {"glLogicOpANGLE", P(GL_LogicOpANGLE)}, + {"glLoseContextCHROMIUM", P(GL_LoseContextCHROMIUM)}, + DESKTOP_ONLY("glMap1d", GL_Map1d) + DESKTOP_ONLY("glMap1f", GL_Map1f) + DESKTOP_ONLY("glMap2d", GL_Map2d) + DESKTOP_ONLY("glMap2f", GL_Map2f) + DESKTOP_ONLY("glMapBuffer", GL_MapBuffer) + {"glMapBufferOES", P(GL_MapBufferOES)}, + {"glMapBufferRange", P(GL_MapBufferRange)}, + {"glMapBufferRangeEXT", P(GL_MapBufferRangeEXT)}, + DESKTOP_ONLY("glMapGrid1d", GL_MapGrid1d) + DESKTOP_ONLY("glMapGrid1f", GL_MapGrid1f) + DESKTOP_ONLY("glMapGrid2d", GL_MapGrid2d) + DESKTOP_ONLY("glMapGrid2f", GL_MapGrid2f) + DESKTOP_ONLY("glMapNamedBuffer", GL_MapNamedBuffer) + DESKTOP_ONLY("glMapNamedBufferRange", GL_MapNamedBufferRange) + {"glMaterialf", P(GL_Materialf)}, + {"glMaterialfv", P(GL_Materialfv)}, + DESKTOP_ONLY("glMateriali", GL_Materiali) + DESKTOP_ONLY("glMaterialiv", GL_Materialiv) + {"glMaterialx", P(GL_Materialx)}, + {"glMaterialxv", P(GL_Materialxv)}, + {"glMatrixIndexPointerOES", P(GL_MatrixIndexPointerOES)}, + {"glMatrixMode", P(GL_MatrixMode)}, + {"glMaxShaderCompilerThreadsKHR", P(GL_MaxShaderCompilerThreadsKHR)}, + {"glMemoryBarrier", P(GL_MemoryBarrier)}, + {"glMemoryBarrierByRegion", P(GL_MemoryBarrierByRegion)}, + {"glMemoryObjectParameterivEXT", P(GL_MemoryObjectParameterivEXT)}, + {"glMinSampleShading", P(GL_MinSampleShading)}, + {"glMinSampleShadingOES", P(GL_MinSampleShadingOES)}, + DESKTOP_ONLY("glMultMatrixd", GL_MultMatrixd) + {"glMultMatrixf", P(GL_MultMatrixf)}, + {"glMultMatrixx", P(GL_MultMatrixx)}, + DESKTOP_ONLY("glMultTransposeMatrixd", GL_MultTransposeMatrixd) + DESKTOP_ONLY("glMultTransposeMatrixf", GL_MultTransposeMatrixf) + DESKTOP_ONLY("glMultiDrawArrays", GL_MultiDrawArrays) + {"glMultiDrawArraysANGLE", P(GL_MultiDrawArraysANGLE)}, + DESKTOP_ONLY("glMultiDrawArraysIndirect", GL_MultiDrawArraysIndirect) + DESKTOP_ONLY("glMultiDrawArraysIndirectCount", GL_MultiDrawArraysIndirectCount) + {"glMultiDrawArraysIndirectEXT", P(GL_MultiDrawArraysIndirectEXT)}, + {"glMultiDrawArraysInstancedANGLE", P(GL_MultiDrawArraysInstancedANGLE)}, + {"glMultiDrawArraysInstancedBaseInstanceANGLE", P(GL_MultiDrawArraysInstancedBaseInstanceANGLE)}, + DESKTOP_ONLY("glMultiDrawElements", GL_MultiDrawElements) + {"glMultiDrawElementsANGLE", P(GL_MultiDrawElementsANGLE)}, + DESKTOP_ONLY("glMultiDrawElementsBaseVertex", GL_MultiDrawElementsBaseVertex) + {"glMultiDrawElementsBaseVertexEXT", P(GL_MultiDrawElementsBaseVertexEXT)}, + DESKTOP_ONLY("glMultiDrawElementsIndirect", GL_MultiDrawElementsIndirect) + DESKTOP_ONLY("glMultiDrawElementsIndirectCount", GL_MultiDrawElementsIndirectCount) + {"glMultiDrawElementsIndirectEXT", P(GL_MultiDrawElementsIndirectEXT)}, + {"glMultiDrawElementsInstancedANGLE", P(GL_MultiDrawElementsInstancedANGLE)}, + {"glMultiDrawElementsInstancedBaseVertexBaseInstanceANGLE", P(GL_MultiDrawElementsInstancedBaseVertexBaseInstanceANGLE)}, + DESKTOP_ONLY("glMultiTexCoord1d", GL_MultiTexCoord1d) + DESKTOP_ONLY("glMultiTexCoord1dv", GL_MultiTexCoord1dv) + DESKTOP_ONLY("glMultiTexCoord1f", GL_MultiTexCoord1f) + DESKTOP_ONLY("glMultiTexCoord1fv", GL_MultiTexCoord1fv) + DESKTOP_ONLY("glMultiTexCoord1i", GL_MultiTexCoord1i) + DESKTOP_ONLY("glMultiTexCoord1iv", GL_MultiTexCoord1iv) + DESKTOP_ONLY("glMultiTexCoord1s", GL_MultiTexCoord1s) + DESKTOP_ONLY("glMultiTexCoord1sv", GL_MultiTexCoord1sv) + DESKTOP_ONLY("glMultiTexCoord2d", GL_MultiTexCoord2d) + DESKTOP_ONLY("glMultiTexCoord2dv", GL_MultiTexCoord2dv) + DESKTOP_ONLY("glMultiTexCoord2f", GL_MultiTexCoord2f) + DESKTOP_ONLY("glMultiTexCoord2fv", GL_MultiTexCoord2fv) + DESKTOP_ONLY("glMultiTexCoord2i", GL_MultiTexCoord2i) + DESKTOP_ONLY("glMultiTexCoord2iv", GL_MultiTexCoord2iv) + DESKTOP_ONLY("glMultiTexCoord2s", GL_MultiTexCoord2s) + DESKTOP_ONLY("glMultiTexCoord2sv", GL_MultiTexCoord2sv) + DESKTOP_ONLY("glMultiTexCoord3d", GL_MultiTexCoord3d) + DESKTOP_ONLY("glMultiTexCoord3dv", GL_MultiTexCoord3dv) + DESKTOP_ONLY("glMultiTexCoord3f", GL_MultiTexCoord3f) + DESKTOP_ONLY("glMultiTexCoord3fv", GL_MultiTexCoord3fv) + DESKTOP_ONLY("glMultiTexCoord3i", GL_MultiTexCoord3i) + DESKTOP_ONLY("glMultiTexCoord3iv", GL_MultiTexCoord3iv) + DESKTOP_ONLY("glMultiTexCoord3s", GL_MultiTexCoord3s) + DESKTOP_ONLY("glMultiTexCoord3sv", GL_MultiTexCoord3sv) + DESKTOP_ONLY("glMultiTexCoord4d", GL_MultiTexCoord4d) + DESKTOP_ONLY("glMultiTexCoord4dv", GL_MultiTexCoord4dv) + {"glMultiTexCoord4f", P(GL_MultiTexCoord4f)}, + DESKTOP_ONLY("glMultiTexCoord4fv", GL_MultiTexCoord4fv) + DESKTOP_ONLY("glMultiTexCoord4i", GL_MultiTexCoord4i) + DESKTOP_ONLY("glMultiTexCoord4iv", GL_MultiTexCoord4iv) + DESKTOP_ONLY("glMultiTexCoord4s", GL_MultiTexCoord4s) + DESKTOP_ONLY("glMultiTexCoord4sv", GL_MultiTexCoord4sv) + {"glMultiTexCoord4x", P(GL_MultiTexCoord4x)}, + DESKTOP_ONLY("glMultiTexCoordP1ui", GL_MultiTexCoordP1ui) + DESKTOP_ONLY("glMultiTexCoordP1uiv", GL_MultiTexCoordP1uiv) + DESKTOP_ONLY("glMultiTexCoordP2ui", GL_MultiTexCoordP2ui) + DESKTOP_ONLY("glMultiTexCoordP2uiv", GL_MultiTexCoordP2uiv) + DESKTOP_ONLY("glMultiTexCoordP3ui", GL_MultiTexCoordP3ui) + DESKTOP_ONLY("glMultiTexCoordP3uiv", GL_MultiTexCoordP3uiv) + DESKTOP_ONLY("glMultiTexCoordP4ui", GL_MultiTexCoordP4ui) + DESKTOP_ONLY("glMultiTexCoordP4uiv", GL_MultiTexCoordP4uiv) + DESKTOP_ONLY("glNamedBufferData", GL_NamedBufferData) + DESKTOP_ONLY("glNamedBufferStorage", GL_NamedBufferStorage) + {"glNamedBufferStorageExternalEXT", P(GL_NamedBufferStorageExternalEXT)}, + DESKTOP_ONLY("glNamedBufferSubData", GL_NamedBufferSubData) + DESKTOP_ONLY("glNamedFramebufferDrawBuffer", GL_NamedFramebufferDrawBuffer) + DESKTOP_ONLY("glNamedFramebufferDrawBuffers", GL_NamedFramebufferDrawBuffers) + DESKTOP_ONLY("glNamedFramebufferParameteri", GL_NamedFramebufferParameteri) + DESKTOP_ONLY("glNamedFramebufferReadBuffer", GL_NamedFramebufferReadBuffer) + DESKTOP_ONLY("glNamedFramebufferRenderbuffer", GL_NamedFramebufferRenderbuffer) + DESKTOP_ONLY("glNamedFramebufferTexture", GL_NamedFramebufferTexture) + DESKTOP_ONLY("glNamedFramebufferTextureLayer", GL_NamedFramebufferTextureLayer) + DESKTOP_ONLY("glNamedRenderbufferStorage", GL_NamedRenderbufferStorage) + DESKTOP_ONLY("glNamedRenderbufferStorageMultisample", GL_NamedRenderbufferStorageMultisample) + DESKTOP_ONLY("glNewList", GL_NewList) + DESKTOP_ONLY("glNormal3b", GL_Normal3b) + DESKTOP_ONLY("glNormal3bv", GL_Normal3bv) + DESKTOP_ONLY("glNormal3d", GL_Normal3d) + DESKTOP_ONLY("glNormal3dv", GL_Normal3dv) + {"glNormal3f", P(GL_Normal3f)}, + DESKTOP_ONLY("glNormal3fv", GL_Normal3fv) + DESKTOP_ONLY("glNormal3i", GL_Normal3i) + DESKTOP_ONLY("glNormal3iv", GL_Normal3iv) + DESKTOP_ONLY("glNormal3s", GL_Normal3s) + DESKTOP_ONLY("glNormal3sv", GL_Normal3sv) + {"glNormal3x", P(GL_Normal3x)}, + DESKTOP_ONLY("glNormalP3ui", GL_NormalP3ui) + DESKTOP_ONLY("glNormalP3uiv", GL_NormalP3uiv) + {"glNormalPointer", P(GL_NormalPointer)}, + {"glObjectLabel", P(GL_ObjectLabel)}, + {"glObjectLabelKHR", P(GL_ObjectLabelKHR)}, + {"glObjectPtrLabel", P(GL_ObjectPtrLabel)}, + {"glObjectPtrLabelKHR", P(GL_ObjectPtrLabelKHR)}, + DESKTOP_ONLY("glOrtho", GL_Ortho) + {"glOrthof", P(GL_Orthof)}, + {"glOrthox", P(GL_Orthox)}, + DESKTOP_ONLY("glPassThrough", GL_PassThrough) + DESKTOP_ONLY("glPatchParameterfv", GL_PatchParameterfv) + {"glPatchParameteri", P(GL_PatchParameteri)}, + {"glPatchParameteriEXT", P(GL_PatchParameteriEXT)}, + {"glPauseTransformFeedback", P(GL_PauseTransformFeedback)}, + {"glPixelLocalStorageBarrierANGLE", P(GL_PixelLocalStorageBarrierANGLE)}, + DESKTOP_ONLY("glPixelMapfv", GL_PixelMapfv) + DESKTOP_ONLY("glPixelMapuiv", GL_PixelMapuiv) + DESKTOP_ONLY("glPixelMapusv", GL_PixelMapusv) + DESKTOP_ONLY("glPixelStoref", GL_PixelStoref) + {"glPixelStorei", P(GL_PixelStorei)}, + DESKTOP_ONLY("glPixelTransferf", GL_PixelTransferf) + DESKTOP_ONLY("glPixelTransferi", GL_PixelTransferi) + DESKTOP_ONLY("glPixelZoom", GL_PixelZoom) + {"glPointParameterf", P(GL_PointParameterf)}, + {"glPointParameterfv", P(GL_PointParameterfv)}, + DESKTOP_ONLY("glPointParameteri", GL_PointParameteri) + DESKTOP_ONLY("glPointParameteriv", GL_PointParameteriv) + {"glPointParameterx", P(GL_PointParameterx)}, + {"glPointParameterxv", P(GL_PointParameterxv)}, + {"glPointSize", P(GL_PointSize)}, + {"glPointSizePointerOES", P(GL_PointSizePointerOES)}, + {"glPointSizex", P(GL_PointSizex)}, + DESKTOP_ONLY("glPolygonMode", GL_PolygonMode) + {"glPolygonOffset", P(GL_PolygonOffset)}, + DESKTOP_ONLY("glPolygonOffsetClamp", GL_PolygonOffsetClamp) + {"glPolygonOffsetx", P(GL_PolygonOffsetx)}, + DESKTOP_ONLY("glPolygonStipple", GL_PolygonStipple) + DESKTOP_ONLY("glPopAttrib", GL_PopAttrib) + DESKTOP_ONLY("glPopClientAttrib", GL_PopClientAttrib) + {"glPopDebugGroup", P(GL_PopDebugGroup)}, + {"glPopDebugGroupKHR", P(GL_PopDebugGroupKHR)}, + {"glPopGroupMarkerEXT", P(GL_PopGroupMarkerEXT)}, + {"glPopMatrix", P(GL_PopMatrix)}, + DESKTOP_ONLY("glPopName", GL_PopName) + {"glPrimitiveBoundingBox", P(GL_PrimitiveBoundingBox)}, + {"glPrimitiveBoundingBoxEXT", P(GL_PrimitiveBoundingBoxEXT)}, + {"glPrimitiveBoundingBoxOES", P(GL_PrimitiveBoundingBoxOES)}, + DESKTOP_ONLY("glPrimitiveRestartIndex", GL_PrimitiveRestartIndex) + DESKTOP_ONLY("glPrioritizeTextures", GL_PrioritizeTextures) + {"glProgramBinary", P(GL_ProgramBinary)}, + {"glProgramBinaryOES", P(GL_ProgramBinaryOES)}, + {"glProgramParameteri", P(GL_ProgramParameteri)}, + {"glProgramParameteriEXT", P(GL_ProgramParameteriEXT)}, + DESKTOP_ONLY("glProgramUniform1d", GL_ProgramUniform1d) + DESKTOP_ONLY("glProgramUniform1dv", GL_ProgramUniform1dv) + {"glProgramUniform1f", P(GL_ProgramUniform1f)}, + {"glProgramUniform1fEXT", P(GL_ProgramUniform1fEXT)}, + {"glProgramUniform1fv", P(GL_ProgramUniform1fv)}, + {"glProgramUniform1fvEXT", P(GL_ProgramUniform1fvEXT)}, + {"glProgramUniform1i", P(GL_ProgramUniform1i)}, + {"glProgramUniform1iEXT", P(GL_ProgramUniform1iEXT)}, + {"glProgramUniform1iv", P(GL_ProgramUniform1iv)}, + {"glProgramUniform1ivEXT", P(GL_ProgramUniform1ivEXT)}, + {"glProgramUniform1ui", P(GL_ProgramUniform1ui)}, + {"glProgramUniform1uiEXT", P(GL_ProgramUniform1uiEXT)}, + {"glProgramUniform1uiv", P(GL_ProgramUniform1uiv)}, + {"glProgramUniform1uivEXT", P(GL_ProgramUniform1uivEXT)}, + DESKTOP_ONLY("glProgramUniform2d", GL_ProgramUniform2d) + DESKTOP_ONLY("glProgramUniform2dv", GL_ProgramUniform2dv) + {"glProgramUniform2f", P(GL_ProgramUniform2f)}, + {"glProgramUniform2fEXT", P(GL_ProgramUniform2fEXT)}, + {"glProgramUniform2fv", P(GL_ProgramUniform2fv)}, + {"glProgramUniform2fvEXT", P(GL_ProgramUniform2fvEXT)}, + {"glProgramUniform2i", P(GL_ProgramUniform2i)}, + {"glProgramUniform2iEXT", P(GL_ProgramUniform2iEXT)}, + {"glProgramUniform2iv", P(GL_ProgramUniform2iv)}, + {"glProgramUniform2ivEXT", P(GL_ProgramUniform2ivEXT)}, + {"glProgramUniform2ui", P(GL_ProgramUniform2ui)}, + {"glProgramUniform2uiEXT", P(GL_ProgramUniform2uiEXT)}, + {"glProgramUniform2uiv", P(GL_ProgramUniform2uiv)}, + {"glProgramUniform2uivEXT", P(GL_ProgramUniform2uivEXT)}, + DESKTOP_ONLY("glProgramUniform3d", GL_ProgramUniform3d) + DESKTOP_ONLY("glProgramUniform3dv", GL_ProgramUniform3dv) + {"glProgramUniform3f", P(GL_ProgramUniform3f)}, + {"glProgramUniform3fEXT", P(GL_ProgramUniform3fEXT)}, + {"glProgramUniform3fv", P(GL_ProgramUniform3fv)}, + {"glProgramUniform3fvEXT", P(GL_ProgramUniform3fvEXT)}, + {"glProgramUniform3i", P(GL_ProgramUniform3i)}, + {"glProgramUniform3iEXT", P(GL_ProgramUniform3iEXT)}, + {"glProgramUniform3iv", P(GL_ProgramUniform3iv)}, + {"glProgramUniform3ivEXT", P(GL_ProgramUniform3ivEXT)}, + {"glProgramUniform3ui", P(GL_ProgramUniform3ui)}, + {"glProgramUniform3uiEXT", P(GL_ProgramUniform3uiEXT)}, + {"glProgramUniform3uiv", P(GL_ProgramUniform3uiv)}, + {"glProgramUniform3uivEXT", P(GL_ProgramUniform3uivEXT)}, + DESKTOP_ONLY("glProgramUniform4d", GL_ProgramUniform4d) + DESKTOP_ONLY("glProgramUniform4dv", GL_ProgramUniform4dv) + {"glProgramUniform4f", P(GL_ProgramUniform4f)}, + {"glProgramUniform4fEXT", P(GL_ProgramUniform4fEXT)}, + {"glProgramUniform4fv", P(GL_ProgramUniform4fv)}, + {"glProgramUniform4fvEXT", P(GL_ProgramUniform4fvEXT)}, + {"glProgramUniform4i", P(GL_ProgramUniform4i)}, + {"glProgramUniform4iEXT", P(GL_ProgramUniform4iEXT)}, + {"glProgramUniform4iv", P(GL_ProgramUniform4iv)}, + {"glProgramUniform4ivEXT", P(GL_ProgramUniform4ivEXT)}, + {"glProgramUniform4ui", P(GL_ProgramUniform4ui)}, + {"glProgramUniform4uiEXT", P(GL_ProgramUniform4uiEXT)}, + {"glProgramUniform4uiv", P(GL_ProgramUniform4uiv)}, + {"glProgramUniform4uivEXT", P(GL_ProgramUniform4uivEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix2dv", GL_ProgramUniformMatrix2dv) + {"glProgramUniformMatrix2fv", P(GL_ProgramUniformMatrix2fv)}, + {"glProgramUniformMatrix2fvEXT", P(GL_ProgramUniformMatrix2fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix2x3dv", GL_ProgramUniformMatrix2x3dv) + {"glProgramUniformMatrix2x3fv", P(GL_ProgramUniformMatrix2x3fv)}, + {"glProgramUniformMatrix2x3fvEXT", P(GL_ProgramUniformMatrix2x3fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix2x4dv", GL_ProgramUniformMatrix2x4dv) + {"glProgramUniformMatrix2x4fv", P(GL_ProgramUniformMatrix2x4fv)}, + {"glProgramUniformMatrix2x4fvEXT", P(GL_ProgramUniformMatrix2x4fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix3dv", GL_ProgramUniformMatrix3dv) + {"glProgramUniformMatrix3fv", P(GL_ProgramUniformMatrix3fv)}, + {"glProgramUniformMatrix3fvEXT", P(GL_ProgramUniformMatrix3fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix3x2dv", GL_ProgramUniformMatrix3x2dv) + {"glProgramUniformMatrix3x2fv", P(GL_ProgramUniformMatrix3x2fv)}, + {"glProgramUniformMatrix3x2fvEXT", P(GL_ProgramUniformMatrix3x2fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix3x4dv", GL_ProgramUniformMatrix3x4dv) + {"glProgramUniformMatrix3x4fv", P(GL_ProgramUniformMatrix3x4fv)}, + {"glProgramUniformMatrix3x4fvEXT", P(GL_ProgramUniformMatrix3x4fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix4dv", GL_ProgramUniformMatrix4dv) + {"glProgramUniformMatrix4fv", P(GL_ProgramUniformMatrix4fv)}, + {"glProgramUniformMatrix4fvEXT", P(GL_ProgramUniformMatrix4fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix4x2dv", GL_ProgramUniformMatrix4x2dv) + {"glProgramUniformMatrix4x2fv", P(GL_ProgramUniformMatrix4x2fv)}, + {"glProgramUniformMatrix4x2fvEXT", P(GL_ProgramUniformMatrix4x2fvEXT)}, + DESKTOP_ONLY("glProgramUniformMatrix4x3dv", GL_ProgramUniformMatrix4x3dv) + {"glProgramUniformMatrix4x3fv", P(GL_ProgramUniformMatrix4x3fv)}, + {"glProgramUniformMatrix4x3fvEXT", P(GL_ProgramUniformMatrix4x3fvEXT)}, + DESKTOP_ONLY("glProvokingVertex", GL_ProvokingVertex) + {"glProvokingVertexANGLE", P(GL_ProvokingVertexANGLE)}, + DESKTOP_ONLY("glPushAttrib", GL_PushAttrib) + DESKTOP_ONLY("glPushClientAttrib", GL_PushClientAttrib) + {"glPushDebugGroup", P(GL_PushDebugGroup)}, + {"glPushDebugGroupKHR", P(GL_PushDebugGroupKHR)}, + {"glPushGroupMarkerEXT", P(GL_PushGroupMarkerEXT)}, + {"glPushMatrix", P(GL_PushMatrix)}, + DESKTOP_ONLY("glPushName", GL_PushName) + DESKTOP_ONLY("glQueryCounter", GL_QueryCounter) + {"glQueryCounterEXT", P(GL_QueryCounterEXT)}, + {"glQueryMatrixxOES", P(GL_QueryMatrixxOES)}, + DESKTOP_ONLY("glRasterPos2d", GL_RasterPos2d) + DESKTOP_ONLY("glRasterPos2dv", GL_RasterPos2dv) + DESKTOP_ONLY("glRasterPos2f", GL_RasterPos2f) + DESKTOP_ONLY("glRasterPos2fv", GL_RasterPos2fv) + DESKTOP_ONLY("glRasterPos2i", GL_RasterPos2i) + DESKTOP_ONLY("glRasterPos2iv", GL_RasterPos2iv) + DESKTOP_ONLY("glRasterPos2s", GL_RasterPos2s) + DESKTOP_ONLY("glRasterPos2sv", GL_RasterPos2sv) + DESKTOP_ONLY("glRasterPos3d", GL_RasterPos3d) + DESKTOP_ONLY("glRasterPos3dv", GL_RasterPos3dv) + DESKTOP_ONLY("glRasterPos3f", GL_RasterPos3f) + DESKTOP_ONLY("glRasterPos3fv", GL_RasterPos3fv) + DESKTOP_ONLY("glRasterPos3i", GL_RasterPos3i) + DESKTOP_ONLY("glRasterPos3iv", GL_RasterPos3iv) + DESKTOP_ONLY("glRasterPos3s", GL_RasterPos3s) + DESKTOP_ONLY("glRasterPos3sv", GL_RasterPos3sv) + DESKTOP_ONLY("glRasterPos4d", GL_RasterPos4d) + DESKTOP_ONLY("glRasterPos4dv", GL_RasterPos4dv) + DESKTOP_ONLY("glRasterPos4f", GL_RasterPos4f) + DESKTOP_ONLY("glRasterPos4fv", GL_RasterPos4fv) + DESKTOP_ONLY("glRasterPos4i", GL_RasterPos4i) + DESKTOP_ONLY("glRasterPos4iv", GL_RasterPos4iv) + DESKTOP_ONLY("glRasterPos4s", GL_RasterPos4s) + DESKTOP_ONLY("glRasterPos4sv", GL_RasterPos4sv) + {"glReadBuffer", P(GL_ReadBuffer)}, + {"glReadPixels", P(GL_ReadPixels)}, + {"glReadPixelsRobustANGLE", P(GL_ReadPixelsRobustANGLE)}, + {"glReadnPixels", P(GL_ReadnPixels)}, + {"glReadnPixelsEXT", P(GL_ReadnPixelsEXT)}, + {"glReadnPixelsRobustANGLE", P(GL_ReadnPixelsRobustANGLE)}, + DESKTOP_ONLY("glRectd", GL_Rectd) + DESKTOP_ONLY("glRectdv", GL_Rectdv) + DESKTOP_ONLY("glRectf", GL_Rectf) + DESKTOP_ONLY("glRectfv", GL_Rectfv) + DESKTOP_ONLY("glRecti", GL_Recti) + DESKTOP_ONLY("glRectiv", GL_Rectiv) + DESKTOP_ONLY("glRects", GL_Rects) + DESKTOP_ONLY("glRectsv", GL_Rectsv) + {"glReleaseShaderCompiler", P(GL_ReleaseShaderCompiler)}, + {"glReleaseTexturesANGLE", P(GL_ReleaseTexturesANGLE)}, + DESKTOP_ONLY("glRenderMode", GL_RenderMode) + {"glRenderbufferStorage", P(GL_RenderbufferStorage)}, + {"glRenderbufferStorageMultisample", P(GL_RenderbufferStorageMultisample)}, + {"glRenderbufferStorageMultisampleANGLE", P(GL_RenderbufferStorageMultisampleANGLE)}, + {"glRenderbufferStorageMultisampleEXT", P(GL_RenderbufferStorageMultisampleEXT)}, + {"glRenderbufferStorageOES", P(GL_RenderbufferStorageOES)}, + {"glRequestExtensionANGLE", P(GL_RequestExtensionANGLE)}, + {"glResumeTransformFeedback", P(GL_ResumeTransformFeedback)}, + DESKTOP_ONLY("glRotated", GL_Rotated) + {"glRotatef", P(GL_Rotatef)}, + {"glRotatex", P(GL_Rotatex)}, + {"glSampleCoverage", P(GL_SampleCoverage)}, + {"glSampleCoveragex", P(GL_SampleCoveragex)}, + {"glSampleMaski", P(GL_SampleMaski)}, + {"glSampleMaskiANGLE", P(GL_SampleMaskiANGLE)}, + {"glSamplerParameterIiv", P(GL_SamplerParameterIiv)}, + {"glSamplerParameterIivEXT", P(GL_SamplerParameterIivEXT)}, + {"glSamplerParameterIivOES", P(GL_SamplerParameterIivOES)}, + {"glSamplerParameterIivRobustANGLE", P(GL_SamplerParameterIivRobustANGLE)}, + {"glSamplerParameterIuiv", P(GL_SamplerParameterIuiv)}, + {"glSamplerParameterIuivEXT", P(GL_SamplerParameterIuivEXT)}, + {"glSamplerParameterIuivOES", P(GL_SamplerParameterIuivOES)}, + {"glSamplerParameterIuivRobustANGLE", P(GL_SamplerParameterIuivRobustANGLE)}, + {"glSamplerParameterf", P(GL_SamplerParameterf)}, + {"glSamplerParameterfv", P(GL_SamplerParameterfv)}, + {"glSamplerParameterfvRobustANGLE", P(GL_SamplerParameterfvRobustANGLE)}, + {"glSamplerParameteri", P(GL_SamplerParameteri)}, + {"glSamplerParameteriv", P(GL_SamplerParameteriv)}, + {"glSamplerParameterivRobustANGLE", P(GL_SamplerParameterivRobustANGLE)}, + DESKTOP_ONLY("glScaled", GL_Scaled) + {"glScalef", P(GL_Scalef)}, + {"glScalex", P(GL_Scalex)}, + {"glScissor", P(GL_Scissor)}, + DESKTOP_ONLY("glScissorArrayv", GL_ScissorArrayv) + DESKTOP_ONLY("glScissorIndexed", GL_ScissorIndexed) + DESKTOP_ONLY("glScissorIndexedv", GL_ScissorIndexedv) + DESKTOP_ONLY("glSecondaryColor3b", GL_SecondaryColor3b) + DESKTOP_ONLY("glSecondaryColor3bv", GL_SecondaryColor3bv) + DESKTOP_ONLY("glSecondaryColor3d", GL_SecondaryColor3d) + DESKTOP_ONLY("glSecondaryColor3dv", GL_SecondaryColor3dv) + DESKTOP_ONLY("glSecondaryColor3f", GL_SecondaryColor3f) + DESKTOP_ONLY("glSecondaryColor3fv", GL_SecondaryColor3fv) + DESKTOP_ONLY("glSecondaryColor3i", GL_SecondaryColor3i) + DESKTOP_ONLY("glSecondaryColor3iv", GL_SecondaryColor3iv) + DESKTOP_ONLY("glSecondaryColor3s", GL_SecondaryColor3s) + DESKTOP_ONLY("glSecondaryColor3sv", GL_SecondaryColor3sv) + DESKTOP_ONLY("glSecondaryColor3ub", GL_SecondaryColor3ub) + DESKTOP_ONLY("glSecondaryColor3ubv", GL_SecondaryColor3ubv) + DESKTOP_ONLY("glSecondaryColor3ui", GL_SecondaryColor3ui) + DESKTOP_ONLY("glSecondaryColor3uiv", GL_SecondaryColor3uiv) + DESKTOP_ONLY("glSecondaryColor3us", GL_SecondaryColor3us) + DESKTOP_ONLY("glSecondaryColor3usv", GL_SecondaryColor3usv) + DESKTOP_ONLY("glSecondaryColorP3ui", GL_SecondaryColorP3ui) + DESKTOP_ONLY("glSecondaryColorP3uiv", GL_SecondaryColorP3uiv) + DESKTOP_ONLY("glSecondaryColorPointer", GL_SecondaryColorPointer) + DESKTOP_ONLY("glSelectBuffer", GL_SelectBuffer) + {"glSelectPerfMonitorCountersAMD", P(GL_SelectPerfMonitorCountersAMD)}, + {"glSemaphoreParameterui64vEXT", P(GL_SemaphoreParameterui64vEXT)}, + {"glSetFenceNV", P(GL_SetFenceNV)}, + {"glShadeModel", P(GL_ShadeModel)}, + {"glShaderBinary", P(GL_ShaderBinary)}, + {"glShaderSource", P(GL_ShaderSource)}, + DESKTOP_ONLY("glShaderStorageBlockBinding", GL_ShaderStorageBlockBinding) + {"glShadingRateQCOM", P(GL_ShadingRateQCOM)}, + {"glSignalSemaphoreEXT", P(GL_SignalSemaphoreEXT)}, + DESKTOP_ONLY("glSpecializeShader", GL_SpecializeShader) + {"glStencilFunc", P(GL_StencilFunc)}, + {"glStencilFuncSeparate", P(GL_StencilFuncSeparate)}, + {"glStencilMask", P(GL_StencilMask)}, + {"glStencilMaskSeparate", P(GL_StencilMaskSeparate)}, + {"glStencilOp", P(GL_StencilOp)}, + {"glStencilOpSeparate", P(GL_StencilOpSeparate)}, + {"glTestFenceNV", P(GL_TestFenceNV)}, + {"glTexBuffer", P(GL_TexBuffer)}, + {"glTexBufferEXT", P(GL_TexBufferEXT)}, + {"glTexBufferOES", P(GL_TexBufferOES)}, + {"glTexBufferRange", P(GL_TexBufferRange)}, + {"glTexBufferRangeEXT", P(GL_TexBufferRangeEXT)}, + {"glTexBufferRangeOES", P(GL_TexBufferRangeOES)}, + DESKTOP_ONLY("glTexCoord1d", GL_TexCoord1d) + DESKTOP_ONLY("glTexCoord1dv", GL_TexCoord1dv) + DESKTOP_ONLY("glTexCoord1f", GL_TexCoord1f) + DESKTOP_ONLY("glTexCoord1fv", GL_TexCoord1fv) + DESKTOP_ONLY("glTexCoord1i", GL_TexCoord1i) + DESKTOP_ONLY("glTexCoord1iv", GL_TexCoord1iv) + DESKTOP_ONLY("glTexCoord1s", GL_TexCoord1s) + DESKTOP_ONLY("glTexCoord1sv", GL_TexCoord1sv) + DESKTOP_ONLY("glTexCoord2d", GL_TexCoord2d) + DESKTOP_ONLY("glTexCoord2dv", GL_TexCoord2dv) + DESKTOP_ONLY("glTexCoord2f", GL_TexCoord2f) + DESKTOP_ONLY("glTexCoord2fv", GL_TexCoord2fv) + DESKTOP_ONLY("glTexCoord2i", GL_TexCoord2i) + DESKTOP_ONLY("glTexCoord2iv", GL_TexCoord2iv) + DESKTOP_ONLY("glTexCoord2s", GL_TexCoord2s) + DESKTOP_ONLY("glTexCoord2sv", GL_TexCoord2sv) + DESKTOP_ONLY("glTexCoord3d", GL_TexCoord3d) + DESKTOP_ONLY("glTexCoord3dv", GL_TexCoord3dv) + DESKTOP_ONLY("glTexCoord3f", GL_TexCoord3f) + DESKTOP_ONLY("glTexCoord3fv", GL_TexCoord3fv) + DESKTOP_ONLY("glTexCoord3i", GL_TexCoord3i) + DESKTOP_ONLY("glTexCoord3iv", GL_TexCoord3iv) + DESKTOP_ONLY("glTexCoord3s", GL_TexCoord3s) + DESKTOP_ONLY("glTexCoord3sv", GL_TexCoord3sv) + DESKTOP_ONLY("glTexCoord4d", GL_TexCoord4d) + DESKTOP_ONLY("glTexCoord4dv", GL_TexCoord4dv) + DESKTOP_ONLY("glTexCoord4f", GL_TexCoord4f) + DESKTOP_ONLY("glTexCoord4fv", GL_TexCoord4fv) + DESKTOP_ONLY("glTexCoord4i", GL_TexCoord4i) + DESKTOP_ONLY("glTexCoord4iv", GL_TexCoord4iv) + DESKTOP_ONLY("glTexCoord4s", GL_TexCoord4s) + DESKTOP_ONLY("glTexCoord4sv", GL_TexCoord4sv) + DESKTOP_ONLY("glTexCoordP1ui", GL_TexCoordP1ui) + DESKTOP_ONLY("glTexCoordP1uiv", GL_TexCoordP1uiv) + DESKTOP_ONLY("glTexCoordP2ui", GL_TexCoordP2ui) + DESKTOP_ONLY("glTexCoordP2uiv", GL_TexCoordP2uiv) + DESKTOP_ONLY("glTexCoordP3ui", GL_TexCoordP3ui) + DESKTOP_ONLY("glTexCoordP3uiv", GL_TexCoordP3uiv) + DESKTOP_ONLY("glTexCoordP4ui", GL_TexCoordP4ui) + DESKTOP_ONLY("glTexCoordP4uiv", GL_TexCoordP4uiv) + {"glTexCoordPointer", P(GL_TexCoordPointer)}, + {"glTexEnvf", P(GL_TexEnvf)}, + {"glTexEnvfv", P(GL_TexEnvfv)}, + {"glTexEnvi", P(GL_TexEnvi)}, + {"glTexEnviv", P(GL_TexEnviv)}, + {"glTexEnvx", P(GL_TexEnvx)}, + {"glTexEnvxv", P(GL_TexEnvxv)}, + DESKTOP_ONLY("glTexGend", GL_TexGend) + DESKTOP_ONLY("glTexGendv", GL_TexGendv) + DESKTOP_ONLY("glTexGenf", GL_TexGenf) + {"glTexGenfOES", P(GL_TexGenfOES)}, + DESKTOP_ONLY("glTexGenfv", GL_TexGenfv) + {"glTexGenfvOES", P(GL_TexGenfvOES)}, + DESKTOP_ONLY("glTexGeni", GL_TexGeni) + {"glTexGeniOES", P(GL_TexGeniOES)}, + DESKTOP_ONLY("glTexGeniv", GL_TexGeniv) + {"glTexGenivOES", P(GL_TexGenivOES)}, + {"glTexGenxOES", P(GL_TexGenxOES)}, + {"glTexGenxvOES", P(GL_TexGenxvOES)}, + DESKTOP_ONLY("glTexImage1D", GL_TexImage1D) + {"glTexImage2D", P(GL_TexImage2D)}, + {"glTexImage2DExternalANGLE", P(GL_TexImage2DExternalANGLE)}, + DESKTOP_ONLY("glTexImage2DMultisample", GL_TexImage2DMultisample) + {"glTexImage2DRobustANGLE", P(GL_TexImage2DRobustANGLE)}, + {"glTexImage3D", P(GL_TexImage3D)}, + DESKTOP_ONLY("glTexImage3DMultisample", GL_TexImage3DMultisample) + {"glTexImage3DOES", P(GL_TexImage3DOES)}, + {"glTexImage3DRobustANGLE", P(GL_TexImage3DRobustANGLE)}, + {"glTexParameterIiv", P(GL_TexParameterIiv)}, + {"glTexParameterIivEXT", P(GL_TexParameterIivEXT)}, + {"glTexParameterIivOES", P(GL_TexParameterIivOES)}, + {"glTexParameterIivRobustANGLE", P(GL_TexParameterIivRobustANGLE)}, + {"glTexParameterIuiv", P(GL_TexParameterIuiv)}, + {"glTexParameterIuivEXT", P(GL_TexParameterIuivEXT)}, + {"glTexParameterIuivOES", P(GL_TexParameterIuivOES)}, + {"glTexParameterIuivRobustANGLE", P(GL_TexParameterIuivRobustANGLE)}, + {"glTexParameterf", P(GL_TexParameterf)}, + {"glTexParameterfv", P(GL_TexParameterfv)}, + {"glTexParameterfvRobustANGLE", P(GL_TexParameterfvRobustANGLE)}, + {"glTexParameteri", P(GL_TexParameteri)}, + {"glTexParameteriv", P(GL_TexParameteriv)}, + {"glTexParameterivRobustANGLE", P(GL_TexParameterivRobustANGLE)}, + {"glTexParameterx", P(GL_TexParameterx)}, + {"glTexParameterxv", P(GL_TexParameterxv)}, + DESKTOP_ONLY("glTexStorage1D", GL_TexStorage1D) + {"glTexStorage1DEXT", P(GL_TexStorage1DEXT)}, + {"glTexStorage2D", P(GL_TexStorage2D)}, + {"glTexStorage2DEXT", P(GL_TexStorage2DEXT)}, + {"glTexStorage2DMultisample", P(GL_TexStorage2DMultisample)}, + {"glTexStorage2DMultisampleANGLE", P(GL_TexStorage2DMultisampleANGLE)}, + {"glTexStorage3D", P(GL_TexStorage3D)}, + {"glTexStorage3DEXT", P(GL_TexStorage3DEXT)}, + {"glTexStorage3DMultisample", P(GL_TexStorage3DMultisample)}, + {"glTexStorage3DMultisampleOES", P(GL_TexStorage3DMultisampleOES)}, + {"glTexStorageMem2DEXT", P(GL_TexStorageMem2DEXT)}, + {"glTexStorageMem2DMultisampleEXT", P(GL_TexStorageMem2DMultisampleEXT)}, + {"glTexStorageMem3DEXT", P(GL_TexStorageMem3DEXT)}, + {"glTexStorageMem3DMultisampleEXT", P(GL_TexStorageMem3DMultisampleEXT)}, + {"glTexStorageMemFlags2DANGLE", P(GL_TexStorageMemFlags2DANGLE)}, + {"glTexStorageMemFlags2DMultisampleANGLE", P(GL_TexStorageMemFlags2DMultisampleANGLE)}, + {"glTexStorageMemFlags3DANGLE", P(GL_TexStorageMemFlags3DANGLE)}, + {"glTexStorageMemFlags3DMultisampleANGLE", P(GL_TexStorageMemFlags3DMultisampleANGLE)}, + DESKTOP_ONLY("glTexSubImage1D", GL_TexSubImage1D) + {"glTexSubImage2D", P(GL_TexSubImage2D)}, + {"glTexSubImage2DRobustANGLE", P(GL_TexSubImage2DRobustANGLE)}, + {"glTexSubImage3D", P(GL_TexSubImage3D)}, + {"glTexSubImage3DOES", P(GL_TexSubImage3DOES)}, + {"glTexSubImage3DRobustANGLE", P(GL_TexSubImage3DRobustANGLE)}, + DESKTOP_ONLY("glTextureBarrier", GL_TextureBarrier) + DESKTOP_ONLY("glTextureBuffer", GL_TextureBuffer) + DESKTOP_ONLY("glTextureBufferRange", GL_TextureBufferRange) + DESKTOP_ONLY("glTextureParameterIiv", GL_TextureParameterIiv) + DESKTOP_ONLY("glTextureParameterIuiv", GL_TextureParameterIuiv) + DESKTOP_ONLY("glTextureParameterf", GL_TextureParameterf) + DESKTOP_ONLY("glTextureParameterfv", GL_TextureParameterfv) + DESKTOP_ONLY("glTextureParameteri", GL_TextureParameteri) + DESKTOP_ONLY("glTextureParameteriv", GL_TextureParameteriv) + DESKTOP_ONLY("glTextureStorage1D", GL_TextureStorage1D) + DESKTOP_ONLY("glTextureStorage2D", GL_TextureStorage2D) + DESKTOP_ONLY("glTextureStorage2DMultisample", GL_TextureStorage2DMultisample) + DESKTOP_ONLY("glTextureStorage3D", GL_TextureStorage3D) + DESKTOP_ONLY("glTextureStorage3DMultisample", GL_TextureStorage3DMultisample) + DESKTOP_ONLY("glTextureSubImage1D", GL_TextureSubImage1D) + DESKTOP_ONLY("glTextureSubImage2D", GL_TextureSubImage2D) + DESKTOP_ONLY("glTextureSubImage3D", GL_TextureSubImage3D) + DESKTOP_ONLY("glTextureView", GL_TextureView) + DESKTOP_ONLY("glTransformFeedbackBufferBase", GL_TransformFeedbackBufferBase) + DESKTOP_ONLY("glTransformFeedbackBufferRange", GL_TransformFeedbackBufferRange) + {"glTransformFeedbackVaryings", P(GL_TransformFeedbackVaryings)}, + DESKTOP_ONLY("glTranslated", GL_Translated) + {"glTranslatef", P(GL_Translatef)}, + {"glTranslatex", P(GL_Translatex)}, + DESKTOP_ONLY("glUniform1d", GL_Uniform1d) + DESKTOP_ONLY("glUniform1dv", GL_Uniform1dv) + {"glUniform1f", P(GL_Uniform1f)}, + {"glUniform1fv", P(GL_Uniform1fv)}, + {"glUniform1i", P(GL_Uniform1i)}, + {"glUniform1iv", P(GL_Uniform1iv)}, + {"glUniform1ui", P(GL_Uniform1ui)}, + {"glUniform1uiv", P(GL_Uniform1uiv)}, + DESKTOP_ONLY("glUniform2d", GL_Uniform2d) + DESKTOP_ONLY("glUniform2dv", GL_Uniform2dv) + {"glUniform2f", P(GL_Uniform2f)}, + {"glUniform2fv", P(GL_Uniform2fv)}, + {"glUniform2i", P(GL_Uniform2i)}, + {"glUniform2iv", P(GL_Uniform2iv)}, + {"glUniform2ui", P(GL_Uniform2ui)}, + {"glUniform2uiv", P(GL_Uniform2uiv)}, + DESKTOP_ONLY("glUniform3d", GL_Uniform3d) + DESKTOP_ONLY("glUniform3dv", GL_Uniform3dv) + {"glUniform3f", P(GL_Uniform3f)}, + {"glUniform3fv", P(GL_Uniform3fv)}, + {"glUniform3i", P(GL_Uniform3i)}, + {"glUniform3iv", P(GL_Uniform3iv)}, + {"glUniform3ui", P(GL_Uniform3ui)}, + {"glUniform3uiv", P(GL_Uniform3uiv)}, + DESKTOP_ONLY("glUniform4d", GL_Uniform4d) + DESKTOP_ONLY("glUniform4dv", GL_Uniform4dv) + {"glUniform4f", P(GL_Uniform4f)}, + {"glUniform4fv", P(GL_Uniform4fv)}, + {"glUniform4i", P(GL_Uniform4i)}, + {"glUniform4iv", P(GL_Uniform4iv)}, + {"glUniform4ui", P(GL_Uniform4ui)}, + {"glUniform4uiv", P(GL_Uniform4uiv)}, + {"glUniformBlockBinding", P(GL_UniformBlockBinding)}, + DESKTOP_ONLY("glUniformMatrix2dv", GL_UniformMatrix2dv) + {"glUniformMatrix2fv", P(GL_UniformMatrix2fv)}, + DESKTOP_ONLY("glUniformMatrix2x3dv", GL_UniformMatrix2x3dv) + {"glUniformMatrix2x3fv", P(GL_UniformMatrix2x3fv)}, + DESKTOP_ONLY("glUniformMatrix2x4dv", GL_UniformMatrix2x4dv) + {"glUniformMatrix2x4fv", P(GL_UniformMatrix2x4fv)}, + DESKTOP_ONLY("glUniformMatrix3dv", GL_UniformMatrix3dv) + {"glUniformMatrix3fv", P(GL_UniformMatrix3fv)}, + DESKTOP_ONLY("glUniformMatrix3x2dv", GL_UniformMatrix3x2dv) + {"glUniformMatrix3x2fv", P(GL_UniformMatrix3x2fv)}, + DESKTOP_ONLY("glUniformMatrix3x4dv", GL_UniformMatrix3x4dv) + {"glUniformMatrix3x4fv", P(GL_UniformMatrix3x4fv)}, + DESKTOP_ONLY("glUniformMatrix4dv", GL_UniformMatrix4dv) + {"glUniformMatrix4fv", P(GL_UniformMatrix4fv)}, + DESKTOP_ONLY("glUniformMatrix4x2dv", GL_UniformMatrix4x2dv) + {"glUniformMatrix4x2fv", P(GL_UniformMatrix4x2fv)}, + DESKTOP_ONLY("glUniformMatrix4x3dv", GL_UniformMatrix4x3dv) + {"glUniformMatrix4x3fv", P(GL_UniformMatrix4x3fv)}, + DESKTOP_ONLY("glUniformSubroutinesuiv", GL_UniformSubroutinesuiv) + {"glUnmapBuffer", P(GL_UnmapBuffer)}, + {"glUnmapBufferOES", P(GL_UnmapBufferOES)}, + DESKTOP_ONLY("glUnmapNamedBuffer", GL_UnmapNamedBuffer) + {"glUseProgram", P(GL_UseProgram)}, + {"glUseProgramStages", P(GL_UseProgramStages)}, + {"glUseProgramStagesEXT", P(GL_UseProgramStagesEXT)}, + {"glValidateProgram", P(GL_ValidateProgram)}, + {"glValidateProgramPipeline", P(GL_ValidateProgramPipeline)}, + {"glValidateProgramPipelineEXT", P(GL_ValidateProgramPipelineEXT)}, + DESKTOP_ONLY("glVertex2d", GL_Vertex2d) + DESKTOP_ONLY("glVertex2dv", GL_Vertex2dv) + DESKTOP_ONLY("glVertex2f", GL_Vertex2f) + DESKTOP_ONLY("glVertex2fv", GL_Vertex2fv) + DESKTOP_ONLY("glVertex2i", GL_Vertex2i) + DESKTOP_ONLY("glVertex2iv", GL_Vertex2iv) + DESKTOP_ONLY("glVertex2s", GL_Vertex2s) + DESKTOP_ONLY("glVertex2sv", GL_Vertex2sv) + DESKTOP_ONLY("glVertex3d", GL_Vertex3d) + DESKTOP_ONLY("glVertex3dv", GL_Vertex3dv) + DESKTOP_ONLY("glVertex3f", GL_Vertex3f) + DESKTOP_ONLY("glVertex3fv", GL_Vertex3fv) + DESKTOP_ONLY("glVertex3i", GL_Vertex3i) + DESKTOP_ONLY("glVertex3iv", GL_Vertex3iv) + DESKTOP_ONLY("glVertex3s", GL_Vertex3s) + DESKTOP_ONLY("glVertex3sv", GL_Vertex3sv) + DESKTOP_ONLY("glVertex4d", GL_Vertex4d) + DESKTOP_ONLY("glVertex4dv", GL_Vertex4dv) + DESKTOP_ONLY("glVertex4f", GL_Vertex4f) + DESKTOP_ONLY("glVertex4fv", GL_Vertex4fv) + DESKTOP_ONLY("glVertex4i", GL_Vertex4i) + DESKTOP_ONLY("glVertex4iv", GL_Vertex4iv) + DESKTOP_ONLY("glVertex4s", GL_Vertex4s) + DESKTOP_ONLY("glVertex4sv", GL_Vertex4sv) + DESKTOP_ONLY("glVertexArrayAttribBinding", GL_VertexArrayAttribBinding) + DESKTOP_ONLY("glVertexArrayAttribFormat", GL_VertexArrayAttribFormat) + DESKTOP_ONLY("glVertexArrayAttribIFormat", GL_VertexArrayAttribIFormat) + DESKTOP_ONLY("glVertexArrayAttribLFormat", GL_VertexArrayAttribLFormat) + DESKTOP_ONLY("glVertexArrayBindingDivisor", GL_VertexArrayBindingDivisor) + DESKTOP_ONLY("glVertexArrayElementBuffer", GL_VertexArrayElementBuffer) + DESKTOP_ONLY("glVertexArrayVertexBuffer", GL_VertexArrayVertexBuffer) + DESKTOP_ONLY("glVertexArrayVertexBuffers", GL_VertexArrayVertexBuffers) + DESKTOP_ONLY("glVertexAttrib1d", GL_VertexAttrib1d) + DESKTOP_ONLY("glVertexAttrib1dv", GL_VertexAttrib1dv) + {"glVertexAttrib1f", P(GL_VertexAttrib1f)}, + {"glVertexAttrib1fv", P(GL_VertexAttrib1fv)}, + DESKTOP_ONLY("glVertexAttrib1s", GL_VertexAttrib1s) + DESKTOP_ONLY("glVertexAttrib1sv", GL_VertexAttrib1sv) + DESKTOP_ONLY("glVertexAttrib2d", GL_VertexAttrib2d) + DESKTOP_ONLY("glVertexAttrib2dv", GL_VertexAttrib2dv) + {"glVertexAttrib2f", P(GL_VertexAttrib2f)}, + {"glVertexAttrib2fv", P(GL_VertexAttrib2fv)}, + DESKTOP_ONLY("glVertexAttrib2s", GL_VertexAttrib2s) + DESKTOP_ONLY("glVertexAttrib2sv", GL_VertexAttrib2sv) + DESKTOP_ONLY("glVertexAttrib3d", GL_VertexAttrib3d) + DESKTOP_ONLY("glVertexAttrib3dv", GL_VertexAttrib3dv) + {"glVertexAttrib3f", P(GL_VertexAttrib3f)}, + {"glVertexAttrib3fv", P(GL_VertexAttrib3fv)}, + DESKTOP_ONLY("glVertexAttrib3s", GL_VertexAttrib3s) + DESKTOP_ONLY("glVertexAttrib3sv", GL_VertexAttrib3sv) + DESKTOP_ONLY("glVertexAttrib4Nbv", GL_VertexAttrib4Nbv) + DESKTOP_ONLY("glVertexAttrib4Niv", GL_VertexAttrib4Niv) + DESKTOP_ONLY("glVertexAttrib4Nsv", GL_VertexAttrib4Nsv) + DESKTOP_ONLY("glVertexAttrib4Nub", GL_VertexAttrib4Nub) + DESKTOP_ONLY("glVertexAttrib4Nubv", GL_VertexAttrib4Nubv) + DESKTOP_ONLY("glVertexAttrib4Nuiv", GL_VertexAttrib4Nuiv) + DESKTOP_ONLY("glVertexAttrib4Nusv", GL_VertexAttrib4Nusv) + DESKTOP_ONLY("glVertexAttrib4bv", GL_VertexAttrib4bv) + DESKTOP_ONLY("glVertexAttrib4d", GL_VertexAttrib4d) + DESKTOP_ONLY("glVertexAttrib4dv", GL_VertexAttrib4dv) + {"glVertexAttrib4f", P(GL_VertexAttrib4f)}, + {"glVertexAttrib4fv", P(GL_VertexAttrib4fv)}, + DESKTOP_ONLY("glVertexAttrib4iv", GL_VertexAttrib4iv) + DESKTOP_ONLY("glVertexAttrib4s", GL_VertexAttrib4s) + DESKTOP_ONLY("glVertexAttrib4sv", GL_VertexAttrib4sv) + DESKTOP_ONLY("glVertexAttrib4ubv", GL_VertexAttrib4ubv) + DESKTOP_ONLY("glVertexAttrib4uiv", GL_VertexAttrib4uiv) + DESKTOP_ONLY("glVertexAttrib4usv", GL_VertexAttrib4usv) + {"glVertexAttribBinding", P(GL_VertexAttribBinding)}, + {"glVertexAttribDivisor", P(GL_VertexAttribDivisor)}, + {"glVertexAttribDivisorANGLE", P(GL_VertexAttribDivisorANGLE)}, + {"glVertexAttribDivisorEXT", P(GL_VertexAttribDivisorEXT)}, + {"glVertexAttribFormat", P(GL_VertexAttribFormat)}, + DESKTOP_ONLY("glVertexAttribI1i", GL_VertexAttribI1i) + DESKTOP_ONLY("glVertexAttribI1iv", GL_VertexAttribI1iv) + DESKTOP_ONLY("glVertexAttribI1ui", GL_VertexAttribI1ui) + DESKTOP_ONLY("glVertexAttribI1uiv", GL_VertexAttribI1uiv) + DESKTOP_ONLY("glVertexAttribI2i", GL_VertexAttribI2i) + DESKTOP_ONLY("glVertexAttribI2iv", GL_VertexAttribI2iv) + DESKTOP_ONLY("glVertexAttribI2ui", GL_VertexAttribI2ui) + DESKTOP_ONLY("glVertexAttribI2uiv", GL_VertexAttribI2uiv) + DESKTOP_ONLY("glVertexAttribI3i", GL_VertexAttribI3i) + DESKTOP_ONLY("glVertexAttribI3iv", GL_VertexAttribI3iv) + DESKTOP_ONLY("glVertexAttribI3ui", GL_VertexAttribI3ui) + DESKTOP_ONLY("glVertexAttribI3uiv", GL_VertexAttribI3uiv) + DESKTOP_ONLY("glVertexAttribI4bv", GL_VertexAttribI4bv) + {"glVertexAttribI4i", P(GL_VertexAttribI4i)}, + {"glVertexAttribI4iv", P(GL_VertexAttribI4iv)}, + DESKTOP_ONLY("glVertexAttribI4sv", GL_VertexAttribI4sv) + DESKTOP_ONLY("glVertexAttribI4ubv", GL_VertexAttribI4ubv) + {"glVertexAttribI4ui", P(GL_VertexAttribI4ui)}, + {"glVertexAttribI4uiv", P(GL_VertexAttribI4uiv)}, + DESKTOP_ONLY("glVertexAttribI4usv", GL_VertexAttribI4usv) + {"glVertexAttribIFormat", P(GL_VertexAttribIFormat)}, + {"glVertexAttribIPointer", P(GL_VertexAttribIPointer)}, + DESKTOP_ONLY("glVertexAttribL1d", GL_VertexAttribL1d) + DESKTOP_ONLY("glVertexAttribL1dv", GL_VertexAttribL1dv) + DESKTOP_ONLY("glVertexAttribL2d", GL_VertexAttribL2d) + DESKTOP_ONLY("glVertexAttribL2dv", GL_VertexAttribL2dv) + DESKTOP_ONLY("glVertexAttribL3d", GL_VertexAttribL3d) + DESKTOP_ONLY("glVertexAttribL3dv", GL_VertexAttribL3dv) + DESKTOP_ONLY("glVertexAttribL4d", GL_VertexAttribL4d) + DESKTOP_ONLY("glVertexAttribL4dv", GL_VertexAttribL4dv) + DESKTOP_ONLY("glVertexAttribLFormat", GL_VertexAttribLFormat) + DESKTOP_ONLY("glVertexAttribLPointer", GL_VertexAttribLPointer) + DESKTOP_ONLY("glVertexAttribP1ui", GL_VertexAttribP1ui) + DESKTOP_ONLY("glVertexAttribP1uiv", GL_VertexAttribP1uiv) + DESKTOP_ONLY("glVertexAttribP2ui", GL_VertexAttribP2ui) + DESKTOP_ONLY("glVertexAttribP2uiv", GL_VertexAttribP2uiv) + DESKTOP_ONLY("glVertexAttribP3ui", GL_VertexAttribP3ui) + DESKTOP_ONLY("glVertexAttribP3uiv", GL_VertexAttribP3uiv) + DESKTOP_ONLY("glVertexAttribP4ui", GL_VertexAttribP4ui) + DESKTOP_ONLY("glVertexAttribP4uiv", GL_VertexAttribP4uiv) + {"glVertexAttribPointer", P(GL_VertexAttribPointer)}, + {"glVertexBindingDivisor", P(GL_VertexBindingDivisor)}, + DESKTOP_ONLY("glVertexP2ui", GL_VertexP2ui) + DESKTOP_ONLY("glVertexP2uiv", GL_VertexP2uiv) + DESKTOP_ONLY("glVertexP3ui", GL_VertexP3ui) + DESKTOP_ONLY("glVertexP3uiv", GL_VertexP3uiv) + DESKTOP_ONLY("glVertexP4ui", GL_VertexP4ui) + DESKTOP_ONLY("glVertexP4uiv", GL_VertexP4uiv) + {"glVertexPointer", P(GL_VertexPointer)}, + {"glViewport", P(GL_Viewport)}, + DESKTOP_ONLY("glViewportArrayv", GL_ViewportArrayv) + DESKTOP_ONLY("glViewportIndexedf", GL_ViewportIndexedf) + DESKTOP_ONLY("glViewportIndexedfv", GL_ViewportIndexedfv) + {"glWaitSemaphoreEXT", P(GL_WaitSemaphoreEXT)}, + {"glWaitSync", P(GL_WaitSync)}, + {"glWeightPointerOES", P(GL_WeightPointerOES)}, + DESKTOP_ONLY("glWindowPos2d", GL_WindowPos2d) + DESKTOP_ONLY("glWindowPos2dv", GL_WindowPos2dv) + DESKTOP_ONLY("glWindowPos2f", GL_WindowPos2f) + DESKTOP_ONLY("glWindowPos2fv", GL_WindowPos2fv) + DESKTOP_ONLY("glWindowPos2i", GL_WindowPos2i) + DESKTOP_ONLY("glWindowPos2iv", GL_WindowPos2iv) + DESKTOP_ONLY("glWindowPos2s", GL_WindowPos2s) + DESKTOP_ONLY("glWindowPos2sv", GL_WindowPos2sv) + DESKTOP_ONLY("glWindowPos3d", GL_WindowPos3d) + DESKTOP_ONLY("glWindowPos3dv", GL_WindowPos3dv) + DESKTOP_ONLY("glWindowPos3f", GL_WindowPos3f) + DESKTOP_ONLY("glWindowPos3fv", GL_WindowPos3fv) + DESKTOP_ONLY("glWindowPos3i", GL_WindowPos3i) + DESKTOP_ONLY("glWindowPos3iv", GL_WindowPos3iv) + DESKTOP_ONLY("glWindowPos3s", GL_WindowPos3s) + DESKTOP_ONLY("glWindowPos3sv", GL_WindowPos3sv) +}; +// clang-format on +const size_t g_numProcs = std::size(g_procTable); +} // namespace egl diff --git a/gfx/angle/checkout/src/libGLESv2/resource.h b/gfx/angle/checkout/src/libGLESv2/resource.h new file mode 100644 index 0000000000..025777671d --- /dev/null +++ b/gfx/angle/checkout/src/libGLESv2/resource.h @@ -0,0 +1,17 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by libGLESv2.rc + +#define IDD_DIALOG1 101 +#define IDC_STATIC -1 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +# ifndef APSTUDIO_READONLY_SYMBOLS +# define _APS_NEXT_RESOURCE_VALUE 101 +# define _APS_NEXT_COMMAND_VALUE 40001 +# define _APS_NEXT_CONTROL_VALUE 1001 +# define _APS_NEXT_SYMED_VALUE 101 +# endif +#endif |