/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* vim: set ts=8 sts=4 et sw=4 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #ifndef GLCONTEXT_H_ #define GLCONTEXT_H_ #include <bitset> #include <ctype.h> #include <stdint.h> #include <stdio.h> #include <map> #include <queue> #include <stack> #ifdef DEBUG #include <string.h> #endif #ifdef GetClassName #undef GetClassName #endif // Define MOZ_GL_DEBUG unconditionally to enable GL debugging in opt // builds. #ifdef DEBUG #define MOZ_GL_DEBUG 1 #endif #include "../../mfbt/RefPtr.h" #include "../../mfbt/UniquePtr.h" #include "GLDefs.h" #include "GLLibraryLoader.h" #include "nsISupportsImpl.h" #include "plstr.h" #include "GLContextTypes.h" #include "SurfaceTypes.h" #include "GLContextSymbols.h" #include "base/platform_thread.h" // for PlatformThreadId #include "mozilla/GenericRefCounted.h" #include "mozilla/WeakPtr.h" #include "gfx2DGlue.h" #include "GeckoProfiler.h" class nsIWidget; namespace android { class GraphicBuffer; } // namespace android namespace mozilla { namespace gfx { class DataSourceSurface; class SourceSurface; } // namespace gfx namespace gl { class GLBlitHelper; class GLBlitTextureImageHelper; class GLContext; class GLLibraryEGL; class GLReadTexImageHelper; class GLScreenBuffer; class SharedSurface; class TextureGarbageBin; struct SurfaceCaps; } // namespace gl namespace layers { class ColorTextureLayerProgram; } // namespace layers } // namespace mozilla namespace mozilla { namespace gl { enum class GLFeature { bind_buffer_offset, blend_minmax, clear_buffers, copy_buffer, depth_texture, draw_buffers, draw_instanced, draw_range_elements, element_index_uint, ES2_compatibility, ES3_compatibility, EXT_color_buffer_float, frag_color_float, frag_depth, framebuffer_blit, framebuffer_multisample, framebuffer_object, framebuffer_object_EXT_OES, get_integer_indexed, get_integer64_indexed, get_query_object_i64v, get_query_object_iv, get_string_indexed, gpu_shader4, instanced_arrays, instanced_non_arrays, internalformat_query, invalidate_framebuffer, map_buffer_range, occlusion_query, occlusion_query_boolean, occlusion_query2, packed_depth_stencil, prim_restart, prim_restart_fixed, query_counter, query_objects, query_time_elapsed, read_buffer, renderbuffer_color_float, renderbuffer_color_half_float, robustness, sRGB_framebuffer, sRGB_texture, sampler_objects, seamless_cube_map_opt_in, shader_texture_lod, split_framebuffer, standard_derivatives, sync, texture_3D, texture_3D_compressed, texture_3D_copy, texture_float, texture_float_linear, texture_half_float, texture_half_float_linear, texture_non_power_of_two, texture_rg, texture_storage, texture_swizzle, transform_feedback2, uniform_buffer_object, uniform_matrix_nonsquare, vertex_array_object, EnumMax }; enum class ContextProfile : uint8_t { Unknown = 0, OpenGL, // only for IsAtLeast's <profile> parameter OpenGLCore, OpenGLCompatibility, OpenGLES }; enum class GLVendor { Intel, NVIDIA, ATI, Qualcomm, Imagination, Nouveau, Vivante, VMware, ARM, Other }; enum class GLRenderer { Adreno200, Adreno205, AdrenoTM200, AdrenoTM205, AdrenoTM305, AdrenoTM320, AdrenoTM330, AdrenoTM420, Mali400MP, Mali450MP, SGX530, SGX540, SGX544MP, Tegra, AndroidEmulator, GalliumLlvmpipe, IntelHD3000, MicrosoftBasicRenderDriver, Other }; class GLContext : public GLLibraryLoader , public GenericAtomicRefCounted , public SupportsWeakPtr<GLContext> { public: MOZ_DECLARE_WEAKREFERENCE_TYPENAME(GLContext) // ----------------------------------------------------------------------------- // basic enums public: // ----------------------------------------------------------------------------- // basic getters public: /** * Returns true if the context is using ANGLE. This should only be overridden * for an ANGLE implementation. */ virtual bool IsANGLE() const { return false; } /** * Returns true if the context is using WARP. This should only be overridden * for an ANGLE implementation. */ virtual bool IsWARP() const { return false; } virtual void GetWSIInfo(nsCString* const out) const = 0; /** * Return true if we are running on a OpenGL core profile context */ inline bool IsCoreProfile() const { MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile"); return mProfile == ContextProfile::OpenGLCore; } /** * Return true if we are running on a OpenGL compatibility profile context * (legacy profile 2.1 on Max OS X) */ inline bool IsCompatibilityProfile() const { MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile"); return mProfile == ContextProfile::OpenGLCompatibility; } /** * Return true if the context is a true OpenGL ES context or an ANGLE context */ inline bool IsGLES() const { MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile"); return mProfile == ContextProfile::OpenGLES; } static const char* GetProfileName(ContextProfile profile) { switch (profile) { case ContextProfile::OpenGL: return "OpenGL"; case ContextProfile::OpenGLCore: return "OpenGL Core"; case ContextProfile::OpenGLCompatibility: return "OpenGL Compatibility"; case ContextProfile::OpenGLES: return "OpenGL ES"; default: break; } MOZ_ASSERT(profile != ContextProfile::Unknown, "unknown context profile"); return "OpenGL unknown profile"; } /** * Return true if we are running on a OpenGL core profile context */ const char* ProfileString() const { return GetProfileName(mProfile); } /** * Return true if the context is compatible with given parameters * * IsAtLeast(ContextProfile::OpenGL, N) is exactly same as * IsAtLeast(ContextProfile::OpenGLCore, N) || IsAtLeast(ContextProfile::OpenGLCompatibility, N) */ inline bool IsAtLeast(ContextProfile profile, unsigned int version) const { MOZ_ASSERT(profile != ContextProfile::Unknown, "IsAtLeast: bad <profile> parameter"); MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile"); MOZ_ASSERT(mVersion != 0, "unknown context version"); if (version > mVersion) { return false; } if (profile == ContextProfile::OpenGL) { return mProfile == ContextProfile::OpenGLCore || mProfile == ContextProfile::OpenGLCompatibility; } return profile == mProfile; } /** * Return the version of the context. * Example : * If this a OpenGL 2.1, that will return 210 */ inline uint32_t Version() const { return mVersion; } const char* VersionString() const { return mVersionString.get(); } inline uint32_t ShadingLanguageVersion() const { return mShadingLanguageVersion; } GLVendor Vendor() const { return mVendor; } GLRenderer Renderer() const { return mRenderer; } bool IsContextLost() const { return mContextLost; } /** * If this context is double-buffered, returns TRUE. */ virtual bool IsDoubleBuffered() const { return false; } virtual GLContextType GetContextType() const = 0; virtual bool IsCurrent() = 0; /** * Get the default framebuffer for this context. */ virtual GLuint GetDefaultFramebuffer() { return 0; } protected: bool mIsOffscreen; bool mContextLost; /** * mVersion store the OpenGL's version, multiplied by 100. For example, if * the context is an OpenGL 2.1 context, mVersion value will be 210. */ uint32_t mVersion; nsCString mVersionString; ContextProfile mProfile; uint32_t mShadingLanguageVersion; GLVendor mVendor; GLRenderer mRenderer; void SetProfileVersion(ContextProfile profile, uint32_t version) { MOZ_ASSERT(!mSymbols.fBindFramebuffer, "SetProfileVersion can only be called before initialization!"); MOZ_ASSERT(profile != ContextProfile::Unknown && profile != ContextProfile::OpenGL, "Invalid `profile` for SetProfileVersion"); MOZ_ASSERT(version >= 100, "Invalid `version` for SetProfileVersion"); mVersion = version; mProfile = profile; } // ----------------------------------------------------------------------------- // Extensions management /** * This mechanism is designed to know if an extension is supported. In the long * term, we would like to only use the extension group queries XXX_* to have * full compatibility with context version and profiles (especialy the core that * officialy don't bring any extensions). */ public: /** * Known GL extensions that can be queried by * IsExtensionSupported. The results of this are cached, and as * such it's safe to use this even in performance critical code. * If you add to this array, remember to add to the string names * in GLContext.cpp. */ enum GLExtensions { Extension_None = 0, AMD_compressed_ATC_texture, ANGLE_depth_texture, ANGLE_framebuffer_blit, ANGLE_framebuffer_multisample, ANGLE_instanced_arrays, ANGLE_texture_compression_dxt3, ANGLE_texture_compression_dxt5, ANGLE_timer_query, APPLE_client_storage, APPLE_framebuffer_multisample, APPLE_sync, APPLE_texture_range, APPLE_vertex_array_object, ARB_ES2_compatibility, ARB_ES3_compatibility, ARB_color_buffer_float, ARB_copy_buffer, ARB_depth_texture, ARB_draw_buffers, ARB_draw_instanced, ARB_framebuffer_object, ARB_framebuffer_sRGB, ARB_geometry_shader4, ARB_half_float_pixel, ARB_instanced_arrays, ARB_internalformat_query, ARB_invalidate_subdata, ARB_map_buffer_range, ARB_occlusion_query2, ARB_pixel_buffer_object, ARB_robustness, ARB_sampler_objects, ARB_seamless_cube_map, ARB_shader_texture_lod, ARB_sync, ARB_texture_compression, ARB_texture_float, ARB_texture_non_power_of_two, ARB_texture_rectangle, ARB_texture_rg, ARB_texture_storage, ARB_texture_swizzle, ARB_timer_query, ARB_transform_feedback2, ARB_uniform_buffer_object, ARB_vertex_array_object, EXT_bgra, EXT_blend_minmax, EXT_color_buffer_float, EXT_color_buffer_half_float, EXT_copy_texture, EXT_disjoint_timer_query, EXT_draw_buffers, EXT_draw_buffers2, EXT_draw_instanced, EXT_draw_range_elements, EXT_frag_depth, EXT_framebuffer_blit, EXT_framebuffer_multisample, EXT_framebuffer_object, EXT_framebuffer_sRGB, EXT_gpu_shader4, EXT_multisampled_render_to_texture, EXT_occlusion_query_boolean, EXT_packed_depth_stencil, EXT_read_format_bgra, EXT_robustness, EXT_sRGB, EXT_sRGB_write_control, EXT_shader_texture_lod, EXT_texture3D, EXT_texture_compression_dxt1, EXT_texture_compression_s3tc, EXT_texture_filter_anisotropic, EXT_texture_format_BGRA8888, EXT_texture_sRGB, EXT_texture_storage, EXT_timer_query, EXT_transform_feedback, EXT_unpack_subimage, IMG_read_format, IMG_texture_compression_pvrtc, IMG_texture_npot, KHR_debug, NV_draw_instanced, NV_fence, NV_framebuffer_blit, NV_geometry_program4, NV_half_float, NV_instanced_arrays, NV_primitive_restart, NV_texture_barrier, NV_transform_feedback, NV_transform_feedback2, OES_EGL_image, OES_EGL_image_external, OES_EGL_sync, OES_compressed_ETC1_RGB8_texture, OES_depth24, OES_depth32, OES_depth_texture, OES_element_index_uint, OES_framebuffer_object, OES_packed_depth_stencil, OES_rgb8_rgba8, OES_standard_derivatives, OES_stencil8, OES_texture_3D, OES_texture_float, OES_texture_float_linear, OES_texture_half_float, OES_texture_half_float_linear, OES_texture_npot, OES_vertex_array_object, Extensions_Max, Extensions_End }; bool IsExtensionSupported(GLExtensions aKnownExtension) const { return mAvailableExtensions[aKnownExtension]; } protected: void MarkExtensionUnsupported(GLExtensions aKnownExtension) { mAvailableExtensions[aKnownExtension] = 0; } void MarkExtensionSupported(GLExtensions aKnownExtension) { mAvailableExtensions[aKnownExtension] = 1; } std::bitset<Extensions_Max> mAvailableExtensions; // ----------------------------------------------------------------------------- // Feature queries /* * This mecahnism introduces a new way to check if a OpenGL feature is * supported, regardless of whether it is supported by an extension or natively * by the context version/profile */ public: bool IsSupported(GLFeature feature) const { return mAvailableFeatures[size_t(feature)]; } static const char* GetFeatureName(GLFeature feature); private: std::bitset<size_t(GLFeature::EnumMax)> mAvailableFeatures; /** * Init features regarding OpenGL extension and context version and profile */ void InitFeatures(); /** * Mark the feature and associated extensions as unsupported */ void MarkUnsupported(GLFeature feature); /** * Is this feature supported using the core (unsuffixed) symbols? */ bool IsFeatureProvidedByCoreSymbols(GLFeature feature); // ----------------------------------------------------------------------------- // Robustness handling private: /** * The derived class is expected to provide information on whether or not it * supports robustness. */ virtual bool SupportsRobustness() const = 0; public: // ----------------------------------------------------------------------------- // Error handling static const char* GLErrorToString(GLenum aError) { switch (aError) { case LOCAL_GL_INVALID_ENUM: return "GL_INVALID_ENUM"; case LOCAL_GL_INVALID_VALUE: return "GL_INVALID_VALUE"; case LOCAL_GL_INVALID_OPERATION: return "GL_INVALID_OPERATION"; case LOCAL_GL_STACK_OVERFLOW: return "GL_STACK_OVERFLOW"; case LOCAL_GL_STACK_UNDERFLOW: return "GL_STACK_UNDERFLOW"; case LOCAL_GL_OUT_OF_MEMORY: return "GL_OUT_OF_MEMORY"; case LOCAL_GL_TABLE_TOO_LARGE: return "GL_TABLE_TOO_LARGE"; case LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION: return "GL_INVALID_FRAMEBUFFER_OPERATION"; default: return ""; } } private: GLenum mTopError; GLenum RawGetError() { return mSymbols.fGetError(); } GLenum RawGetErrorAndClear() { GLenum err = RawGetError(); if (err) while (RawGetError()) {} return err; } public: GLenum FlushErrors() { GLenum err = RawGetErrorAndClear(); if (!mTopError) mTopError = err; return err; } // We smash all errors together, so you never have to loop on this. We // guarantee that immediately after this call, there are no errors left. GLenum fGetError() { FlushErrors(); GLenum err = mTopError; mTopError = LOCAL_GL_NO_ERROR; return err; } //////////////////////////////////// // Use this safer option. class LocalErrorScope; private: std::stack<const LocalErrorScope*> mLocalErrorScopeStack; public: class LocalErrorScope { GLContext& mGL; GLenum mOldTop; bool mHasBeenChecked; public: explicit LocalErrorScope(GLContext& gl) : mGL(gl) , mHasBeenChecked(false) { mGL.mLocalErrorScopeStack.push(this); mGL.FlushErrors(); mOldTop = mGL.mTopError; mGL.mTopError = LOCAL_GL_NO_ERROR; } GLenum GetError() { MOZ_ASSERT(!mHasBeenChecked); mHasBeenChecked = true; const GLenum ret = mGL.fGetError(); while (mGL.fGetError()) {} return ret; } ~LocalErrorScope() { MOZ_ASSERT(mHasBeenChecked); MOZ_ASSERT(mGL.fGetError() == LOCAL_GL_NO_ERROR); MOZ_ASSERT(mGL.mLocalErrorScopeStack.top() == this); mGL.mLocalErrorScopeStack.pop(); mGL.mTopError = mOldTop; } }; bool GetPotentialInteger(GLenum pname, GLint* param) { LocalErrorScope localError(*this); fGetIntegerv(pname, param); GLenum err = localError.GetError(); MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_INVALID_ENUM); return err == LOCAL_GL_NO_ERROR; } private: static void GLAPIENTRY StaticDebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message, const GLvoid* userParam); void DebugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* message); // ----------------------------------------------------------------------------- // MOZ_GL_DEBUG implementation private: #undef BEFORE_GL_CALL #undef AFTER_GL_CALL #ifdef MOZ_GL_DEBUG #ifndef MOZ_FUNCTION_NAME # ifdef __GNUC__ # define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__ # elif defined(_MSC_VER) # define MOZ_FUNCTION_NAME __FUNCTION__ # else # define MOZ_FUNCTION_NAME __func__ // defined in C99, supported in various C++ compilers. Just raw function name. # endif #endif void BeforeGLCall(const char* funcName) { MOZ_ASSERT(IsCurrent()); if (mDebugFlags) { FlushErrors(); if (mDebugFlags & DebugFlagTrace) { printf_stderr("[gl:%p] > %s\n", this, funcName); } GLContext* tlsContext = (GLContext*)PR_GetThreadPrivate(sCurrentGLContextTLS); if (this != tlsContext) { printf_stderr("Fatal: %s called on non-current context %p. The" " current context for this thread is %p.\n", funcName, this, tlsContext); MOZ_CRASH("GFX: GLContext is not current."); } } } void AfterGLCall(const char* funcName) { if (mDebugFlags) { // calling fFinish() immediately after every GL call makes sure that if this GL command crashes, // the stack trace will actually point to it. Otherwise, OpenGL being an asynchronous API, stack traces // tend to be meaningless mSymbols.fFinish(); GLenum err = FlushErrors(); if (mDebugFlags & DebugFlagTrace) { printf_stderr("[gl:%p] < %s [%s (0x%04x)]\n", this, funcName, GLErrorToString(err), err); } if (err != LOCAL_GL_NO_ERROR && !mLocalErrorScopeStack.size()) { printf_stderr("[gl:%p] %s: Generated unexpected %s error." " (0x%04x)\n", this, funcName, GLErrorToString(err), err); if (mDebugFlags & DebugFlagAbortOnError) { MOZ_CRASH("Unexpected error with MOZ_GL_DEBUG_ABORT_ON_ERROR. (Run" " with MOZ_GL_DEBUG_ABORT_ON_ERROR=0 to disable)"); } } } } GLContext* TrackingContext() { GLContext* tip = this; while (tip->mSharedContext) tip = tip->mSharedContext; return tip; } static void AssertNotPassingStackBufferToTheGL(const void* ptr); #ifdef MOZ_WIDGET_ANDROID // Record the name of the GL call for better hang stacks on Android. #define BEFORE_GL_CALL \ PROFILER_LABEL_FUNC( \ js::ProfileEntry::Category::GRAPHICS);\ BeforeGLCall(MOZ_FUNCTION_NAME) #else #define BEFORE_GL_CALL \ do { \ BeforeGLCall(MOZ_FUNCTION_NAME); \ } while (0) #endif #define AFTER_GL_CALL \ do { \ AfterGLCall(MOZ_FUNCTION_NAME); \ } while (0) #define TRACKING_CONTEXT(a) \ do { \ TrackingContext()->a; \ } while (0) #define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) AssertNotPassingStackBufferToTheGL(ptr) #else // ifdef MOZ_GL_DEBUG #ifdef MOZ_WIDGET_ANDROID // Record the name of the GL call for better hang stacks on Android. #define BEFORE_GL_CALL PROFILER_LABEL_FUNC(js::ProfileEntry::Category::GRAPHICS) #else #define BEFORE_GL_CALL do { } while (0) #endif #define AFTER_GL_CALL do { } while (0) #define TRACKING_CONTEXT(a) do {} while (0) #define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) do {} while (0) #endif // ifdef MOZ_GL_DEBUG #define ASSERT_SYMBOL_PRESENT(func) \ do {\ MOZ_ASSERT(strstr(MOZ_FUNCTION_NAME, #func) != nullptr, "Mismatched symbol check.");\ if (MOZ_UNLIKELY(!mSymbols.func)) {\ printf_stderr("RUNTIME ASSERT: Uninitialized GL function: %s\n", #func);\ MOZ_CRASH("GFX: Uninitialized GL function");\ }\ } while (0) // Do whatever setup is necessary to draw to our offscreen FBO, if it's // bound. void BeforeGLDrawCall() { } // Do whatever tear-down is necessary after drawing to our offscreen FBO, // if it's bound. void AfterGLDrawCall(); // Do whatever setup is necessary to read from our offscreen FBO, if it's // bound. void BeforeGLReadCall(); // Do whatever tear-down is necessary after reading from our offscreen FBO, // if it's bound. void AfterGLReadCall() { } // ----------------------------------------------------------------------------- // GL official entry points public: void fActiveTexture(GLenum texture) { BEFORE_GL_CALL; mSymbols.fActiveTexture(texture); AFTER_GL_CALL; } void fAttachShader(GLuint program, GLuint shader) { BEFORE_GL_CALL; mSymbols.fAttachShader(program, shader); AFTER_GL_CALL; } void fBeginQuery(GLenum target, GLuint id) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBeginQuery); mSymbols.fBeginQuery(target, id); AFTER_GL_CALL; } void fBindAttribLocation(GLuint program, GLuint index, const GLchar* name) { BEFORE_GL_CALL; mSymbols.fBindAttribLocation(program, index, name); AFTER_GL_CALL; } void fBindBuffer(GLenum target, GLuint buffer) { BEFORE_GL_CALL; mSymbols.fBindBuffer(target, buffer); AFTER_GL_CALL; } void fBindFramebuffer(GLenum target, GLuint framebuffer); void fInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) { BeforeGLDrawCall(); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fInvalidateFramebuffer); mSymbols.fInvalidateFramebuffer(target, numAttachments, attachments); AFTER_GL_CALL; AfterGLDrawCall(); } void fInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) { BeforeGLDrawCall(); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fInvalidateSubFramebuffer); mSymbols.fInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height); AFTER_GL_CALL; AfterGLDrawCall(); } void fBindTexture(GLenum target, GLuint texture) { BEFORE_GL_CALL; mSymbols.fBindTexture(target, texture); AFTER_GL_CALL; } void fBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) { BEFORE_GL_CALL; mSymbols.fBlendColor(red, green, blue, alpha); AFTER_GL_CALL; } void fBlendEquation(GLenum mode) { BEFORE_GL_CALL; mSymbols.fBlendEquation(mode); AFTER_GL_CALL; } void fBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) { BEFORE_GL_CALL; mSymbols.fBlendEquationSeparate(modeRGB, modeAlpha); AFTER_GL_CALL; } void fBlendFunc(GLenum sfactor, GLenum dfactor) { BEFORE_GL_CALL; mSymbols.fBlendFunc(sfactor, dfactor); AFTER_GL_CALL; } void fBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) { BEFORE_GL_CALL; mSymbols.fBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); AFTER_GL_CALL; } private: void raw_fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data); BEFORE_GL_CALL; mSymbols.fBufferData(target, size, data, usage); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } public: void fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) { raw_fBufferData(target, size, data, usage); // bug 744888 if (WorkAroundDriverBugs() && !data && Vendor() == GLVendor::NVIDIA) { UniquePtr<char[]> buf = MakeUnique<char[]>(1); buf[0] = 0; fBufferSubData(target, size-1, 1, buf.get()); } } void fBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data); BEFORE_GL_CALL; mSymbols.fBufferSubData(target, offset, size, data); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } private: void raw_fClear(GLbitfield mask) { BEFORE_GL_CALL; mSymbols.fClear(mask); AFTER_GL_CALL; } public: void fClear(GLbitfield mask) { BeforeGLDrawCall(); raw_fClear(mask); AfterGLDrawCall(); } void fClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) { BeforeGLDrawCall(); BEFORE_GL_CALL; mSymbols.fClearBufferfi(buffer, drawbuffer, depth, stencil); AFTER_GL_CALL; AfterGLDrawCall(); } void fClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) { BeforeGLDrawCall(); BEFORE_GL_CALL; mSymbols.fClearBufferfv(buffer, drawbuffer, value); AFTER_GL_CALL; AfterGLDrawCall(); } void fClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) { BeforeGLDrawCall(); BEFORE_GL_CALL; mSymbols.fClearBufferiv(buffer, drawbuffer, value); AFTER_GL_CALL; AfterGLDrawCall(); } void fClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) { BeforeGLDrawCall(); BEFORE_GL_CALL; mSymbols.fClearBufferuiv(buffer, drawbuffer, value); AFTER_GL_CALL; AfterGLDrawCall(); } void fClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) { BEFORE_GL_CALL; mSymbols.fClearColor(r, g, b, a); AFTER_GL_CALL; } void fClearStencil(GLint s) { BEFORE_GL_CALL; mSymbols.fClearStencil(s); AFTER_GL_CALL; } void fClientActiveTexture(GLenum texture) { BEFORE_GL_CALL; mSymbols.fClientActiveTexture(texture); AFTER_GL_CALL; } void fColorMask(realGLboolean red, realGLboolean green, realGLboolean blue, realGLboolean alpha) { BEFORE_GL_CALL; mSymbols.fColorMask(red, green, blue, alpha); AFTER_GL_CALL; } void fCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pixels) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels); BEFORE_GL_CALL; mSymbols.fCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } void fCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pixels) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels); BEFORE_GL_CALL; mSymbols.fCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } void fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); void fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { BeforeGLReadCall(); raw_fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); AfterGLReadCall(); } void fCullFace(GLenum mode) { BEFORE_GL_CALL; mSymbols.fCullFace(mode); AFTER_GL_CALL; } void fDebugMessageCallback(GLDEBUGPROC callback, const GLvoid* userParam) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDebugMessageCallback); mSymbols.fDebugMessageCallback(callback, userParam); AFTER_GL_CALL; } void fDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, realGLboolean enabled) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDebugMessageControl); mSymbols.fDebugMessageControl(source, type, severity, count, ids, enabled); AFTER_GL_CALL; } void fDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDebugMessageInsert); mSymbols.fDebugMessageInsert(source, type, id, severity, length, buf); AFTER_GL_CALL; } void fDetachShader(GLuint program, GLuint shader) { BEFORE_GL_CALL; mSymbols.fDetachShader(program, shader); AFTER_GL_CALL; } void fDepthFunc(GLenum func) { BEFORE_GL_CALL; mSymbols.fDepthFunc(func); AFTER_GL_CALL; } void fDepthMask(realGLboolean flag) { BEFORE_GL_CALL; mSymbols.fDepthMask(flag); AFTER_GL_CALL; } void fDisable(GLenum capability) { BEFORE_GL_CALL; mSymbols.fDisable(capability); AFTER_GL_CALL; } void fDisableClientState(GLenum capability) { BEFORE_GL_CALL; mSymbols.fDisableClientState(capability); AFTER_GL_CALL; } void fDisableVertexAttribArray(GLuint index) { BEFORE_GL_CALL; mSymbols.fDisableVertexAttribArray(index); AFTER_GL_CALL; } void fDrawBuffer(GLenum mode) { BEFORE_GL_CALL; mSymbols.fDrawBuffer(mode); AFTER_GL_CALL; } private: void raw_fDrawArrays(GLenum mode, GLint first, GLsizei count) { BEFORE_GL_CALL; mSymbols.fDrawArrays(mode, first, count); AFTER_GL_CALL; } void raw_fDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { BEFORE_GL_CALL; mSymbols.fDrawElements(mode, count, type, indices); AFTER_GL_CALL; } public: void fDrawArrays(GLenum mode, GLint first, GLsizei count) { BeforeGLDrawCall(); raw_fDrawArrays(mode, first, count); AfterGLDrawCall(); } void fDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) { BeforeGLDrawCall(); raw_fDrawElements(mode, count, type, indices); AfterGLDrawCall(); } void fEnable(GLenum capability) { BEFORE_GL_CALL; mSymbols.fEnable(capability); AFTER_GL_CALL; } void fEnableClientState(GLenum capability) { BEFORE_GL_CALL; mSymbols.fEnableClientState(capability); AFTER_GL_CALL; } void fEnableVertexAttribArray(GLuint index) { BEFORE_GL_CALL; mSymbols.fEnableVertexAttribArray(index); AFTER_GL_CALL; } void fEndQuery(GLenum target) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fEndQuery); mSymbols.fEndQuery(target); AFTER_GL_CALL; } void fFinish() { BEFORE_GL_CALL; mSymbols.fFinish(); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = false; } void fFlush() { BEFORE_GL_CALL; mSymbols.fFlush(); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = false; } void fFrontFace(GLenum face) { BEFORE_GL_CALL; mSymbols.fFrontFace(face); AFTER_GL_CALL; } void fGetActiveAttrib(GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { BEFORE_GL_CALL; mSymbols.fGetActiveAttrib(program, index, maxLength, length, size, type, name); AFTER_GL_CALL; } void fGetActiveUniform(GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name) { BEFORE_GL_CALL; mSymbols.fGetActiveUniform(program, index, maxLength, length, size, type, name); AFTER_GL_CALL; } void fGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) { BEFORE_GL_CALL; mSymbols.fGetAttachedShaders(program, maxCount, count, shaders); AFTER_GL_CALL; } GLint fGetAttribLocation(GLuint program, const GLchar* name) { BEFORE_GL_CALL; GLint retval = mSymbols.fGetAttribLocation(program, name); AFTER_GL_CALL; return retval; } private: void raw_fGetIntegerv(GLenum pname, GLint* params) { BEFORE_GL_CALL; mSymbols.fGetIntegerv(pname, params); AFTER_GL_CALL; } public: void fGetIntegerv(GLenum pname, GLint* params); void GetUIntegerv(GLenum pname, GLuint* params) { fGetIntegerv(pname, reinterpret_cast<GLint*>(params)); } template<typename T> T GetIntAs(GLenum pname) { static_assert(sizeof(T) == sizeof(GLint), "Invalid T."); T ret = 0; fGetIntegerv(pname, (GLint*)&ret); return ret; } void fGetFloatv(GLenum pname, GLfloat* params) { BEFORE_GL_CALL; mSymbols.fGetFloatv(pname, params); AFTER_GL_CALL; } void fGetBooleanv(GLenum pname, realGLboolean* params) { BEFORE_GL_CALL; mSymbols.fGetBooleanv(pname, params); AFTER_GL_CALL; } void fGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) { BEFORE_GL_CALL; mSymbols.fGetBufferParameteriv(target, pname, params); AFTER_GL_CALL; } GLuint fGetDebugMessageLog(GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetDebugMessageLog); GLuint ret = mSymbols.fGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog); AFTER_GL_CALL; return ret; } void fGetPointerv(GLenum pname, GLvoid** params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetPointerv); mSymbols.fGetPointerv(pname, params); AFTER_GL_CALL; } void fGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetObjectLabel); mSymbols.fGetObjectLabel(identifier, name, bufSize, length, label); AFTER_GL_CALL; } void fGetObjectPtrLabel(const GLvoid* ptr, GLsizei bufSize, GLsizei* length, GLchar* label) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetObjectPtrLabel); mSymbols.fGetObjectPtrLabel(ptr, bufSize, length, label); AFTER_GL_CALL; } void fGenerateMipmap(GLenum target) { BEFORE_GL_CALL; mSymbols.fGenerateMipmap(target); AFTER_GL_CALL; } void fGetProgramiv(GLuint program, GLenum pname, GLint* param) { BEFORE_GL_CALL; mSymbols.fGetProgramiv(program, pname, param); AFTER_GL_CALL; } void fGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { BEFORE_GL_CALL; mSymbols.fGetProgramInfoLog(program, bufSize, length, infoLog); AFTER_GL_CALL; } void fTexParameteri(GLenum target, GLenum pname, GLint param) { BEFORE_GL_CALL; mSymbols.fTexParameteri(target, pname, param); AFTER_GL_CALL; } void fTexParameteriv(GLenum target, GLenum pname, const GLint* params) { BEFORE_GL_CALL; mSymbols.fTexParameteriv(target, pname, params); AFTER_GL_CALL; } void fTexParameterf(GLenum target, GLenum pname, GLfloat param) { BEFORE_GL_CALL; mSymbols.fTexParameterf(target, pname, param); AFTER_GL_CALL; } const GLubyte* fGetString(GLenum name) { BEFORE_GL_CALL; const GLubyte* result = mSymbols.fGetString(name); AFTER_GL_CALL; return result; } void fGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* img) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetTexImage); mSymbols.fGetTexImage(target, level, format, type, img); AFTER_GL_CALL; } void fGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetTexLevelParameteriv); mSymbols.fGetTexLevelParameteriv(target, level, pname, params); AFTER_GL_CALL; } void fGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) { BEFORE_GL_CALL; mSymbols.fGetTexParameterfv(target, pname, params); AFTER_GL_CALL; } void fGetTexParameteriv(GLenum target, GLenum pname, GLint* params) { BEFORE_GL_CALL; mSymbols.fGetTexParameteriv(target, pname, params); AFTER_GL_CALL; } void fGetUniformfv(GLuint program, GLint location, GLfloat* params) { BEFORE_GL_CALL; mSymbols.fGetUniformfv(program, location, params); AFTER_GL_CALL; } void fGetUniformiv(GLuint program, GLint location, GLint* params) { BEFORE_GL_CALL; mSymbols.fGetUniformiv(program, location, params); AFTER_GL_CALL; } void fGetUniformuiv(GLuint program, GLint location, GLuint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetUniformuiv); mSymbols.fGetUniformuiv(program, location, params); AFTER_GL_CALL; } GLint fGetUniformLocation (GLint programObj, const GLchar* name) { BEFORE_GL_CALL; GLint retval = mSymbols.fGetUniformLocation(programObj, name); AFTER_GL_CALL; return retval; } void fGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* retval) { BEFORE_GL_CALL; mSymbols.fGetVertexAttribfv(index, pname, retval); AFTER_GL_CALL; } void fGetVertexAttribiv(GLuint index, GLenum pname, GLint* retval) { BEFORE_GL_CALL; mSymbols.fGetVertexAttribiv(index, pname, retval); AFTER_GL_CALL; } void fGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** retval) { BEFORE_GL_CALL; mSymbols.fGetVertexAttribPointerv(index, pname, retval); AFTER_GL_CALL; } void fHint(GLenum target, GLenum mode) { BEFORE_GL_CALL; mSymbols.fHint(target, mode); AFTER_GL_CALL; } realGLboolean fIsBuffer(GLuint buffer) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsBuffer(buffer); AFTER_GL_CALL; return retval; } realGLboolean fIsEnabled(GLenum capability) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsEnabled(capability); AFTER_GL_CALL; return retval; } realGLboolean fIsProgram(GLuint program) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsProgram(program); AFTER_GL_CALL; return retval; } realGLboolean fIsShader(GLuint shader) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsShader(shader); AFTER_GL_CALL; return retval; } realGLboolean fIsTexture(GLuint texture) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsTexture(texture); AFTER_GL_CALL; return retval; } void fLineWidth(GLfloat width) { BEFORE_GL_CALL; mSymbols.fLineWidth(width); AFTER_GL_CALL; } void fLinkProgram(GLuint program) { BEFORE_GL_CALL; mSymbols.fLinkProgram(program); AFTER_GL_CALL; } void fObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar* label) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fObjectLabel); mSymbols.fObjectLabel(identifier, name, length, label); AFTER_GL_CALL; } void fObjectPtrLabel(const GLvoid* ptr, GLsizei length, const GLchar* label) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fObjectPtrLabel); mSymbols.fObjectPtrLabel(ptr, length, label); AFTER_GL_CALL; } void fLoadIdentity() { BEFORE_GL_CALL; mSymbols.fLoadIdentity(); AFTER_GL_CALL; } void fLoadMatrixf(const GLfloat* matrix) { BEFORE_GL_CALL; mSymbols.fLoadMatrixf(matrix); AFTER_GL_CALL; } void fMatrixMode(GLenum mode) { BEFORE_GL_CALL; mSymbols.fMatrixMode(mode); AFTER_GL_CALL; } void fPixelStorei(GLenum pname, GLint param) { BEFORE_GL_CALL; mSymbols.fPixelStorei(pname, param); AFTER_GL_CALL; } void fTextureRangeAPPLE(GLenum target, GLsizei length, GLvoid* pointer) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pointer); BEFORE_GL_CALL; mSymbols.fTextureRangeAPPLE(target, length, pointer); AFTER_GL_CALL; } void fPointParameterf(GLenum pname, GLfloat param) { BEFORE_GL_CALL; mSymbols.fPointParameterf(pname, param); AFTER_GL_CALL; } void fPolygonOffset(GLfloat factor, GLfloat bias) { BEFORE_GL_CALL; mSymbols.fPolygonOffset(factor, bias); AFTER_GL_CALL; } void fPopDebugGroup() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fPopDebugGroup); mSymbols.fPopDebugGroup(); AFTER_GL_CALL; } void fPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fPushDebugGroup); mSymbols.fPushDebugGroup(source, id, length, message); AFTER_GL_CALL; } void fReadBuffer(GLenum mode) { BEFORE_GL_CALL; mSymbols.fReadBuffer(mode); AFTER_GL_CALL; } void raw_fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels); BEFORE_GL_CALL; mSymbols.fReadPixels(x, y, width, height, format, type, pixels); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } void fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); public: void fSampleCoverage(GLclampf value, realGLboolean invert) { BEFORE_GL_CALL; mSymbols.fSampleCoverage(value, invert); AFTER_GL_CALL; } void fScissor(GLint x, GLint y, GLsizei width, GLsizei height) { if (mScissorRect[0] == x && mScissorRect[1] == y && mScissorRect[2] == width && mScissorRect[3] == height) { return; } mScissorRect[0] = x; mScissorRect[1] = y; mScissorRect[2] = width; mScissorRect[3] = height; BEFORE_GL_CALL; mSymbols.fScissor(x, y, width, height); AFTER_GL_CALL; } void fStencilFunc(GLenum func, GLint reference, GLuint mask) { BEFORE_GL_CALL; mSymbols.fStencilFunc(func, reference, mask); AFTER_GL_CALL; } void fStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint reference, GLuint mask) { BEFORE_GL_CALL; mSymbols.fStencilFuncSeparate(frontfunc, backfunc, reference, mask); AFTER_GL_CALL; } void fStencilMask(GLuint mask) { BEFORE_GL_CALL; mSymbols.fStencilMask(mask); AFTER_GL_CALL; } void fStencilMaskSeparate(GLenum face, GLuint mask) { BEFORE_GL_CALL; mSymbols.fStencilMaskSeparate(face, mask); AFTER_GL_CALL; } void fStencilOp(GLenum fail, GLenum zfail, GLenum zpass) { BEFORE_GL_CALL; mSymbols.fStencilOp(fail, zfail, zpass); AFTER_GL_CALL; } void fStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) { BEFORE_GL_CALL; mSymbols.fStencilOpSeparate(face, sfail, dpfail, dppass); AFTER_GL_CALL; } void fTexGeni(GLenum coord, GLenum pname, GLint param) { BEFORE_GL_CALL; mSymbols.fTexGeni(coord, pname, param); AFTER_GL_CALL; } void fTexGenf(GLenum coord, GLenum pname, GLfloat param) { BEFORE_GL_CALL; mSymbols.fTexGenf(coord, pname, param); AFTER_GL_CALL; } void fTexGenfv(GLenum coord, GLenum pname, const GLfloat* params) { BEFORE_GL_CALL; mSymbols.fTexGenfv(coord, pname, params); AFTER_GL_CALL; } private: void raw_fTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels); BEFORE_GL_CALL; mSymbols.fTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } public: void fTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels); void fTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) { ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels); BEFORE_GL_CALL; mSymbols.fTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } void fUniform1f(GLint location, GLfloat v0) { BEFORE_GL_CALL; mSymbols.fUniform1f(location, v0); AFTER_GL_CALL; } void fUniform1fv(GLint location, GLsizei count, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniform1fv(location, count, value); AFTER_GL_CALL; } void fUniform1i(GLint location, GLint v0) { BEFORE_GL_CALL; mSymbols.fUniform1i(location, v0); AFTER_GL_CALL; } void fUniform1iv(GLint location, GLsizei count, const GLint* value) { BEFORE_GL_CALL; mSymbols.fUniform1iv(location, count, value); AFTER_GL_CALL; } void fUniform2f(GLint location, GLfloat v0, GLfloat v1) { BEFORE_GL_CALL; mSymbols.fUniform2f(location, v0, v1); AFTER_GL_CALL; } void fUniform2fv(GLint location, GLsizei count, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniform2fv(location, count, value); AFTER_GL_CALL; } void fUniform2i(GLint location, GLint v0, GLint v1) { BEFORE_GL_CALL; mSymbols.fUniform2i(location, v0, v1); AFTER_GL_CALL; } void fUniform2iv(GLint location, GLsizei count, const GLint* value) { BEFORE_GL_CALL; mSymbols.fUniform2iv(location, count, value); AFTER_GL_CALL; } void fUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) { BEFORE_GL_CALL; mSymbols.fUniform3f(location, v0, v1, v2); AFTER_GL_CALL; } void fUniform3fv(GLint location, GLsizei count, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniform3fv(location, count, value); AFTER_GL_CALL; } void fUniform3i(GLint location, GLint v0, GLint v1, GLint v2) { BEFORE_GL_CALL; mSymbols.fUniform3i(location, v0, v1, v2); AFTER_GL_CALL; } void fUniform3iv(GLint location, GLsizei count, const GLint* value) { BEFORE_GL_CALL; mSymbols.fUniform3iv(location, count, value); AFTER_GL_CALL; } void fUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) { BEFORE_GL_CALL; mSymbols.fUniform4f(location, v0, v1, v2, v3); AFTER_GL_CALL; } void fUniform4fv(GLint location, GLsizei count, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniform4fv(location, count, value); AFTER_GL_CALL; } void fUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) { BEFORE_GL_CALL; mSymbols.fUniform4i(location, v0, v1, v2, v3); AFTER_GL_CALL; } void fUniform4iv(GLint location, GLsizei count, const GLint* value) { BEFORE_GL_CALL; mSymbols.fUniform4iv(location, count, value); AFTER_GL_CALL; } void fUniformMatrix2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniformMatrix2fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix2x3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix2x3fv); mSymbols.fUniformMatrix2x3fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix2x4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix2x4fv); mSymbols.fUniformMatrix2x4fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniformMatrix3fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix3x2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix3x2fv); mSymbols.fUniformMatrix3x2fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix3x4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix3x4fv); mSymbols.fUniformMatrix3x4fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; mSymbols.fUniformMatrix4fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix4x2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix4x2fv); mSymbols.fUniformMatrix4x2fv(location, count, transpose, value); AFTER_GL_CALL; } void fUniformMatrix4x3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniformMatrix4x3fv); mSymbols.fUniformMatrix4x3fv(location, count, transpose, value); AFTER_GL_CALL; } void fUseProgram(GLuint program) { BEFORE_GL_CALL; mSymbols.fUseProgram(program); AFTER_GL_CALL; } void fValidateProgram(GLuint program) { BEFORE_GL_CALL; mSymbols.fValidateProgram(program); AFTER_GL_CALL; } void fVertexAttribPointer(GLuint index, GLint size, GLenum type, realGLboolean normalized, GLsizei stride, const GLvoid* pointer) { BEFORE_GL_CALL; mSymbols.fVertexAttribPointer(index, size, type, normalized, stride, pointer); AFTER_GL_CALL; } void fVertexAttrib1f(GLuint index, GLfloat x) { BEFORE_GL_CALL; mSymbols.fVertexAttrib1f(index, x); AFTER_GL_CALL; } void fVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) { BEFORE_GL_CALL; mSymbols.fVertexAttrib2f(index, x, y); AFTER_GL_CALL; } void fVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) { BEFORE_GL_CALL; mSymbols.fVertexAttrib3f(index, x, y, z); AFTER_GL_CALL; } void fVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { BEFORE_GL_CALL; mSymbols.fVertexAttrib4f(index, x, y, z, w); AFTER_GL_CALL; } void fVertexAttrib1fv(GLuint index, const GLfloat* v) { BEFORE_GL_CALL; mSymbols.fVertexAttrib1fv(index, v); AFTER_GL_CALL; } void fVertexAttrib2fv(GLuint index, const GLfloat* v) { BEFORE_GL_CALL; mSymbols.fVertexAttrib2fv(index, v); AFTER_GL_CALL; } void fVertexAttrib3fv(GLuint index, const GLfloat* v) { BEFORE_GL_CALL; mSymbols.fVertexAttrib3fv(index, v); AFTER_GL_CALL; } void fVertexAttrib4fv(GLuint index, const GLfloat* v) { BEFORE_GL_CALL; mSymbols.fVertexAttrib4fv(index, v); AFTER_GL_CALL; } void fVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) { BEFORE_GL_CALL; mSymbols.fVertexPointer(size, type, stride, pointer); AFTER_GL_CALL; } void fCompileShader(GLuint shader) { BEFORE_GL_CALL; mSymbols.fCompileShader(shader); AFTER_GL_CALL; } private: friend class SharedSurface_IOSurface; void raw_fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) { BEFORE_GL_CALL; mSymbols.fCopyTexImage2D(target, level, internalformat, x, y, width, height, border); AFTER_GL_CALL; } void raw_fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) { BEFORE_GL_CALL; mSymbols.fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); AFTER_GL_CALL; } public: void fGetShaderiv(GLuint shader, GLenum pname, GLint* param) { BEFORE_GL_CALL; mSymbols.fGetShaderiv(shader, pname, param); AFTER_GL_CALL; } void fGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { BEFORE_GL_CALL; mSymbols.fGetShaderInfoLog(shader, bufSize, length, infoLog); AFTER_GL_CALL; } private: void raw_fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { MOZ_ASSERT(IsGLES()); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetShaderPrecisionFormat); mSymbols.fGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); AFTER_GL_CALL; } public: void fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { if (IsGLES()) { raw_fGetShaderPrecisionFormat(shadertype, precisiontype, range, precision); } else { // Fall back to automatic values because almost all desktop hardware supports the OpenGL standard precisions. GetShaderPrecisionFormatNonES2(shadertype, precisiontype, range, precision); } } void fGetShaderSource(GLint obj, GLsizei maxLength, GLsizei* length, GLchar* source) { BEFORE_GL_CALL; mSymbols.fGetShaderSource(obj, maxLength, length, source); AFTER_GL_CALL; } void fShaderSource(GLuint shader, GLsizei count, const GLchar* const* strings, const GLint* lengths) { BEFORE_GL_CALL; mSymbols.fShaderSource(shader, count, strings, lengths); AFTER_GL_CALL; } private: friend class SharedSurface; void raw_fBindFramebuffer(GLenum target, GLuint framebuffer) { BEFORE_GL_CALL; mSymbols.fBindFramebuffer(target, framebuffer); AFTER_GL_CALL; } public: void fBindRenderbuffer(GLenum target, GLuint renderbuffer) { BEFORE_GL_CALL; mSymbols.fBindRenderbuffer(target, renderbuffer); AFTER_GL_CALL; } GLenum fCheckFramebufferStatus(GLenum target) { BEFORE_GL_CALL; GLenum retval = mSymbols.fCheckFramebufferStatus(target); AFTER_GL_CALL; return retval; } void fFramebufferRenderbuffer(GLenum target, GLenum attachmentPoint, GLenum renderbufferTarget, GLuint renderbuffer) { BEFORE_GL_CALL; mSymbols.fFramebufferRenderbuffer(target, attachmentPoint, renderbufferTarget, renderbuffer); AFTER_GL_CALL; } void fFramebufferTexture2D(GLenum target, GLenum attachmentPoint, GLenum textureTarget, GLuint texture, GLint level) { BEFORE_GL_CALL; mSymbols.fFramebufferTexture2D(target, attachmentPoint, textureTarget, texture, level); AFTER_GL_CALL; if (mNeedsCheckAfterAttachTextureToFb) { fCheckFramebufferStatus(target); } } void fFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fFramebufferTextureLayer); mSymbols.fFramebufferTextureLayer(target, attachment, texture, level, layer); AFTER_GL_CALL; } void fGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* value) { BEFORE_GL_CALL; mSymbols.fGetFramebufferAttachmentParameteriv(target, attachment, pname, value); AFTER_GL_CALL; } void fGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* value) { BEFORE_GL_CALL; mSymbols.fGetRenderbufferParameteriv(target, pname, value); AFTER_GL_CALL; } realGLboolean fIsFramebuffer (GLuint framebuffer) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsFramebuffer(framebuffer); AFTER_GL_CALL; return retval; } public: realGLboolean fIsRenderbuffer (GLuint renderbuffer) { BEFORE_GL_CALL; realGLboolean retval = mSymbols.fIsRenderbuffer(renderbuffer); AFTER_GL_CALL; return retval; } void fRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) { BEFORE_GL_CALL; mSymbols.fRenderbufferStorage(target, internalFormat, width, height); AFTER_GL_CALL; } private: void raw_fDepthRange(GLclampf a, GLclampf b) { MOZ_ASSERT(!IsGLES()); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDepthRange); mSymbols.fDepthRange(a, b); AFTER_GL_CALL; } void raw_fDepthRangef(GLclampf a, GLclampf b) { MOZ_ASSERT(IsGLES()); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDepthRangef); mSymbols.fDepthRangef(a, b); AFTER_GL_CALL; } void raw_fClearDepth(GLclampf v) { MOZ_ASSERT(!IsGLES()); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fClearDepth); mSymbols.fClearDepth(v); AFTER_GL_CALL; } void raw_fClearDepthf(GLclampf v) { MOZ_ASSERT(IsGLES()); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fClearDepthf); mSymbols.fClearDepthf(v); AFTER_GL_CALL; } public: void fDepthRange(GLclampf a, GLclampf b) { if (IsGLES()) { raw_fDepthRangef(a, b); } else { raw_fDepthRange(a, b); } } void fClearDepth(GLclampf v) { if (IsGLES()) { raw_fClearDepthf(v); } else { raw_fClearDepth(v); } } void* fMapBuffer(GLenum target, GLenum access) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fMapBuffer); void* ret = mSymbols.fMapBuffer(target, access); AFTER_GL_CALL; return ret; } realGLboolean fUnmapBuffer(GLenum target) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUnmapBuffer); realGLboolean ret = mSymbols.fUnmapBuffer(target); AFTER_GL_CALL; return ret; } private: GLuint raw_fCreateProgram() { BEFORE_GL_CALL; GLuint ret = mSymbols.fCreateProgram(); AFTER_GL_CALL; return ret; } GLuint raw_fCreateShader(GLenum t) { BEFORE_GL_CALL; GLuint ret = mSymbols.fCreateShader(t); AFTER_GL_CALL; return ret; } void raw_fGenBuffers(GLsizei n, GLuint* names) { BEFORE_GL_CALL; mSymbols.fGenBuffers(n, names); AFTER_GL_CALL; } void raw_fGenFramebuffers(GLsizei n, GLuint* names) { BEFORE_GL_CALL; mSymbols.fGenFramebuffers(n, names); AFTER_GL_CALL; } void raw_fGenRenderbuffers(GLsizei n, GLuint* names) { BEFORE_GL_CALL; mSymbols.fGenRenderbuffers(n, names); AFTER_GL_CALL; } void raw_fGenTextures(GLsizei n, GLuint* names) { BEFORE_GL_CALL; mSymbols.fGenTextures(n, names); AFTER_GL_CALL; } public: GLuint fCreateProgram() { GLuint ret = raw_fCreateProgram(); TRACKING_CONTEXT(CreatedProgram(this, ret)); return ret; } GLuint fCreateShader(GLenum t) { GLuint ret = raw_fCreateShader(t); TRACKING_CONTEXT(CreatedShader(this, ret)); return ret; } void fGenBuffers(GLsizei n, GLuint* names) { raw_fGenBuffers(n, names); TRACKING_CONTEXT(CreatedBuffers(this, n, names)); } void fGenFramebuffers(GLsizei n, GLuint* names) { raw_fGenFramebuffers(n, names); TRACKING_CONTEXT(CreatedFramebuffers(this, n, names)); } void fGenRenderbuffers(GLsizei n, GLuint* names) { raw_fGenRenderbuffers(n, names); TRACKING_CONTEXT(CreatedRenderbuffers(this, n, names)); } void fGenTextures(GLsizei n, GLuint* names) { raw_fGenTextures(n, names); TRACKING_CONTEXT(CreatedTextures(this, n, names)); } private: void raw_fDeleteProgram(GLuint program) { BEFORE_GL_CALL; mSymbols.fDeleteProgram(program); AFTER_GL_CALL; } void raw_fDeleteShader(GLuint shader) { BEFORE_GL_CALL; mSymbols.fDeleteShader(shader); AFTER_GL_CALL; } void raw_fDeleteBuffers(GLsizei n, const GLuint* names) { BEFORE_GL_CALL; mSymbols.fDeleteBuffers(n, names); AFTER_GL_CALL; } void raw_fDeleteFramebuffers(GLsizei n, const GLuint* names) { BEFORE_GL_CALL; mSymbols.fDeleteFramebuffers(n, names); AFTER_GL_CALL; } void raw_fDeleteRenderbuffers(GLsizei n, const GLuint* names) { BEFORE_GL_CALL; mSymbols.fDeleteRenderbuffers(n, names); AFTER_GL_CALL; } void raw_fDeleteTextures(GLsizei n, const GLuint* names) { BEFORE_GL_CALL; mSymbols.fDeleteTextures(n, names); AFTER_GL_CALL; } public: void fDeleteProgram(GLuint program) { raw_fDeleteProgram(program); TRACKING_CONTEXT(DeletedProgram(this, program)); } void fDeleteShader(GLuint shader) { raw_fDeleteShader(shader); TRACKING_CONTEXT(DeletedShader(this, shader)); } void fDeleteBuffers(GLsizei n, const GLuint* names) { raw_fDeleteBuffers(n, names); TRACKING_CONTEXT(DeletedBuffers(this, n, names)); } void fDeleteFramebuffers(GLsizei n, const GLuint* names); void fDeleteRenderbuffers(GLsizei n, const GLuint* names) { raw_fDeleteRenderbuffers(n, names); TRACKING_CONTEXT(DeletedRenderbuffers(this, n, names)); } void fDeleteTextures(GLsizei n, const GLuint* names) { raw_fDeleteTextures(n, names); TRACKING_CONTEXT(DeletedTextures(this, n, names)); } GLenum fGetGraphicsResetStatus() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetGraphicsResetStatus); GLenum ret = mSymbols.fGetGraphicsResetStatus(); AFTER_GL_CALL; return ret; } // ----------------------------------------------------------------------------- // Extension ARB_sync (GL) public: GLsync fFenceSync(GLenum condition, GLbitfield flags) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fFenceSync); GLsync ret = mSymbols.fFenceSync(condition, flags); AFTER_GL_CALL; return ret; } realGLboolean fIsSync(GLsync sync) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fIsSync); realGLboolean ret = mSymbols.fIsSync(sync); AFTER_GL_CALL; return ret; } void fDeleteSync(GLsync sync) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDeleteSync); mSymbols.fDeleteSync(sync); AFTER_GL_CALL; } GLenum fClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fClientWaitSync); GLenum ret = mSymbols.fClientWaitSync(sync, flags, timeout); AFTER_GL_CALL; return ret; } void fWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fWaitSync); mSymbols.fWaitSync(sync, flags, timeout); AFTER_GL_CALL; } void fGetInteger64v(GLenum pname, GLint64* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetInteger64v); mSymbols.fGetInteger64v(pname, params); AFTER_GL_CALL; } void fGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetSynciv); mSymbols.fGetSynciv(sync, pname, bufSize, length, values); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Extension OES_EGL_image (GLES) public: void fEGLImageTargetTexture2D(GLenum target, GLeglImage image) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fEGLImageTargetTexture2D); mSymbols.fEGLImageTargetTexture2D(target, image); AFTER_GL_CALL; mHeavyGLCallsSinceLastFlush = true; } void fEGLImageTargetRenderbufferStorage(GLenum target, GLeglImage image) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fEGLImageTargetRenderbufferStorage); mSymbols.fEGLImageTargetRenderbufferStorage(target, image); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_bind_buffer_offset public: void fBindBufferOffset(GLenum target, GLuint index, GLuint buffer, GLintptr offset) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindBufferOffset); mSymbols.fBindBufferOffset(target, index, buffer, offset); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_draw_buffers public: void fDrawBuffers(GLsizei n, const GLenum* bufs) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDrawBuffers); mSymbols.fDrawBuffers(n, bufs); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_draw_instanced public: void fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount) { BeforeGLDrawCall(); raw_fDrawArraysInstanced(mode, first, count, primcount); AfterGLDrawCall(); } void fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount) { BeforeGLDrawCall(); raw_fDrawElementsInstanced(mode, count, type, indices, primcount); AfterGLDrawCall(); } private: void raw_fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDrawArraysInstanced); mSymbols.fDrawArraysInstanced(mode, first, count, primcount); AFTER_GL_CALL; } void raw_fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDrawElementsInstanced); mSymbols.fDrawElementsInstanced(mode, count, type, indices, primcount); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Feature draw_range_elements public: void fDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) { BeforeGLDrawCall(); raw_fDrawRangeElements(mode, start, end, count, type, indices); AfterGLDrawCall(); } private: void raw_fDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid* indices) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDrawRangeElements); mSymbols.fDrawRangeElements(mode, start, end, count, type, indices); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_framebuffer_blit public: // Draw/Read void fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { BeforeGLDrawCall(); BeforeGLReadCall(); raw_fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); AfterGLReadCall(); AfterGLDrawCall(); } private: void raw_fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBlitFramebuffer); mSymbols.fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_framebuffer_multisample public: void fRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fRenderbufferStorageMultisample); mSymbols.fRenderbufferStorageMultisample(target, samples, internalFormat, width, height); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // GL 3.0, GL ES 3.0 & EXT_gpu_shader4 public: void fGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params) { ASSERT_SYMBOL_PRESENT(fGetVertexAttribIiv); BEFORE_GL_CALL; mSymbols.fGetVertexAttribIiv(index, pname, params); AFTER_GL_CALL; } void fGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params) { ASSERT_SYMBOL_PRESENT(fGetVertexAttribIuiv); BEFORE_GL_CALL; mSymbols.fGetVertexAttribIuiv(index, pname, params); AFTER_GL_CALL; } void fVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribI4i); mSymbols.fVertexAttribI4i(index, x, y, z, w); AFTER_GL_CALL; } void fVertexAttribI4iv(GLuint index, const GLint* v) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribI4iv); mSymbols.fVertexAttribI4iv(index, v); AFTER_GL_CALL; } void fVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribI4ui); mSymbols.fVertexAttribI4ui(index, x, y, z, w); AFTER_GL_CALL; } void fVertexAttribI4uiv(GLuint index, const GLuint* v) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribI4uiv); mSymbols.fVertexAttribI4uiv(index, v); AFTER_GL_CALL; } void fVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* offset) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribIPointer); mSymbols.fVertexAttribIPointer(index, size, type, stride, offset); AFTER_GL_CALL; } void fUniform1ui(GLint location, GLuint v0) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform1ui); mSymbols.fUniform1ui(location, v0); AFTER_GL_CALL; } void fUniform2ui(GLint location, GLuint v0, GLuint v1) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform2ui); mSymbols.fUniform2ui(location, v0, v1); AFTER_GL_CALL; } void fUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform3ui); mSymbols.fUniform3ui(location, v0, v1, v2); AFTER_GL_CALL; } void fUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform4ui); mSymbols.fUniform4ui(location, v0, v1, v2, v3); AFTER_GL_CALL; } void fUniform1uiv(GLint location, GLsizei count, const GLuint* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform1uiv); mSymbols.fUniform1uiv(location, count, value); AFTER_GL_CALL; } void fUniform2uiv(GLint location, GLsizei count, const GLuint* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform2uiv); mSymbols.fUniform2uiv(location, count, value); AFTER_GL_CALL; } void fUniform3uiv(GLint location, GLsizei count, const GLuint* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform3uiv); mSymbols.fUniform3uiv(location, count, value); AFTER_GL_CALL; } void fUniform4uiv(GLint location, GLsizei count, const GLuint* value) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fUniform4uiv); mSymbols.fUniform4uiv(location, count, value); AFTER_GL_CALL; } GLint fGetFragDataLocation(GLuint program, const GLchar* name) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetFragDataLocation); GLint result = mSymbols.fGetFragDataLocation(program, name); AFTER_GL_CALL; return result; } // ----------------------------------------------------------------------------- // Package XXX_instanced_arrays public: void fVertexAttribDivisor(GLuint index, GLuint divisor) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fVertexAttribDivisor); mSymbols.fVertexAttribDivisor(index, divisor); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Feature internalformat_query public: void fGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetInternalformativ); mSymbols.fGetInternalformativ(target, internalformat, pname, bufSize, params); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_query_counter /** * XXX_query_counter: * - depends on XXX_query_objects * - provide all followed entry points * - provide GL_TIMESTAMP */ public: void fQueryCounter(GLuint id, GLenum target) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fQueryCounter); mSymbols.fQueryCounter(id, target); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_query_objects /** * XXX_query_objects: * - provide all followed entry points * * XXX_occlusion_query2: * - depends on XXX_query_objects * - provide ANY_SAMPLES_PASSED * * XXX_occlusion_query_boolean: * - depends on XXX_occlusion_query2 * - provide ANY_SAMPLES_PASSED_CONSERVATIVE */ public: void fDeleteQueries(GLsizei n, const GLuint* names) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDeleteQueries); mSymbols.fDeleteQueries(n, names); AFTER_GL_CALL; TRACKING_CONTEXT(DeletedQueries(this, n, names)); } void fGenQueries(GLsizei n, GLuint* names) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGenQueries); mSymbols.fGenQueries(n, names); AFTER_GL_CALL; TRACKING_CONTEXT(CreatedQueries(this, n, names)); } void fGetQueryiv(GLenum target, GLenum pname, GLint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetQueryiv); mSymbols.fGetQueryiv(target, pname, params); AFTER_GL_CALL; } void fGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetQueryObjectuiv); mSymbols.fGetQueryObjectuiv(id, pname, params); AFTER_GL_CALL; } realGLboolean fIsQuery(GLuint query) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fIsQuery); realGLboolean retval = mSymbols.fIsQuery(query); AFTER_GL_CALL; return retval; } // ----------------------------------------------------------------------------- // Package XXX_get_query_object_i64v /** * XXX_get_query_object_i64v: * - depends on XXX_query_objects * - provide the followed entry point */ public: void fGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetQueryObjecti64v); mSymbols.fGetQueryObjecti64v(id, pname, params); AFTER_GL_CALL; } void fGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetQueryObjectui64v); mSymbols.fGetQueryObjectui64v(id, pname, params); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_get_query_object_iv /** * XXX_get_query_object_iv: * - depends on XXX_query_objects * - provide the followed entry point * * XXX_occlusion_query: * - depends on XXX_get_query_object_iv * - provide LOCAL_GL_SAMPLES_PASSED */ public: void fGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetQueryObjectiv); mSymbols.fGetQueryObjectiv(id, pname, params); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // GL 4.0, GL ES 3.0, ARB_transform_feedback2, NV_transform_feedback2 public: void fBindBufferBase(GLenum target, GLuint index, GLuint buffer) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindBufferBase); mSymbols.fBindBufferBase(target, index, buffer); AFTER_GL_CALL; } void fBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindBufferRange); mSymbols.fBindBufferRange(target, index, buffer, offset, size); AFTER_GL_CALL; } void fGenTransformFeedbacks(GLsizei n, GLuint* ids) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGenTransformFeedbacks); mSymbols.fGenTransformFeedbacks(n, ids); AFTER_GL_CALL; } void fDeleteTransformFeedbacks(GLsizei n, const GLuint* ids) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDeleteTransformFeedbacks); mSymbols.fDeleteTransformFeedbacks(n, ids); AFTER_GL_CALL; } realGLboolean fIsTransformFeedback(GLuint id) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fIsTransformFeedback); realGLboolean result = mSymbols.fIsTransformFeedback(id); AFTER_GL_CALL; return result; } void fBindTransformFeedback(GLenum target, GLuint id) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindTransformFeedback); mSymbols.fBindTransformFeedback(target, id); AFTER_GL_CALL; } void fBeginTransformFeedback(GLenum primitiveMode) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBeginTransformFeedback); mSymbols.fBeginTransformFeedback(primitiveMode); AFTER_GL_CALL; } void fEndTransformFeedback() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fEndTransformFeedback); mSymbols.fEndTransformFeedback(); AFTER_GL_CALL; } void fTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fTransformFeedbackVaryings); mSymbols.fTransformFeedbackVaryings(program, count, varyings, bufferMode); AFTER_GL_CALL; } void fGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetTransformFeedbackVarying); mSymbols.fGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name); AFTER_GL_CALL; } void fPauseTransformFeedback() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fPauseTransformFeedback); mSymbols.fPauseTransformFeedback(); AFTER_GL_CALL; } void fResumeTransformFeedback() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fResumeTransformFeedback); mSymbols.fResumeTransformFeedback(); AFTER_GL_CALL; } void fGetIntegeri_v(GLenum param, GLuint index, GLint* values) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetIntegeri_v); mSymbols.fGetIntegeri_v(param, index, values); AFTER_GL_CALL; } void fGetInteger64i_v(GLenum target, GLuint index, GLint64* data) { ASSERT_SYMBOL_PRESENT(fGetInteger64i_v); BEFORE_GL_CALL; mSymbols.fGetInteger64i_v(target, index, data); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Package XXX_vertex_array_object public: void fBindVertexArray(GLuint array) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindVertexArray); mSymbols.fBindVertexArray(array); AFTER_GL_CALL; } void fDeleteVertexArrays(GLsizei n, const GLuint* arrays) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDeleteVertexArrays); mSymbols.fDeleteVertexArrays(n, arrays); AFTER_GL_CALL; } void fGenVertexArrays(GLsizei n, GLuint* arrays) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGenVertexArrays); mSymbols.fGenVertexArrays(n, arrays); AFTER_GL_CALL; } realGLboolean fIsVertexArray(GLuint array) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fIsVertexArray); realGLboolean ret = mSymbols.fIsVertexArray(array); AFTER_GL_CALL; return ret; } // ----------------------------------------------------------------------------- // Extension NV_fence public: void fGenFences(GLsizei n, GLuint* fences) { ASSERT_SYMBOL_PRESENT(fGenFences); BEFORE_GL_CALL; mSymbols.fGenFences(n, fences); AFTER_GL_CALL; } void fDeleteFences(GLsizei n, const GLuint* fences) { ASSERT_SYMBOL_PRESENT(fDeleteFences); BEFORE_GL_CALL; mSymbols.fDeleteFences(n, fences); AFTER_GL_CALL; } void fSetFence(GLuint fence, GLenum condition) { ASSERT_SYMBOL_PRESENT(fSetFence); BEFORE_GL_CALL; mSymbols.fSetFence(fence, condition); AFTER_GL_CALL; } realGLboolean fTestFence(GLuint fence) { ASSERT_SYMBOL_PRESENT(fTestFence); BEFORE_GL_CALL; realGLboolean ret = mSymbols.fTestFence(fence); AFTER_GL_CALL; return ret; } void fFinishFence(GLuint fence) { ASSERT_SYMBOL_PRESENT(fFinishFence); BEFORE_GL_CALL; mSymbols.fFinishFence(fence); AFTER_GL_CALL; } realGLboolean fIsFence(GLuint fence) { ASSERT_SYMBOL_PRESENT(fIsFence); BEFORE_GL_CALL; realGLboolean ret = mSymbols.fIsFence(fence); AFTER_GL_CALL; return ret; } void fGetFenceiv(GLuint fence, GLenum pname, GLint* params) { ASSERT_SYMBOL_PRESENT(fGetFenceiv); BEFORE_GL_CALL; mSymbols.fGetFenceiv(fence, pname, params); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Extension NV_texture_barrier public: void fTextureBarrier() { ASSERT_SYMBOL_PRESENT(fTextureBarrier); BEFORE_GL_CALL; mSymbols.fTextureBarrier(); AFTER_GL_CALL; } // Core GL & Extension ARB_copy_buffer public: void fCopyBufferSubData(GLenum readtarget, GLenum writetarget, GLintptr readoffset, GLintptr writeoffset, GLsizeiptr size) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fCopyBufferSubData); mSymbols.fCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Core GL & Extension ARB_map_buffer_range public: void* fMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { ASSERT_SYMBOL_PRESENT(fMapBufferRange); BEFORE_GL_CALL; void* data = mSymbols.fMapBufferRange(target, offset, length, access); AFTER_GL_CALL; return data; } void fFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) { ASSERT_SYMBOL_PRESENT(fFlushMappedBufferRange); BEFORE_GL_CALL; mSymbols.fFlushMappedBufferRange(target, offset, length); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Core GL & Extension ARB_sampler_objects public: void fGenSamplers(GLsizei count, GLuint* samplers) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGenSamplers); mSymbols.fGenSamplers(count, samplers); AFTER_GL_CALL; } void fDeleteSamplers(GLsizei count, const GLuint* samplers) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fDeleteSamplers); mSymbols.fDeleteSamplers(count, samplers); AFTER_GL_CALL; } realGLboolean fIsSampler(GLuint sampler) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fIsSampler); realGLboolean result = mSymbols.fIsSampler(sampler); AFTER_GL_CALL; return result; } void fBindSampler(GLuint unit, GLuint sampler) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fBindSampler); mSymbols.fBindSampler(unit, sampler); AFTER_GL_CALL; } void fSamplerParameteri(GLuint sampler, GLenum pname, GLint param) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fSamplerParameteri); mSymbols.fSamplerParameteri(sampler, pname, param); AFTER_GL_CALL; } void fSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fSamplerParameteriv); mSymbols.fSamplerParameteriv(sampler, pname, param); AFTER_GL_CALL; } void fSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fSamplerParameterf); mSymbols.fSamplerParameterf(sampler, pname, param); AFTER_GL_CALL; } void fSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fSamplerParameterfv); mSymbols.fSamplerParameterfv(sampler, pname, param); AFTER_GL_CALL; } void fGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetSamplerParameteriv); mSymbols.fGetSamplerParameteriv(sampler, pname, params); AFTER_GL_CALL; } void fGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetSamplerParameterfv); mSymbols.fGetSamplerParameterfv(sampler, pname, params); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Core GL & Extension ARB_uniform_buffer_object public: void fGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const* uniformNames, GLuint* uniformIndices) { ASSERT_SYMBOL_PRESENT(fGetUniformIndices); BEFORE_GL_CALL; mSymbols.fGetUniformIndices(program, uniformCount, uniformNames, uniformIndices); AFTER_GL_CALL; } void fGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices, GLenum pname, GLint* params) { ASSERT_SYMBOL_PRESENT(fGetActiveUniformsiv); BEFORE_GL_CALL; mSymbols.fGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params); AFTER_GL_CALL; } GLuint fGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) { ASSERT_SYMBOL_PRESENT(fGetUniformBlockIndex); BEFORE_GL_CALL; GLuint result = mSymbols.fGetUniformBlockIndex(program, uniformBlockName); AFTER_GL_CALL; return result; } void fGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params) { ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockiv); BEFORE_GL_CALL; mSymbols.fGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params); AFTER_GL_CALL; } void fGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName) { ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockName); BEFORE_GL_CALL; mSymbols.fGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName); AFTER_GL_CALL; } void fUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) { ASSERT_SYMBOL_PRESENT(fUniformBlockBinding); BEFORE_GL_CALL; mSymbols.fUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Core GL 4.2, GL ES 3.0 & Extension ARB_texture_storage/EXT_texture_storage void fTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fTexStorage2D); mSymbols.fTexStorage2D(target, levels, internalformat, width, height); AFTER_GL_CALL; } void fTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fTexStorage3D); mSymbols.fTexStorage3D(target, levels, internalformat, width, height, depth); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // 3D Textures void fTexImage3D(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * data) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fTexImage3D); mSymbols.fTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, data); AFTER_GL_CALL; } void fTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid* pixels) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fTexSubImage3D); mSymbols.fTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); AFTER_GL_CALL; } void fCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) { BeforeGLReadCall(); BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fCopyTexSubImage3D); mSymbols.fCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height); AFTER_GL_CALL; AfterGLReadCall(); } void fCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid* data) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fCompressedTexImage3D); mSymbols.fCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data); AFTER_GL_CALL; } void fCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid* data) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fCompressedTexSubImage3D); mSymbols.fCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // get_string_indexed const GLubyte* fGetStringi(GLenum name, GLuint index) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fGetStringi); const GLubyte* ret = mSymbols.fGetStringi(name, index); AFTER_GL_CALL; return ret; } // ----------------------------------------------------------------------------- // APPLE_framebuffer_multisample void fResolveMultisampleFramebufferAPPLE() { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fResolveMultisampleFramebufferAPPLE); mSymbols.fResolveMultisampleFramebufferAPPLE(); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // prim_restart void fPrimitiveRestartIndex(GLuint index) { BEFORE_GL_CALL; ASSERT_SYMBOL_PRESENT(fPrimitiveRestartIndex); mSymbols.fPrimitiveRestartIndex(index); AFTER_GL_CALL; } // ----------------------------------------------------------------------------- // Constructor protected: explicit GLContext(CreateContextFlags flags, const SurfaceCaps& caps, GLContext* sharedContext = nullptr, bool isOffscreen = false); // ----------------------------------------------------------------------------- // Destructor public: virtual ~GLContext(); // Mark this context as destroyed. This will nullptr out all // the GL function pointers! void MarkDestroyed(); // ----------------------------------------------------------------------------- // Everything that isn't standard GL APIs protected: typedef gfx::SurfaceFormat SurfaceFormat; virtual bool MakeCurrentImpl(bool aForce) = 0; public: #ifdef MOZ_GL_DEBUG static void StaticInit() { PR_NewThreadPrivateIndex(&sCurrentGLContextTLS, nullptr); } #endif bool MakeCurrent(bool aForce = false) { if (IsDestroyed()) { return false; } #ifdef MOZ_GL_DEBUG PR_SetThreadPrivate(sCurrentGLContextTLS, this); // XXX this assertion is disabled because it's triggering on Mac; // we need to figure out why and reenable it. #if 0 // IsOwningThreadCurrent is a bit of a misnomer; // the "owning thread" is the creation thread, // and the only thread that can own this. We don't // support contexts used on multiple threads. NS_ASSERTION(IsOwningThreadCurrent(), "MakeCurrent() called on different thread than this context was created on!"); #endif #endif return MakeCurrentImpl(aForce); } virtual bool Init() = 0; virtual bool SetupLookupFunction() = 0; virtual void ReleaseSurface() {} bool IsDestroyed() { // MarkDestroyed will mark all these as null. return mSymbols.fUseProgram == nullptr; } GLContext* GetSharedContext() { return mSharedContext; } /** * Returns true if the thread on which this context was created is the currently * executing thread. */ bool IsOwningThreadCurrent(); static void PlatformStartup(); public: /** * If this context wraps a double-buffered target, swap the back * and front buffers. It should be assumed that after a swap, the * contents of the new back buffer are undefined. */ virtual bool SwapBuffers() { return false; } /** * Defines a two-dimensional texture image for context target surface */ virtual bool BindTexImage() { return false; } /* * Releases a color buffer that is being used as a texture */ virtual bool ReleaseTexImage() { return false; } // Before reads from offscreen texture void GuaranteeResolve(); /* * Resize the current offscreen buffer. Returns true on success. * If it returns false, the context should be treated as unusable * and should be recreated. After the resize, the viewport is not * changed; glViewport should be called as appropriate. * * Only valid if IsOffscreen() returns true. */ bool ResizeOffscreen(const gfx::IntSize& size) { return ResizeScreenBuffer(size); } /* * Return size of this offscreen context. * * Only valid if IsOffscreen() returns true. */ const gfx::IntSize& OffscreenSize() const; void BindFB(GLuint fb) { fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, fb); MOZ_ASSERT(!fb || fIsFramebuffer(fb)); } void BindDrawFB(GLuint fb) { fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, fb); } void BindReadFB(GLuint fb) { fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, fb); } GLuint GetDrawFB(); GLuint GetReadFB(); GLuint GetFB(); private: void GetShaderPrecisionFormatNonES2(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) { switch (precisiontype) { case LOCAL_GL_LOW_FLOAT: case LOCAL_GL_MEDIUM_FLOAT: case LOCAL_GL_HIGH_FLOAT: // Assume IEEE 754 precision range[0] = 127; range[1] = 127; *precision = 23; break; case LOCAL_GL_LOW_INT: case LOCAL_GL_MEDIUM_INT: case LOCAL_GL_HIGH_INT: // Some (most) hardware only supports single-precision floating-point numbers, // which can accurately represent integers up to +/-16777216 range[0] = 24; range[1] = 24; *precision = 0; break; } } public: void ForceDirtyScreen(); void CleanDirtyScreen(); virtual GLenum GetPreferredARGB32Format() const { return LOCAL_GL_RGBA; } virtual GLenum GetPreferredEGLImageTextureTarget() const { return IsExtensionSupported(OES_EGL_image_external) ? LOCAL_GL_TEXTURE_EXTERNAL : LOCAL_GL_TEXTURE_2D; } virtual bool RenewSurface(nsIWidget* aWidget) { return false; } // Shared code for GL extensions and GLX extensions. static bool ListHasExtension(const GLubyte* extensions, const char* extension); GLint GetMaxTextureImageSize() { return mMaxTextureImageSize; } public: std::map<GLuint, SharedSurface*> mFBOMapping; enum { DebugFlagEnabled = 1 << 0, DebugFlagTrace = 1 << 1, DebugFlagAbortOnError = 1 << 2 }; const uint8_t mDebugFlags; protected: RefPtr<GLContext> mSharedContext; // The thread id which this context was created. PlatformThreadId mOwningThreadId; GLContextSymbols mSymbols; #ifdef MOZ_GL_DEBUG // Non-zero debug flags will check that we don't send call // to a GLContext that isn't current on the current // thread. // Store the current context when binding to thread local // storage to support debug flags on an arbitrary thread. static unsigned sCurrentGLContextTLS; #endif UniquePtr<GLBlitHelper> mBlitHelper; UniquePtr<GLReadTexImageHelper> mReadTexImageHelper; public: GLBlitHelper* BlitHelper(); GLBlitTextureImageHelper* BlitTextureImageHelper(); GLReadTexImageHelper* ReadTexImageHelper(); // Assumes shares are created by all sharing with the same global context. bool SharesWith(const GLContext* other) const { MOZ_ASSERT(!this->mSharedContext || !this->mSharedContext->mSharedContext); MOZ_ASSERT(!other->mSharedContext || !other->mSharedContext->mSharedContext); MOZ_ASSERT(!this->mSharedContext || !other->mSharedContext || this->mSharedContext == other->mSharedContext); const GLContext* thisShared = this->mSharedContext ? this->mSharedContext : this; const GLContext* otherShared = other->mSharedContext ? other->mSharedContext : other; return thisShared == otherShared; } bool InitOffscreen(const gfx::IntSize& size, const SurfaceCaps& caps); protected: // Note that it does -not- clear the resized buffers. bool CreateScreenBuffer(const gfx::IntSize& size, const SurfaceCaps& caps) { if (!IsOffscreenSizeAllowed(size)) return false; return CreateScreenBufferImpl(size, caps); } bool CreateScreenBufferImpl(const gfx::IntSize& size, const SurfaceCaps& caps); public: bool ResizeScreenBuffer(const gfx::IntSize& size); protected: SurfaceCaps mCaps; public: const SurfaceCaps& Caps() const { return mCaps; } // Only varies based on bpp16 and alpha. GLFormats ChooseGLFormats(const SurfaceCaps& caps) const; bool IsFramebufferComplete(GLuint fb, GLenum* status = nullptr); // Does not check completeness. void AttachBuffersToFB(GLuint colorTex, GLuint colorRB, GLuint depthRB, GLuint stencilRB, GLuint fb, GLenum target = LOCAL_GL_TEXTURE_2D); // Passing null is fine if the value you'd get is 0. bool AssembleOffscreenFBs(const GLuint colorMSRB, const GLuint depthRB, const GLuint stencilRB, const GLuint texture, GLuint* drawFB, GLuint* readFB); protected: friend class GLScreenBuffer; UniquePtr<GLScreenBuffer> mScreen; SharedSurface* mLockedSurface; public: void LockSurface(SharedSurface* surf) { MOZ_ASSERT(!mLockedSurface); mLockedSurface = surf; } void UnlockSurface(SharedSurface* surf) { MOZ_ASSERT(mLockedSurface == surf); mLockedSurface = nullptr; } SharedSurface* GetLockedSurface() const { return mLockedSurface; } bool IsOffscreen() const { return mIsOffscreen; } GLScreenBuffer* Screen() const { return mScreen.get(); } /* Clear to transparent black, with 0 depth and stencil, * while preserving current ClearColor etc. values. * Useful for resizing offscreen buffers. */ void ClearSafely(); bool WorkAroundDriverBugs() const { return mWorkAroundDriverBugs; } bool IsDrawingToDefaultFramebuffer(); protected: RefPtr<TextureGarbageBin> mTexGarbageBin; public: TextureGarbageBin* TexGarbageBin() { MOZ_ASSERT(mTexGarbageBin); return mTexGarbageBin; } void EmptyTexGarbageBin(); bool IsOffscreenSizeAllowed(const gfx::IntSize& aSize) const; protected: bool InitWithPrefix(const char* prefix, bool trygl); private: bool InitWithPrefixImpl(const char* prefix, bool trygl); void LoadMoreSymbols(const char* prefix, bool trygl); bool LoadExtSymbols(const char* prefix, bool trygl, const SymLoadStruct* list, GLExtensions ext); bool LoadFeatureSymbols(const char* prefix, bool trygl, const SymLoadStruct* list, GLFeature feature); protected: void InitExtensions(); GLint mViewportRect[4]; GLint mScissorRect[4]; GLint mMaxTextureSize; GLint mMaxCubeMapTextureSize; GLint mMaxTextureImageSize; GLint mMaxRenderbufferSize; GLint mMaxViewportDims[2]; GLsizei mMaxSamples; bool mNeedsTextureSizeChecks; bool mNeedsFlushBeforeDeleteFB; bool mTextureAllocCrashesOnMapFailure; bool mNeedsCheckAfterAttachTextureToFb; bool mWorkAroundDriverBugs; bool IsTextureSizeSafeToPassToDriver(GLenum target, GLsizei width, GLsizei height) const { if (mNeedsTextureSizeChecks) { // some drivers incorrectly handle some large texture sizes that are below the // max texture size that they report. So we check ourselves against our own values // (mMax[CubeMap]TextureSize). // see bug 737182 for Mac Intel 2D textures // see bug 684882 for Mac Intel cube map textures // see bug 814716 for Mesa Nouveau GLsizei maxSize = target == LOCAL_GL_TEXTURE_CUBE_MAP || (target >= LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X && target <= LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z) ? mMaxCubeMapTextureSize : mMaxTextureSize; return width <= maxSize && height <= maxSize; } return true; } public: GLsizei MaxSamples() const { return mMaxSamples; } void fViewport(GLint x, GLint y, GLsizei width, GLsizei height) { if (mViewportRect[0] == x && mViewportRect[1] == y && mViewportRect[2] == width && mViewportRect[3] == height) { return; } mViewportRect[0] = x; mViewportRect[1] = y; mViewportRect[2] = width; mViewportRect[3] = height; BEFORE_GL_CALL; mSymbols.fViewport(x, y, width, height); AFTER_GL_CALL; } #undef ASSERT_SYMBOL_PRESENT #ifdef MOZ_GL_DEBUG void CreatedProgram(GLContext* aOrigin, GLuint aName); void CreatedShader(GLContext* aOrigin, GLuint aName); void CreatedBuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames); void CreatedQueries(GLContext* aOrigin, GLsizei aCount, GLuint* aNames); void CreatedTextures(GLContext* aOrigin, GLsizei aCount, GLuint* aNames); void CreatedFramebuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames); void CreatedRenderbuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames); void DeletedProgram(GLContext* aOrigin, GLuint aName); void DeletedShader(GLContext* aOrigin, GLuint aName); void DeletedBuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames); void DeletedQueries(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames); void DeletedTextures(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames); void DeletedFramebuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames); void DeletedRenderbuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames); void SharedContextDestroyed(GLContext* aChild); void ReportOutstandingNames(); struct NamedResource { NamedResource() : origin(nullptr), name(0), originDeleted(false) { } NamedResource(GLContext* aOrigin, GLuint aName) : origin(aOrigin), name(aName), originDeleted(false) { } GLContext* origin; GLuint name; bool originDeleted; // for sorting bool operator<(const NamedResource& aOther) const { if (intptr_t(origin) < intptr_t(aOther.origin)) return true; if (name < aOther.name) return true; return false; } bool operator==(const NamedResource& aOther) const { return origin == aOther.origin && name == aOther.name && originDeleted == aOther.originDeleted; } }; nsTArray<NamedResource> mTrackedPrograms; nsTArray<NamedResource> mTrackedShaders; nsTArray<NamedResource> mTrackedTextures; nsTArray<NamedResource> mTrackedFramebuffers; nsTArray<NamedResource> mTrackedRenderbuffers; nsTArray<NamedResource> mTrackedBuffers; nsTArray<NamedResource> mTrackedQueries; #endif protected: bool mHeavyGLCallsSinceLastFlush; public: void FlushIfHeavyGLCallsSinceLastFlush(); static bool ShouldSpew(); static bool ShouldDumpExts(); void Readback(SharedSurface* src, gfx::DataSourceSurface* dest); }; bool DoesStringMatch(const char* aString, const char* aWantedString); void SplitByChar(const nsACString& str, const char delim, std::vector<nsCString>* const out); template<size_t N> bool MarkBitfieldByString(const nsACString& str, const char* const (&markStrList)[N], std::bitset<N>* const out_markList) { for (size_t i = 0; i < N; i++) { if (str.Equals(markStrList[i])) { (*out_markList)[i] = 1; return true; } } return false; } template<size_t N> void MarkBitfieldByStrings(const std::vector<nsCString>& strList, bool dumpStrings, const char* const (&markStrList)[N], std::bitset<N>* const out_markList) { for (auto itr = strList.begin(); itr != strList.end(); ++itr) { const nsACString& str = *itr; const bool wasMarked = MarkBitfieldByString(str, markStrList, out_markList); if (dumpStrings) printf_stderr(" %s%s\n", str.BeginReading(), wasMarked ? "(*)" : ""); } } /** * Helper function that creates a 2D texture aSize.width x aSize.height with * storage type specified by aFormats. Returns GL texture object id. * * See mozilla::gl::CreateTexture. */ GLuint CreateTextureForOffscreen(GLContext* aGL, const GLFormats& aFormats, const gfx::IntSize& aSize); /** * Helper function that creates a 2D texture aSize.width x aSize.height with * storage type aInternalFormat. Returns GL texture object id. * * Initialize textyre parameters to: * GL_TEXTURE_MIN_FILTER = GL_LINEAR * GL_TEXTURE_MAG_FILTER = GL_LINEAR * GL_TEXTURE_WRAP_S = GL_CLAMP_TO_EDGE * GL_TEXTURE_WRAP_T = GL_CLAMP_TO_EDGE */ GLuint CreateTexture(GLContext* aGL, GLenum aInternalFormat, GLenum aFormat, GLenum aType, const gfx::IntSize& aSize, bool linear = true); /** * Helper function that calculates the number of bytes required per * texel for a texture from its format and type. */ uint32_t GetBytesPerTexel(GLenum format, GLenum type); } /* namespace gl */ } /* namespace mozilla */ #endif /* GLCONTEXT_H_ */