Line data Source code
1 : /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /* vim: set ts=8 sts=4 et sw=4 tw=80: */
3 : /* This Source Code Form is subject to the terms of the Mozilla Public
4 : * License, v. 2.0. If a copy of the MPL was not distributed with this
5 : * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 :
7 : #ifndef GLCONTEXT_H_
8 : #define GLCONTEXT_H_
9 :
10 : #include <bitset>
11 : #include <ctype.h>
12 : #include <stdint.h>
13 : #include <stdio.h>
14 : #include <map>
15 : #include <queue>
16 : #include <stack>
17 :
18 : #ifdef DEBUG
19 : #include <string.h>
20 : #endif
21 :
22 : #ifdef GetClassName
23 : #undef GetClassName
24 : #endif
25 :
26 : // Define MOZ_GL_DEBUG unconditionally to enable GL debugging in opt
27 : // builds.
28 : #ifdef DEBUG
29 : #define MOZ_GL_DEBUG 1
30 : #endif
31 :
32 : #include "../../mfbt/RefPtr.h"
33 : #include "../../mfbt/UniquePtr.h"
34 : #include "../../mfbt/ThreadLocal.h"
35 :
36 : #include "GLDefs.h"
37 : #include "GLLibraryLoader.h"
38 : #include "nsISupportsImpl.h"
39 : #include "plstr.h"
40 : #include "GLContextTypes.h"
41 : #include "SurfaceTypes.h"
42 : #include "GLContextSymbols.h"
43 : #include "base/platform_thread.h" // for PlatformThreadId
44 : #include "mozilla/GenericRefCounted.h"
45 : #include "mozilla/WeakPtr.h"
46 : #include "gfx2DGlue.h"
47 : #include "GeckoProfiler.h"
48 :
49 : namespace android {
50 : class GraphicBuffer;
51 : } // namespace android
52 :
53 : namespace mozilla {
54 : namespace gfx {
55 : class DataSourceSurface;
56 : class SourceSurface;
57 : } // namespace gfx
58 :
59 : namespace gl {
60 : class GLBlitHelper;
61 : class GLBlitTextureImageHelper;
62 : class GLContext;
63 : class GLLibraryEGL;
64 : class GLReadTexImageHelper;
65 : class GLScreenBuffer;
66 : class SharedSurface;
67 : struct SurfaceCaps;
68 : } // namespace gl
69 :
70 : namespace layers {
71 : class ColorTextureLayerProgram;
72 : } // namespace layers
73 :
74 : namespace widget {
75 : class CompositorWidget;
76 : } // namespace widget
77 : } // namespace mozilla
78 :
79 : namespace mozilla {
80 : namespace gl {
81 :
82 : enum class GLFeature {
83 : bind_buffer_offset,
84 : blend_minmax,
85 : clear_buffers,
86 : copy_buffer,
87 : depth_texture,
88 : draw_buffers,
89 : draw_instanced,
90 : draw_range_elements,
91 : element_index_uint,
92 : ES2_compatibility,
93 : ES3_compatibility,
94 : EXT_color_buffer_float,
95 : frag_color_float,
96 : frag_depth,
97 : framebuffer_blit,
98 : framebuffer_multisample,
99 : framebuffer_object,
100 : framebuffer_object_EXT_OES,
101 : get_integer_indexed,
102 : get_integer64_indexed,
103 : get_query_object_i64v,
104 : get_query_object_iv,
105 : gpu_shader4,
106 : instanced_arrays,
107 : instanced_non_arrays,
108 : internalformat_query,
109 : invalidate_framebuffer,
110 : map_buffer_range,
111 : occlusion_query,
112 : occlusion_query_boolean,
113 : occlusion_query2,
114 : packed_depth_stencil,
115 : prim_restart,
116 : prim_restart_fixed,
117 : query_counter,
118 : query_objects,
119 : query_time_elapsed,
120 : read_buffer,
121 : renderbuffer_color_float,
122 : renderbuffer_color_half_float,
123 : robust_buffer_access_behavior,
124 : robustness,
125 : sRGB_framebuffer,
126 : sRGB_texture,
127 : sampler_objects,
128 : seamless_cube_map_opt_in,
129 : shader_texture_lod,
130 : split_framebuffer,
131 : standard_derivatives,
132 : sync,
133 : texture_3D,
134 : texture_3D_compressed,
135 : texture_3D_copy,
136 : texture_float,
137 : texture_float_linear,
138 : texture_half_float,
139 : texture_half_float_linear,
140 : texture_non_power_of_two,
141 : texture_rg,
142 : texture_storage,
143 : texture_swizzle,
144 : transform_feedback2,
145 : uniform_buffer_object,
146 : uniform_matrix_nonsquare,
147 : vertex_array_object,
148 : EnumMax
149 : };
150 :
151 : enum class ContextProfile : uint8_t {
152 : Unknown = 0,
153 : OpenGLCore,
154 : OpenGLCompatibility,
155 : OpenGLES
156 : };
157 :
158 : enum class GLVendor {
159 : Intel,
160 : NVIDIA,
161 : ATI,
162 : Qualcomm,
163 : Imagination,
164 : Nouveau,
165 : Vivante,
166 : VMware,
167 : ARM,
168 : Other
169 : };
170 :
171 : enum class GLRenderer {
172 : Adreno200,
173 : Adreno205,
174 : AdrenoTM200,
175 : AdrenoTM205,
176 : AdrenoTM305,
177 : AdrenoTM320,
178 : AdrenoTM330,
179 : AdrenoTM420,
180 : Mali400MP,
181 : Mali450MP,
182 : SGX530,
183 : SGX540,
184 : SGX544MP,
185 : Tegra,
186 : AndroidEmulator,
187 : GalliumLlvmpipe,
188 : IntelHD3000,
189 : MicrosoftBasicRenderDriver,
190 : Other
191 : };
192 :
193 : class GLContext
194 : : public GLLibraryLoader
195 : , public GenericAtomicRefCounted
196 : , public SupportsWeakPtr<GLContext>
197 : {
198 : public:
199 0 : MOZ_DECLARE_WEAKREFERENCE_TYPENAME(GLContext)
200 : static MOZ_THREAD_LOCAL(GLContext*) sCurrentContext;
201 :
202 : // -----------------------------------------------------------------------------
203 : // basic getters
204 : public:
205 :
206 : /**
207 : * Returns true if the context is using ANGLE. This should only be overridden
208 : * for an ANGLE implementation.
209 : */
210 0 : virtual bool IsANGLE() const {
211 0 : return false;
212 : }
213 :
214 : /**
215 : * Returns true if the context is using WARP. This should only be overridden
216 : * for an ANGLE implementation.
217 : */
218 0 : virtual bool IsWARP() const {
219 0 : return false;
220 : }
221 :
222 : virtual void GetWSIInfo(nsCString* const out) const = 0;
223 :
224 : /**
225 : * Return true if we are running on a OpenGL core profile context
226 : */
227 0 : inline bool IsCoreProfile() const {
228 0 : MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
229 :
230 0 : return mProfile == ContextProfile::OpenGLCore;
231 : }
232 :
233 : /**
234 : * Return true if we are running on a OpenGL compatibility profile context
235 : * (legacy profile 2.1 on Max OS X)
236 : */
237 0 : inline bool IsCompatibilityProfile() const {
238 0 : MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
239 :
240 0 : return mProfile == ContextProfile::OpenGLCompatibility;
241 : }
242 :
243 0 : inline bool IsGLES() const {
244 0 : MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
245 :
246 0 : return mProfile == ContextProfile::OpenGLES;
247 : }
248 :
249 0 : inline bool IsAtLeast(ContextProfile profile, unsigned int version) const
250 : {
251 0 : MOZ_ASSERT(profile != ContextProfile::Unknown, "IsAtLeast: bad <profile> parameter");
252 0 : MOZ_ASSERT(mProfile != ContextProfile::Unknown, "unknown context profile");
253 0 : MOZ_ASSERT(mVersion != 0, "unknown context version");
254 :
255 0 : if (version > mVersion) {
256 0 : return false;
257 : }
258 :
259 0 : return profile == mProfile;
260 : }
261 :
262 : /**
263 : * Return the version of the context.
264 : * Example :
265 : * If this a OpenGL 2.1, that will return 210
266 : */
267 0 : inline uint32_t Version() const {
268 0 : return mVersion;
269 : }
270 :
271 0 : inline uint32_t ShadingLanguageVersion() const {
272 0 : return mShadingLanguageVersion;
273 : }
274 :
275 0 : GLVendor Vendor() const {
276 0 : return mVendor;
277 : }
278 :
279 0 : GLRenderer Renderer() const {
280 0 : return mRenderer;
281 : }
282 :
283 0 : bool IsContextLost() const {
284 0 : return mContextLost;
285 : }
286 :
287 0 : bool HasPBOState() const {
288 0 : return (!IsGLES() || Version() >= 300);
289 : }
290 :
291 : /**
292 : * If this context is double-buffered, returns TRUE.
293 : */
294 0 : virtual bool IsDoubleBuffered() const {
295 0 : return false;
296 : }
297 :
298 : virtual GLContextType GetContextType() const = 0;
299 :
300 : virtual bool IsCurrent() = 0;
301 :
302 : /**
303 : * Get the default framebuffer for this context.
304 : */
305 0 : virtual GLuint GetDefaultFramebuffer() {
306 0 : return 0;
307 : }
308 :
309 : protected:
310 : bool mIsOffscreen;
311 : bool mContextLost;
312 : const bool mUseTLSIsCurrent;
313 :
314 : /**
315 : * mVersion store the OpenGL's version, multiplied by 100. For example, if
316 : * the context is an OpenGL 2.1 context, mVersion value will be 210.
317 : */
318 : uint32_t mVersion;
319 : ContextProfile mProfile;
320 :
321 : uint32_t mShadingLanguageVersion;
322 :
323 : GLVendor mVendor;
324 : GLRenderer mRenderer;
325 :
326 : // -----------------------------------------------------------------------------
327 : // Extensions management
328 : /**
329 : * This mechanism is designed to know if an extension is supported. In the long
330 : * term, we would like to only use the extension group queries XXX_* to have
331 : * full compatibility with context version and profiles (especialy the core that
332 : * officialy don't bring any extensions).
333 : */
334 : public:
335 :
336 : /**
337 : * Known GL extensions that can be queried by
338 : * IsExtensionSupported. The results of this are cached, and as
339 : * such it's safe to use this even in performance critical code.
340 : * If you add to this array, remember to add to the string names
341 : * in GLContext.cpp.
342 : */
343 : enum GLExtensions {
344 : Extension_None = 0,
345 : AMD_compressed_ATC_texture,
346 : ANGLE_depth_texture,
347 : ANGLE_framebuffer_blit,
348 : ANGLE_framebuffer_multisample,
349 : ANGLE_instanced_arrays,
350 : ANGLE_texture_compression_dxt3,
351 : ANGLE_texture_compression_dxt5,
352 : ANGLE_timer_query,
353 : APPLE_client_storage,
354 : APPLE_framebuffer_multisample,
355 : APPLE_sync,
356 : APPLE_texture_range,
357 : APPLE_vertex_array_object,
358 : ARB_ES2_compatibility,
359 : ARB_ES3_compatibility,
360 : ARB_color_buffer_float,
361 : ARB_compatibility,
362 : ARB_copy_buffer,
363 : ARB_depth_texture,
364 : ARB_draw_buffers,
365 : ARB_draw_instanced,
366 : ARB_framebuffer_object,
367 : ARB_framebuffer_sRGB,
368 : ARB_geometry_shader4,
369 : ARB_half_float_pixel,
370 : ARB_instanced_arrays,
371 : ARB_internalformat_query,
372 : ARB_invalidate_subdata,
373 : ARB_map_buffer_range,
374 : ARB_occlusion_query2,
375 : ARB_pixel_buffer_object,
376 : ARB_robust_buffer_access_behavior,
377 : ARB_robustness,
378 : ARB_sampler_objects,
379 : ARB_seamless_cube_map,
380 : ARB_shader_texture_lod,
381 : ARB_sync,
382 : ARB_texture_compression,
383 : ARB_texture_float,
384 : ARB_texture_non_power_of_two,
385 : ARB_texture_rectangle,
386 : ARB_texture_rg,
387 : ARB_texture_storage,
388 : ARB_texture_swizzle,
389 : ARB_timer_query,
390 : ARB_transform_feedback2,
391 : ARB_uniform_buffer_object,
392 : ARB_vertex_array_object,
393 : EXT_bgra,
394 : EXT_blend_minmax,
395 : EXT_color_buffer_float,
396 : EXT_color_buffer_half_float,
397 : EXT_copy_texture,
398 : EXT_disjoint_timer_query,
399 : EXT_draw_buffers,
400 : EXT_draw_buffers2,
401 : EXT_draw_instanced,
402 : EXT_draw_range_elements,
403 : EXT_frag_depth,
404 : EXT_framebuffer_blit,
405 : EXT_framebuffer_multisample,
406 : EXT_framebuffer_object,
407 : EXT_framebuffer_sRGB,
408 : EXT_gpu_shader4,
409 : EXT_multisampled_render_to_texture,
410 : EXT_occlusion_query_boolean,
411 : EXT_packed_depth_stencil,
412 : EXT_read_format_bgra,
413 : EXT_robustness,
414 : EXT_sRGB,
415 : EXT_sRGB_write_control,
416 : EXT_shader_texture_lod,
417 : EXT_texture3D,
418 : EXT_texture_compression_dxt1,
419 : EXT_texture_compression_s3tc,
420 : EXT_texture_filter_anisotropic,
421 : EXT_texture_format_BGRA8888,
422 : EXT_texture_sRGB,
423 : EXT_texture_storage,
424 : EXT_timer_query,
425 : EXT_transform_feedback,
426 : EXT_unpack_subimage,
427 : IMG_read_format,
428 : IMG_texture_compression_pvrtc,
429 : IMG_texture_npot,
430 : KHR_debug,
431 : KHR_robust_buffer_access_behavior,
432 : KHR_robustness,
433 : KHR_texture_compression_astc_hdr,
434 : KHR_texture_compression_astc_ldr,
435 : NV_draw_instanced,
436 : NV_fence,
437 : NV_framebuffer_blit,
438 : NV_geometry_program4,
439 : NV_half_float,
440 : NV_instanced_arrays,
441 : NV_primitive_restart,
442 : NV_texture_barrier,
443 : NV_transform_feedback,
444 : NV_transform_feedback2,
445 : OES_EGL_image,
446 : OES_EGL_image_external,
447 : OES_EGL_sync,
448 : OES_compressed_ETC1_RGB8_texture,
449 : OES_depth24,
450 : OES_depth32,
451 : OES_depth_texture,
452 : OES_element_index_uint,
453 : OES_framebuffer_object,
454 : OES_packed_depth_stencil,
455 : OES_rgb8_rgba8,
456 : OES_standard_derivatives,
457 : OES_stencil8,
458 : OES_texture_3D,
459 : OES_texture_float,
460 : OES_texture_float_linear,
461 : OES_texture_half_float,
462 : OES_texture_half_float_linear,
463 : OES_texture_npot,
464 : OES_vertex_array_object,
465 : Extensions_Max,
466 : Extensions_End
467 : };
468 :
469 0 : bool IsExtensionSupported(GLExtensions aKnownExtension) const {
470 0 : return mAvailableExtensions[aKnownExtension];
471 : }
472 :
473 : protected:
474 0 : void MarkExtensionUnsupported(GLExtensions aKnownExtension) {
475 0 : mAvailableExtensions[aKnownExtension] = 0;
476 0 : }
477 :
478 0 : void MarkExtensionSupported(GLExtensions aKnownExtension) {
479 0 : mAvailableExtensions[aKnownExtension] = 1;
480 0 : }
481 :
482 : std::bitset<Extensions_Max> mAvailableExtensions;
483 :
484 : // -----------------------------------------------------------------------------
485 : // Feature queries
486 : /*
487 : * This mecahnism introduces a new way to check if a OpenGL feature is
488 : * supported, regardless of whether it is supported by an extension or natively
489 : * by the context version/profile
490 : */
491 : public:
492 0 : bool IsSupported(GLFeature feature) const {
493 0 : return mAvailableFeatures[size_t(feature)];
494 : }
495 :
496 : static const char* GetFeatureName(GLFeature feature);
497 :
498 : private:
499 : std::bitset<size_t(GLFeature::EnumMax)> mAvailableFeatures;
500 :
501 : /**
502 : * Init features regarding OpenGL extension and context version and profile
503 : */
504 : void InitFeatures();
505 :
506 : /**
507 : * Mark the feature and associated extensions as unsupported
508 : */
509 : void MarkUnsupported(GLFeature feature);
510 :
511 : /**
512 : * Is this feature supported using the core (unsuffixed) symbols?
513 : */
514 : bool IsFeatureProvidedByCoreSymbols(GLFeature feature);
515 :
516 : public:
517 : // -----------------------------------------------------------------------------
518 : // Error handling
519 0 : static const char* GLErrorToString(GLenum aError) {
520 0 : switch (aError) {
521 : case LOCAL_GL_INVALID_ENUM:
522 0 : return "GL_INVALID_ENUM";
523 : case LOCAL_GL_INVALID_VALUE:
524 0 : return "GL_INVALID_VALUE";
525 : case LOCAL_GL_INVALID_OPERATION:
526 0 : return "GL_INVALID_OPERATION";
527 : case LOCAL_GL_STACK_OVERFLOW:
528 0 : return "GL_STACK_OVERFLOW";
529 : case LOCAL_GL_STACK_UNDERFLOW:
530 0 : return "GL_STACK_UNDERFLOW";
531 : case LOCAL_GL_OUT_OF_MEMORY:
532 0 : return "GL_OUT_OF_MEMORY";
533 : case LOCAL_GL_TABLE_TOO_LARGE:
534 0 : return "GL_TABLE_TOO_LARGE";
535 : case LOCAL_GL_INVALID_FRAMEBUFFER_OPERATION:
536 0 : return "GL_INVALID_FRAMEBUFFER_OPERATION";
537 : default:
538 0 : return "";
539 : }
540 : }
541 :
542 : private:
543 : GLenum mTopError;
544 :
545 0 : GLenum RawGetError() {
546 0 : return mSymbols.fGetError();
547 : }
548 :
549 0 : GLenum RawGetErrorAndClear() {
550 0 : GLenum err = RawGetError();
551 :
552 0 : if (err)
553 0 : while (RawGetError()) {}
554 :
555 0 : return err;
556 : }
557 :
558 : public:
559 0 : GLenum FlushErrors() {
560 0 : GLenum err = RawGetErrorAndClear();
561 0 : if (!mTopError)
562 0 : mTopError = err;
563 0 : return err;
564 : }
565 :
566 : // We smash all errors together, so you never have to loop on this. We
567 : // guarantee that immediately after this call, there are no errors left.
568 0 : GLenum fGetError() {
569 0 : FlushErrors();
570 :
571 0 : GLenum err = mTopError;
572 0 : mTopError = LOCAL_GL_NO_ERROR;
573 0 : return err;
574 : }
575 :
576 : ////////////////////////////////////
577 : // Use this safer option.
578 : class LocalErrorScope;
579 :
580 : private:
581 : std::stack<const LocalErrorScope*> mLocalErrorScopeStack;
582 :
583 : public:
584 : class LocalErrorScope {
585 : GLContext& mGL;
586 : GLenum mOldTop;
587 : bool mHasBeenChecked;
588 :
589 : public:
590 0 : explicit LocalErrorScope(GLContext& gl)
591 0 : : mGL(gl)
592 0 : , mHasBeenChecked(false)
593 : {
594 0 : mGL.mLocalErrorScopeStack.push(this);
595 :
596 0 : mGL.FlushErrors();
597 :
598 0 : mOldTop = mGL.mTopError;
599 0 : mGL.mTopError = LOCAL_GL_NO_ERROR;
600 0 : }
601 :
602 0 : GLenum GetError() {
603 0 : MOZ_ASSERT(!mHasBeenChecked);
604 0 : mHasBeenChecked = true;
605 :
606 0 : const GLenum ret = mGL.fGetError();
607 :
608 0 : while (mGL.fGetError()) {}
609 :
610 0 : return ret;
611 : }
612 :
613 0 : ~LocalErrorScope() {
614 0 : MOZ_ASSERT(mHasBeenChecked);
615 :
616 0 : MOZ_ASSERT(mGL.fGetError() == LOCAL_GL_NO_ERROR);
617 :
618 0 : MOZ_ASSERT(mGL.mLocalErrorScopeStack.top() == this);
619 0 : mGL.mLocalErrorScopeStack.pop();
620 :
621 0 : mGL.mTopError = mOldTop;
622 0 : }
623 : };
624 :
625 0 : bool GetPotentialInteger(GLenum pname, GLint* param) {
626 0 : LocalErrorScope localError(*this);
627 :
628 0 : fGetIntegerv(pname, param);
629 :
630 0 : GLenum err = localError.GetError();
631 0 : MOZ_ASSERT_IF(err != LOCAL_GL_NO_ERROR, err == LOCAL_GL_INVALID_ENUM);
632 0 : return err == LOCAL_GL_NO_ERROR;
633 : }
634 :
635 : private:
636 : static void GLAPIENTRY StaticDebugCallback(GLenum source,
637 : GLenum type,
638 : GLuint id,
639 : GLenum severity,
640 : GLsizei length,
641 : const GLchar* message,
642 : const GLvoid* userParam);
643 : void DebugCallback(GLenum source,
644 : GLenum type,
645 : GLuint id,
646 : GLenum severity,
647 : GLsizei length,
648 : const GLchar* message);
649 :
650 :
651 : // -----------------------------------------------------------------------------
652 : // MOZ_GL_DEBUG implementation
653 : private:
654 :
655 : #undef BEFORE_GL_CALL
656 : #undef AFTER_GL_CALL
657 :
658 : #ifdef MOZ_GL_DEBUG
659 :
660 : #ifndef MOZ_FUNCTION_NAME
661 : # ifdef __GNUC__
662 : # define MOZ_FUNCTION_NAME __PRETTY_FUNCTION__
663 : # elif defined(_MSC_VER)
664 : # define MOZ_FUNCTION_NAME __FUNCTION__
665 : # else
666 : # define MOZ_FUNCTION_NAME __func__ // defined in C99, supported in various C++ compilers. Just raw function name.
667 : # endif
668 : #endif
669 :
670 0 : void BeforeGLCall(const char* funcName) {
671 0 : MOZ_ASSERT(IsCurrent());
672 :
673 0 : if (mDebugFlags) {
674 0 : FlushErrors();
675 :
676 0 : if (mDebugFlags & DebugFlagTrace) {
677 0 : printf_stderr("[gl:%p] > %s\n", this, funcName);
678 : }
679 :
680 0 : GLContext* tlsContext = (GLContext*)PR_GetThreadPrivate(sCurrentGLContextTLS);
681 0 : if (this != tlsContext) {
682 : printf_stderr("Fatal: %s called on non-current context %p. The"
683 : " current context for this thread is %p.\n",
684 0 : funcName, this, tlsContext);
685 0 : MOZ_CRASH("GFX: GLContext is not current.");
686 : }
687 : }
688 0 : }
689 :
690 0 : void AfterGLCall(const char* funcName) {
691 0 : if (mDebugFlags) {
692 : // calling fFinish() immediately after every GL call makes sure that if this GL command crashes,
693 : // the stack trace will actually point to it. Otherwise, OpenGL being an asynchronous API, stack traces
694 : // tend to be meaningless
695 0 : mSymbols.fFinish();
696 0 : GLenum err = FlushErrors();
697 :
698 0 : if (mDebugFlags & DebugFlagTrace) {
699 0 : printf_stderr("[gl:%p] < %s [%s (0x%04x)]\n", this, funcName,
700 0 : GLErrorToString(err), err);
701 : }
702 :
703 0 : if (err != LOCAL_GL_NO_ERROR &&
704 0 : !mLocalErrorScopeStack.size())
705 : {
706 0 : printf_stderr("[gl:%p] %s: Generated unexpected %s error."
707 : " (0x%04x)\n", this, funcName,
708 0 : GLErrorToString(err), err);
709 :
710 0 : if (mDebugFlags & DebugFlagAbortOnError) {
711 0 : MOZ_CRASH("Unexpected error with MOZ_GL_DEBUG_ABORT_ON_ERROR. (Run"
712 : " with MOZ_GL_DEBUG_ABORT_ON_ERROR=0 to disable)");
713 : }
714 : }
715 : }
716 0 : }
717 :
718 0 : GLContext* TrackingContext()
719 : {
720 0 : GLContext* tip = this;
721 0 : while (tip->mSharedContext)
722 0 : tip = tip->mSharedContext;
723 0 : return tip;
724 : }
725 :
726 : static void AssertNotPassingStackBufferToTheGL(const void* ptr);
727 :
728 : #ifdef MOZ_WIDGET_ANDROID
729 : // Record the name of the GL call for better hang stacks on Android.
730 : #define BEFORE_GL_CALL \
731 : AUTO_PROFILER_LABEL(__func__, GRAPHICS);\
732 : BeforeGLCall(MOZ_FUNCTION_NAME)
733 : #else
734 : #define BEFORE_GL_CALL \
735 : do { \
736 : BeforeGLCall(MOZ_FUNCTION_NAME); \
737 : } while (0)
738 : #endif
739 :
740 : #define AFTER_GL_CALL \
741 : do { \
742 : AfterGLCall(MOZ_FUNCTION_NAME); \
743 : } while (0)
744 :
745 : #define TRACKING_CONTEXT(a) \
746 : do { \
747 : TrackingContext()->a; \
748 : } while (0)
749 :
750 : #define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) AssertNotPassingStackBufferToTheGL(ptr)
751 :
752 : #else // ifdef MOZ_GL_DEBUG
753 :
754 : #ifdef MOZ_WIDGET_ANDROID
755 : // Record the name of the GL call for better hang stacks on Android.
756 : #define BEFORE_GL_CALL AUTO_PROFILER_LABEL(__func__, GRAPHICS)
757 : #else
758 : #define BEFORE_GL_CALL do { } while (0)
759 : #endif
760 : #define AFTER_GL_CALL do { } while (0)
761 : #define TRACKING_CONTEXT(a) do {} while (0)
762 : #define ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(ptr) do {} while (0)
763 :
764 : #endif // ifdef MOZ_GL_DEBUG
765 :
766 : #define ASSERT_SYMBOL_PRESENT(func) \
767 : do {\
768 : MOZ_ASSERT(strstr(MOZ_FUNCTION_NAME, #func) != nullptr, "Mismatched symbol check.");\
769 : if (MOZ_UNLIKELY(!mSymbols.func)) {\
770 : printf_stderr("RUNTIME ASSERT: Uninitialized GL function: %s\n", #func);\
771 : MOZ_CRASH("GFX: Uninitialized GL function");\
772 : }\
773 : } while (0)
774 :
775 : // Do whatever setup is necessary to draw to our offscreen FBO, if it's
776 : // bound.
777 0 : void BeforeGLDrawCall() { }
778 :
779 : // Do whatever tear-down is necessary after drawing to our offscreen FBO,
780 : // if it's bound.
781 : void AfterGLDrawCall();
782 :
783 : // Do whatever setup is necessary to read from our offscreen FBO, if it's
784 : // bound.
785 : void BeforeGLReadCall();
786 :
787 : // Do whatever tear-down is necessary after reading from our offscreen FBO,
788 : // if it's bound.
789 0 : void AfterGLReadCall() { }
790 :
791 :
792 : // -----------------------------------------------------------------------------
793 : // GL official entry points
794 : public:
795 :
796 0 : void fActiveTexture(GLenum texture) {
797 0 : BEFORE_GL_CALL;
798 0 : mSymbols.fActiveTexture(texture);
799 0 : AFTER_GL_CALL;
800 0 : }
801 :
802 0 : void fAttachShader(GLuint program, GLuint shader) {
803 0 : BEFORE_GL_CALL;
804 0 : mSymbols.fAttachShader(program, shader);
805 0 : AFTER_GL_CALL;
806 0 : }
807 :
808 0 : void fBeginQuery(GLenum target, GLuint id) {
809 0 : BEFORE_GL_CALL;
810 0 : ASSERT_SYMBOL_PRESENT(fBeginQuery);
811 0 : mSymbols.fBeginQuery(target, id);
812 0 : AFTER_GL_CALL;
813 0 : }
814 :
815 0 : void fBindAttribLocation(GLuint program, GLuint index, const GLchar* name) {
816 0 : BEFORE_GL_CALL;
817 0 : mSymbols.fBindAttribLocation(program, index, name);
818 0 : AFTER_GL_CALL;
819 0 : }
820 :
821 0 : void fBindBuffer(GLenum target, GLuint buffer) {
822 0 : BEFORE_GL_CALL;
823 0 : mSymbols.fBindBuffer(target, buffer);
824 0 : AFTER_GL_CALL;
825 0 : }
826 :
827 : void fBindFramebuffer(GLenum target, GLuint framebuffer);
828 :
829 0 : void fInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments) {
830 0 : BeforeGLDrawCall();
831 0 : BEFORE_GL_CALL;
832 0 : ASSERT_SYMBOL_PRESENT(fInvalidateFramebuffer);
833 0 : mSymbols.fInvalidateFramebuffer(target, numAttachments, attachments);
834 0 : AFTER_GL_CALL;
835 0 : AfterGLDrawCall();
836 0 : }
837 :
838 0 : void fInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum* attachments, GLint x, GLint y, GLsizei width, GLsizei height) {
839 0 : BeforeGLDrawCall();
840 0 : BEFORE_GL_CALL;
841 0 : ASSERT_SYMBOL_PRESENT(fInvalidateSubFramebuffer);
842 0 : mSymbols.fInvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
843 0 : AFTER_GL_CALL;
844 0 : AfterGLDrawCall();
845 0 : }
846 :
847 0 : void fBindTexture(GLenum target, GLuint texture) {
848 0 : BEFORE_GL_CALL;
849 0 : mSymbols.fBindTexture(target, texture);
850 0 : AFTER_GL_CALL;
851 0 : }
852 :
853 0 : void fBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
854 0 : BEFORE_GL_CALL;
855 0 : mSymbols.fBlendColor(red, green, blue, alpha);
856 0 : AFTER_GL_CALL;
857 0 : }
858 :
859 0 : void fBlendEquation(GLenum mode) {
860 0 : BEFORE_GL_CALL;
861 0 : mSymbols.fBlendEquation(mode);
862 0 : AFTER_GL_CALL;
863 0 : }
864 :
865 0 : void fBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) {
866 0 : BEFORE_GL_CALL;
867 0 : mSymbols.fBlendEquationSeparate(modeRGB, modeAlpha);
868 0 : AFTER_GL_CALL;
869 0 : }
870 :
871 0 : void fBlendFunc(GLenum sfactor, GLenum dfactor) {
872 0 : BEFORE_GL_CALL;
873 0 : mSymbols.fBlendFunc(sfactor, dfactor);
874 0 : AFTER_GL_CALL;
875 0 : }
876 :
877 0 : void fBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
878 0 : BEFORE_GL_CALL;
879 0 : mSymbols.fBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
880 0 : AFTER_GL_CALL;
881 0 : }
882 :
883 : private:
884 0 : void raw_fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) {
885 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data);
886 0 : BEFORE_GL_CALL;
887 0 : mSymbols.fBufferData(target, size, data, usage);
888 0 : AFTER_GL_CALL;
889 0 : mHeavyGLCallsSinceLastFlush = true;
890 0 : }
891 :
892 : public:
893 0 : void fBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) {
894 0 : raw_fBufferData(target, size, data, usage);
895 :
896 : // bug 744888
897 0 : if (WorkAroundDriverBugs() &&
898 0 : !data &&
899 0 : Vendor() == GLVendor::NVIDIA)
900 : {
901 0 : UniquePtr<char[]> buf = MakeUnique<char[]>(1);
902 0 : buf[0] = 0;
903 0 : fBufferSubData(target, size-1, 1, buf.get());
904 : }
905 0 : }
906 :
907 0 : void fBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) {
908 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(data);
909 0 : BEFORE_GL_CALL;
910 0 : mSymbols.fBufferSubData(target, offset, size, data);
911 0 : AFTER_GL_CALL;
912 0 : mHeavyGLCallsSinceLastFlush = true;
913 0 : }
914 :
915 : private:
916 0 : void raw_fClear(GLbitfield mask) {
917 0 : BEFORE_GL_CALL;
918 0 : mSymbols.fClear(mask);
919 0 : AFTER_GL_CALL;
920 0 : }
921 :
922 : public:
923 0 : void fClear(GLbitfield mask) {
924 0 : BeforeGLDrawCall();
925 0 : raw_fClear(mask);
926 0 : AfterGLDrawCall();
927 0 : }
928 :
929 0 : void fClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
930 0 : BeforeGLDrawCall();
931 0 : BEFORE_GL_CALL;
932 0 : mSymbols.fClearBufferfi(buffer, drawbuffer, depth, stencil);
933 0 : AFTER_GL_CALL;
934 0 : AfterGLDrawCall();
935 0 : }
936 :
937 0 : void fClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat* value) {
938 0 : BeforeGLDrawCall();
939 0 : BEFORE_GL_CALL;
940 0 : mSymbols.fClearBufferfv(buffer, drawbuffer, value);
941 0 : AFTER_GL_CALL;
942 0 : AfterGLDrawCall();
943 0 : }
944 :
945 0 : void fClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint* value) {
946 0 : BeforeGLDrawCall();
947 0 : BEFORE_GL_CALL;
948 0 : mSymbols.fClearBufferiv(buffer, drawbuffer, value);
949 0 : AFTER_GL_CALL;
950 0 : AfterGLDrawCall();
951 0 : }
952 :
953 0 : void fClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint* value) {
954 0 : BeforeGLDrawCall();
955 0 : BEFORE_GL_CALL;
956 0 : mSymbols.fClearBufferuiv(buffer, drawbuffer, value);
957 0 : AFTER_GL_CALL;
958 0 : AfterGLDrawCall();
959 0 : }
960 :
961 0 : void fClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) {
962 0 : BEFORE_GL_CALL;
963 0 : mSymbols.fClearColor(r, g, b, a);
964 0 : AFTER_GL_CALL;
965 0 : }
966 :
967 0 : void fClearStencil(GLint s) {
968 0 : BEFORE_GL_CALL;
969 0 : mSymbols.fClearStencil(s);
970 0 : AFTER_GL_CALL;
971 0 : }
972 :
973 : void fClientActiveTexture(GLenum texture) {
974 : BEFORE_GL_CALL;
975 : mSymbols.fClientActiveTexture(texture);
976 : AFTER_GL_CALL;
977 : }
978 :
979 0 : void fColorMask(realGLboolean red, realGLboolean green, realGLboolean blue, realGLboolean alpha) {
980 0 : BEFORE_GL_CALL;
981 0 : mSymbols.fColorMask(red, green, blue, alpha);
982 0 : AFTER_GL_CALL;
983 0 : }
984 :
985 0 : void fCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* pixels) {
986 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
987 0 : BEFORE_GL_CALL;
988 0 : mSymbols.fCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, pixels);
989 0 : AFTER_GL_CALL;
990 0 : mHeavyGLCallsSinceLastFlush = true;
991 0 : }
992 :
993 0 : void fCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* pixels) {
994 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
995 0 : BEFORE_GL_CALL;
996 0 : mSymbols.fCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, pixels);
997 0 : AFTER_GL_CALL;
998 0 : mHeavyGLCallsSinceLastFlush = true;
999 0 : }
1000 :
1001 : void fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x,
1002 : GLint y, GLsizei width, GLsizei height, GLint border);
1003 :
1004 0 : void fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {
1005 0 : BeforeGLReadCall();
1006 : raw_fCopyTexSubImage2D(target, level, xoffset, yoffset,
1007 0 : x, y, width, height);
1008 0 : AfterGLReadCall();
1009 0 : }
1010 :
1011 0 : void fCullFace(GLenum mode) {
1012 0 : BEFORE_GL_CALL;
1013 0 : mSymbols.fCullFace(mode);
1014 0 : AFTER_GL_CALL;
1015 0 : }
1016 :
1017 0 : void fDebugMessageCallback(GLDEBUGPROC callback, const GLvoid* userParam) {
1018 0 : BEFORE_GL_CALL;
1019 0 : ASSERT_SYMBOL_PRESENT(fDebugMessageCallback);
1020 0 : mSymbols.fDebugMessageCallback(callback, userParam);
1021 0 : AFTER_GL_CALL;
1022 0 : }
1023 :
1024 0 : void fDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, realGLboolean enabled) {
1025 0 : BEFORE_GL_CALL;
1026 0 : ASSERT_SYMBOL_PRESENT(fDebugMessageControl);
1027 0 : mSymbols.fDebugMessageControl(source, type, severity, count, ids, enabled);
1028 0 : AFTER_GL_CALL;
1029 0 : }
1030 :
1031 : void fDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar* buf) {
1032 : BEFORE_GL_CALL;
1033 : ASSERT_SYMBOL_PRESENT(fDebugMessageInsert);
1034 : mSymbols.fDebugMessageInsert(source, type, id, severity, length, buf);
1035 : AFTER_GL_CALL;
1036 : }
1037 :
1038 0 : void fDetachShader(GLuint program, GLuint shader) {
1039 0 : BEFORE_GL_CALL;
1040 0 : mSymbols.fDetachShader(program, shader);
1041 0 : AFTER_GL_CALL;
1042 0 : }
1043 :
1044 0 : void fDepthFunc(GLenum func) {
1045 0 : BEFORE_GL_CALL;
1046 0 : mSymbols.fDepthFunc(func);
1047 0 : AFTER_GL_CALL;
1048 0 : }
1049 :
1050 0 : void fDepthMask(realGLboolean flag) {
1051 0 : BEFORE_GL_CALL;
1052 0 : mSymbols.fDepthMask(flag);
1053 0 : AFTER_GL_CALL;
1054 0 : }
1055 :
1056 0 : void fDisable(GLenum capability) {
1057 0 : BEFORE_GL_CALL;
1058 0 : mSymbols.fDisable(capability);
1059 0 : AFTER_GL_CALL;
1060 0 : }
1061 :
1062 : void fDisableClientState(GLenum capability) {
1063 : BEFORE_GL_CALL;
1064 : mSymbols.fDisableClientState(capability);
1065 : AFTER_GL_CALL;
1066 : }
1067 :
1068 0 : void fDisableVertexAttribArray(GLuint index) {
1069 0 : BEFORE_GL_CALL;
1070 0 : mSymbols.fDisableVertexAttribArray(index);
1071 0 : AFTER_GL_CALL;
1072 0 : }
1073 :
1074 0 : void fDrawBuffer(GLenum mode) {
1075 0 : BEFORE_GL_CALL;
1076 0 : mSymbols.fDrawBuffer(mode);
1077 0 : AFTER_GL_CALL;
1078 0 : }
1079 :
1080 : private:
1081 0 : void raw_fDrawArrays(GLenum mode, GLint first, GLsizei count) {
1082 0 : BEFORE_GL_CALL;
1083 0 : mSymbols.fDrawArrays(mode, first, count);
1084 0 : AFTER_GL_CALL;
1085 0 : }
1086 :
1087 0 : void raw_fDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) {
1088 0 : BEFORE_GL_CALL;
1089 0 : mSymbols.fDrawElements(mode, count, type, indices);
1090 0 : AFTER_GL_CALL;
1091 0 : }
1092 :
1093 : public:
1094 0 : void fDrawArrays(GLenum mode, GLint first, GLsizei count) {
1095 0 : BeforeGLDrawCall();
1096 0 : raw_fDrawArrays(mode, first, count);
1097 0 : AfterGLDrawCall();
1098 0 : }
1099 :
1100 0 : void fDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) {
1101 0 : BeforeGLDrawCall();
1102 0 : raw_fDrawElements(mode, count, type, indices);
1103 0 : AfterGLDrawCall();
1104 0 : }
1105 :
1106 0 : void fEnable(GLenum capability) {
1107 0 : BEFORE_GL_CALL;
1108 0 : mSymbols.fEnable(capability);
1109 0 : AFTER_GL_CALL;
1110 0 : }
1111 :
1112 : void fEnableClientState(GLenum capability) {
1113 : BEFORE_GL_CALL;
1114 : mSymbols.fEnableClientState(capability);
1115 : AFTER_GL_CALL;
1116 : }
1117 :
1118 0 : void fEnableVertexAttribArray(GLuint index) {
1119 0 : BEFORE_GL_CALL;
1120 0 : mSymbols.fEnableVertexAttribArray(index);
1121 0 : AFTER_GL_CALL;
1122 0 : }
1123 :
1124 0 : void fEndQuery(GLenum target) {
1125 0 : BEFORE_GL_CALL;
1126 0 : ASSERT_SYMBOL_PRESENT(fEndQuery);
1127 0 : mSymbols.fEndQuery(target);
1128 0 : AFTER_GL_CALL;
1129 0 : }
1130 :
1131 0 : void fFinish() {
1132 0 : BEFORE_GL_CALL;
1133 0 : mSymbols.fFinish();
1134 0 : AFTER_GL_CALL;
1135 0 : mHeavyGLCallsSinceLastFlush = false;
1136 0 : }
1137 :
1138 0 : void fFlush() {
1139 0 : BEFORE_GL_CALL;
1140 0 : mSymbols.fFlush();
1141 0 : AFTER_GL_CALL;
1142 0 : mHeavyGLCallsSinceLastFlush = false;
1143 0 : }
1144 :
1145 0 : void fFrontFace(GLenum face) {
1146 0 : BEFORE_GL_CALL;
1147 0 : mSymbols.fFrontFace(face);
1148 0 : AFTER_GL_CALL;
1149 0 : }
1150 :
1151 0 : void fGetActiveAttrib(GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
1152 0 : BEFORE_GL_CALL;
1153 0 : mSymbols.fGetActiveAttrib(program, index, maxLength, length, size, type, name);
1154 0 : AFTER_GL_CALL;
1155 0 : }
1156 :
1157 0 : void fGetActiveUniform(GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name) {
1158 0 : BEFORE_GL_CALL;
1159 0 : mSymbols.fGetActiveUniform(program, index, maxLength, length, size, type, name);
1160 0 : AFTER_GL_CALL;
1161 0 : }
1162 :
1163 : void fGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) {
1164 : BEFORE_GL_CALL;
1165 : mSymbols.fGetAttachedShaders(program, maxCount, count, shaders);
1166 : AFTER_GL_CALL;
1167 : }
1168 :
1169 0 : GLint fGetAttribLocation(GLuint program, const GLchar* name) {
1170 0 : BEFORE_GL_CALL;
1171 0 : GLint retval = mSymbols.fGetAttribLocation(program, name);
1172 0 : AFTER_GL_CALL;
1173 0 : return retval;
1174 : }
1175 :
1176 : private:
1177 0 : void raw_fGetIntegerv(GLenum pname, GLint* params) {
1178 0 : BEFORE_GL_CALL;
1179 0 : mSymbols.fGetIntegerv(pname, params);
1180 0 : AFTER_GL_CALL;
1181 0 : }
1182 :
1183 : public:
1184 :
1185 : void fGetIntegerv(GLenum pname, GLint* params);
1186 :
1187 0 : void GetUIntegerv(GLenum pname, GLuint* params) {
1188 0 : fGetIntegerv(pname, reinterpret_cast<GLint*>(params));
1189 0 : }
1190 :
1191 : template<typename T>
1192 0 : T GetIntAs(GLenum pname) {
1193 : static_assert(sizeof(T) == sizeof(GLint), "Invalid T.");
1194 0 : T ret = 0;
1195 0 : fGetIntegerv(pname, (GLint*)&ret);
1196 0 : return ret;
1197 : }
1198 :
1199 0 : void fGetFloatv(GLenum pname, GLfloat* params) {
1200 0 : BEFORE_GL_CALL;
1201 0 : mSymbols.fGetFloatv(pname, params);
1202 0 : AFTER_GL_CALL;
1203 0 : }
1204 :
1205 0 : void fGetBooleanv(GLenum pname, realGLboolean* params) {
1206 0 : BEFORE_GL_CALL;
1207 0 : mSymbols.fGetBooleanv(pname, params);
1208 0 : AFTER_GL_CALL;
1209 0 : }
1210 :
1211 0 : void fGetBufferParameteriv(GLenum target, GLenum pname, GLint* params) {
1212 0 : BEFORE_GL_CALL;
1213 0 : mSymbols.fGetBufferParameteriv(target, pname, params);
1214 0 : AFTER_GL_CALL;
1215 0 : }
1216 :
1217 : GLuint fGetDebugMessageLog(GLuint count, GLsizei bufsize, GLenum* sources, GLenum* types, GLuint* ids, GLenum* severities, GLsizei* lengths, GLchar* messageLog) {
1218 : BEFORE_GL_CALL;
1219 : ASSERT_SYMBOL_PRESENT(fGetDebugMessageLog);
1220 : GLuint ret = mSymbols.fGetDebugMessageLog(count, bufsize, sources, types, ids, severities, lengths, messageLog);
1221 : AFTER_GL_CALL;
1222 : return ret;
1223 : }
1224 :
1225 : void fGetPointerv(GLenum pname, GLvoid** params) {
1226 : BEFORE_GL_CALL;
1227 : ASSERT_SYMBOL_PRESENT(fGetPointerv);
1228 : mSymbols.fGetPointerv(pname, params);
1229 : AFTER_GL_CALL;
1230 : }
1231 :
1232 : void fGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei* length, GLchar* label) {
1233 : BEFORE_GL_CALL;
1234 : ASSERT_SYMBOL_PRESENT(fGetObjectLabel);
1235 : mSymbols.fGetObjectLabel(identifier, name, bufSize, length, label);
1236 : AFTER_GL_CALL;
1237 : }
1238 :
1239 : void fGetObjectPtrLabel(const GLvoid* ptr, GLsizei bufSize, GLsizei* length, GLchar* label) {
1240 : BEFORE_GL_CALL;
1241 : ASSERT_SYMBOL_PRESENT(fGetObjectPtrLabel);
1242 : mSymbols.fGetObjectPtrLabel(ptr, bufSize, length, label);
1243 : AFTER_GL_CALL;
1244 : }
1245 :
1246 0 : void fGenerateMipmap(GLenum target) {
1247 0 : BEFORE_GL_CALL;
1248 0 : mSymbols.fGenerateMipmap(target);
1249 0 : AFTER_GL_CALL;
1250 0 : }
1251 :
1252 0 : void fGetProgramiv(GLuint program, GLenum pname, GLint* param) {
1253 0 : BEFORE_GL_CALL;
1254 0 : mSymbols.fGetProgramiv(program, pname, param);
1255 0 : AFTER_GL_CALL;
1256 0 : }
1257 :
1258 0 : void fGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
1259 0 : BEFORE_GL_CALL;
1260 0 : mSymbols.fGetProgramInfoLog(program, bufSize, length, infoLog);
1261 0 : AFTER_GL_CALL;
1262 0 : }
1263 :
1264 0 : void fTexParameteri(GLenum target, GLenum pname, GLint param) {
1265 0 : BEFORE_GL_CALL;
1266 0 : mSymbols.fTexParameteri(target, pname, param);
1267 0 : AFTER_GL_CALL;
1268 0 : }
1269 :
1270 0 : void fTexParameteriv(GLenum target, GLenum pname, const GLint* params) {
1271 0 : BEFORE_GL_CALL;
1272 0 : mSymbols.fTexParameteriv(target, pname, params);
1273 0 : AFTER_GL_CALL;
1274 0 : }
1275 :
1276 0 : void fTexParameterf(GLenum target, GLenum pname, GLfloat param) {
1277 0 : BEFORE_GL_CALL;
1278 0 : mSymbols.fTexParameterf(target, pname, param);
1279 0 : AFTER_GL_CALL;
1280 0 : }
1281 :
1282 0 : const GLubyte* fGetString(GLenum name) {
1283 0 : BEFORE_GL_CALL;
1284 0 : const GLubyte* result = mSymbols.fGetString(name);
1285 0 : AFTER_GL_CALL;
1286 0 : return result;
1287 : }
1288 :
1289 0 : void fGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid* img) {
1290 0 : BEFORE_GL_CALL;
1291 0 : ASSERT_SYMBOL_PRESENT(fGetTexImage);
1292 0 : mSymbols.fGetTexImage(target, level, format, type, img);
1293 0 : AFTER_GL_CALL;
1294 0 : }
1295 :
1296 0 : void fGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params)
1297 : {
1298 0 : BEFORE_GL_CALL;
1299 0 : ASSERT_SYMBOL_PRESENT(fGetTexLevelParameteriv);
1300 0 : mSymbols.fGetTexLevelParameteriv(target, level, pname, params);
1301 0 : AFTER_GL_CALL;
1302 0 : }
1303 :
1304 0 : void fGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params) {
1305 0 : BEFORE_GL_CALL;
1306 0 : mSymbols.fGetTexParameterfv(target, pname, params);
1307 0 : AFTER_GL_CALL;
1308 0 : }
1309 :
1310 0 : void fGetTexParameteriv(GLenum target, GLenum pname, GLint* params) {
1311 0 : BEFORE_GL_CALL;
1312 0 : mSymbols.fGetTexParameteriv(target, pname, params);
1313 0 : AFTER_GL_CALL;
1314 0 : }
1315 :
1316 0 : void fGetUniformfv(GLuint program, GLint location, GLfloat* params) {
1317 0 : BEFORE_GL_CALL;
1318 0 : mSymbols.fGetUniformfv(program, location, params);
1319 0 : AFTER_GL_CALL;
1320 0 : }
1321 :
1322 0 : void fGetUniformiv(GLuint program, GLint location, GLint* params) {
1323 0 : BEFORE_GL_CALL;
1324 0 : mSymbols.fGetUniformiv(program, location, params);
1325 0 : AFTER_GL_CALL;
1326 0 : }
1327 :
1328 0 : void fGetUniformuiv(GLuint program, GLint location, GLuint* params) {
1329 0 : BEFORE_GL_CALL;
1330 0 : ASSERT_SYMBOL_PRESENT(fGetUniformuiv);
1331 0 : mSymbols.fGetUniformuiv(program, location, params);
1332 0 : AFTER_GL_CALL;
1333 0 : }
1334 :
1335 0 : GLint fGetUniformLocation (GLint programObj, const GLchar* name) {
1336 0 : BEFORE_GL_CALL;
1337 0 : GLint retval = mSymbols.fGetUniformLocation(programObj, name);
1338 0 : AFTER_GL_CALL;
1339 0 : return retval;
1340 : }
1341 :
1342 0 : void fGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* retval) {
1343 0 : BEFORE_GL_CALL;
1344 0 : mSymbols.fGetVertexAttribfv(index, pname, retval);
1345 0 : AFTER_GL_CALL;
1346 0 : }
1347 :
1348 0 : void fGetVertexAttribiv(GLuint index, GLenum pname, GLint* retval) {
1349 0 : BEFORE_GL_CALL;
1350 0 : mSymbols.fGetVertexAttribiv(index, pname, retval);
1351 0 : AFTER_GL_CALL;
1352 0 : }
1353 :
1354 0 : void fGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid** retval) {
1355 0 : BEFORE_GL_CALL;
1356 0 : mSymbols.fGetVertexAttribPointerv(index, pname, retval);
1357 0 : AFTER_GL_CALL;
1358 0 : }
1359 :
1360 0 : void fHint(GLenum target, GLenum mode) {
1361 0 : BEFORE_GL_CALL;
1362 0 : mSymbols.fHint(target, mode);
1363 0 : AFTER_GL_CALL;
1364 0 : }
1365 :
1366 0 : realGLboolean fIsBuffer(GLuint buffer) {
1367 0 : BEFORE_GL_CALL;
1368 0 : realGLboolean retval = mSymbols.fIsBuffer(buffer);
1369 0 : AFTER_GL_CALL;
1370 0 : return retval;
1371 : }
1372 :
1373 0 : realGLboolean fIsEnabled(GLenum capability) {
1374 0 : BEFORE_GL_CALL;
1375 0 : realGLboolean retval = mSymbols.fIsEnabled(capability);
1376 0 : AFTER_GL_CALL;
1377 0 : return retval;
1378 : }
1379 :
1380 : realGLboolean fIsProgram(GLuint program) {
1381 : BEFORE_GL_CALL;
1382 : realGLboolean retval = mSymbols.fIsProgram(program);
1383 : AFTER_GL_CALL;
1384 : return retval;
1385 : }
1386 :
1387 : realGLboolean fIsShader(GLuint shader) {
1388 : BEFORE_GL_CALL;
1389 : realGLboolean retval = mSymbols.fIsShader(shader);
1390 : AFTER_GL_CALL;
1391 : return retval;
1392 : }
1393 :
1394 0 : realGLboolean fIsTexture(GLuint texture) {
1395 0 : BEFORE_GL_CALL;
1396 0 : realGLboolean retval = mSymbols.fIsTexture(texture);
1397 0 : AFTER_GL_CALL;
1398 0 : return retval;
1399 : }
1400 :
1401 0 : void fLineWidth(GLfloat width) {
1402 0 : BEFORE_GL_CALL;
1403 0 : mSymbols.fLineWidth(width);
1404 0 : AFTER_GL_CALL;
1405 0 : }
1406 :
1407 0 : void fLinkProgram(GLuint program) {
1408 0 : BEFORE_GL_CALL;
1409 0 : mSymbols.fLinkProgram(program);
1410 0 : AFTER_GL_CALL;
1411 0 : }
1412 :
1413 : void fObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar* label) {
1414 : BEFORE_GL_CALL;
1415 : ASSERT_SYMBOL_PRESENT(fObjectLabel);
1416 : mSymbols.fObjectLabel(identifier, name, length, label);
1417 : AFTER_GL_CALL;
1418 : }
1419 :
1420 : void fObjectPtrLabel(const GLvoid* ptr, GLsizei length, const GLchar* label) {
1421 : BEFORE_GL_CALL;
1422 : ASSERT_SYMBOL_PRESENT(fObjectPtrLabel);
1423 : mSymbols.fObjectPtrLabel(ptr, length, label);
1424 : AFTER_GL_CALL;
1425 : }
1426 :
1427 : void fLoadIdentity() {
1428 : BEFORE_GL_CALL;
1429 : mSymbols.fLoadIdentity();
1430 : AFTER_GL_CALL;
1431 : }
1432 :
1433 : void fLoadMatrixf(const GLfloat* matrix) {
1434 : BEFORE_GL_CALL;
1435 : mSymbols.fLoadMatrixf(matrix);
1436 : AFTER_GL_CALL;
1437 : }
1438 :
1439 : void fMatrixMode(GLenum mode) {
1440 : BEFORE_GL_CALL;
1441 : mSymbols.fMatrixMode(mode);
1442 : AFTER_GL_CALL;
1443 : }
1444 :
1445 0 : void fPixelStorei(GLenum pname, GLint param) {
1446 0 : BEFORE_GL_CALL;
1447 0 : mSymbols.fPixelStorei(pname, param);
1448 0 : AFTER_GL_CALL;
1449 0 : }
1450 :
1451 : void fTextureRangeAPPLE(GLenum target, GLsizei length, GLvoid* pointer) {
1452 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pointer);
1453 : BEFORE_GL_CALL;
1454 : mSymbols.fTextureRangeAPPLE(target, length, pointer);
1455 : AFTER_GL_CALL;
1456 : }
1457 :
1458 : void fPointParameterf(GLenum pname, GLfloat param) {
1459 : BEFORE_GL_CALL;
1460 : mSymbols.fPointParameterf(pname, param);
1461 : AFTER_GL_CALL;
1462 : }
1463 :
1464 0 : void fPolygonMode(GLenum face, GLenum mode) {
1465 0 : BEFORE_GL_CALL;
1466 0 : mSymbols.fPolygonMode(face, mode);
1467 0 : AFTER_GL_CALL;
1468 0 : }
1469 :
1470 0 : void fPolygonOffset(GLfloat factor, GLfloat bias) {
1471 0 : BEFORE_GL_CALL;
1472 0 : mSymbols.fPolygonOffset(factor, bias);
1473 0 : AFTER_GL_CALL;
1474 0 : }
1475 :
1476 : void fPopDebugGroup() {
1477 : BEFORE_GL_CALL;
1478 : ASSERT_SYMBOL_PRESENT(fPopDebugGroup);
1479 : mSymbols.fPopDebugGroup();
1480 : AFTER_GL_CALL;
1481 : }
1482 :
1483 : void fPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar* message) {
1484 : BEFORE_GL_CALL;
1485 : ASSERT_SYMBOL_PRESENT(fPushDebugGroup);
1486 : mSymbols.fPushDebugGroup(source, id, length, message);
1487 : AFTER_GL_CALL;
1488 : }
1489 :
1490 0 : void fReadBuffer(GLenum mode) {
1491 0 : BEFORE_GL_CALL;
1492 0 : mSymbols.fReadBuffer(mode);
1493 0 : AFTER_GL_CALL;
1494 0 : }
1495 :
1496 0 : void raw_fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) {
1497 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1498 0 : BEFORE_GL_CALL;
1499 0 : mSymbols.fReadPixels(x, y, width, height, format, type, pixels);
1500 0 : AFTER_GL_CALL;
1501 0 : mHeavyGLCallsSinceLastFlush = true;
1502 0 : }
1503 :
1504 : void fReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format,
1505 : GLenum type, GLvoid* pixels);
1506 :
1507 : public:
1508 0 : void fSampleCoverage(GLclampf value, realGLboolean invert) {
1509 0 : BEFORE_GL_CALL;
1510 0 : mSymbols.fSampleCoverage(value, invert);
1511 0 : AFTER_GL_CALL;
1512 0 : }
1513 :
1514 0 : void fScissor(GLint x, GLint y, GLsizei width, GLsizei height) {
1515 0 : if (mScissorRect[0] == x &&
1516 0 : mScissorRect[1] == y &&
1517 0 : mScissorRect[2] == width &&
1518 0 : mScissorRect[3] == height)
1519 : {
1520 0 : return;
1521 : }
1522 0 : mScissorRect[0] = x;
1523 0 : mScissorRect[1] = y;
1524 0 : mScissorRect[2] = width;
1525 0 : mScissorRect[3] = height;
1526 0 : BEFORE_GL_CALL;
1527 0 : mSymbols.fScissor(x, y, width, height);
1528 0 : AFTER_GL_CALL;
1529 : }
1530 :
1531 0 : void fStencilFunc(GLenum func, GLint reference, GLuint mask) {
1532 0 : BEFORE_GL_CALL;
1533 0 : mSymbols.fStencilFunc(func, reference, mask);
1534 0 : AFTER_GL_CALL;
1535 0 : }
1536 :
1537 0 : void fStencilFuncSeparate(GLenum frontfunc, GLenum backfunc, GLint reference, GLuint mask) {
1538 0 : BEFORE_GL_CALL;
1539 0 : mSymbols.fStencilFuncSeparate(frontfunc, backfunc, reference, mask);
1540 0 : AFTER_GL_CALL;
1541 0 : }
1542 :
1543 0 : void fStencilMask(GLuint mask) {
1544 0 : BEFORE_GL_CALL;
1545 0 : mSymbols.fStencilMask(mask);
1546 0 : AFTER_GL_CALL;
1547 0 : }
1548 :
1549 0 : void fStencilMaskSeparate(GLenum face, GLuint mask) {
1550 0 : BEFORE_GL_CALL;
1551 0 : mSymbols.fStencilMaskSeparate(face, mask);
1552 0 : AFTER_GL_CALL;
1553 0 : }
1554 :
1555 0 : void fStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
1556 0 : BEFORE_GL_CALL;
1557 0 : mSymbols.fStencilOp(fail, zfail, zpass);
1558 0 : AFTER_GL_CALL;
1559 0 : }
1560 :
1561 0 : void fStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) {
1562 0 : BEFORE_GL_CALL;
1563 0 : mSymbols.fStencilOpSeparate(face, sfail, dpfail, dppass);
1564 0 : AFTER_GL_CALL;
1565 0 : }
1566 :
1567 : void fTexGeni(GLenum coord, GLenum pname, GLint param) {
1568 : BEFORE_GL_CALL;
1569 : mSymbols.fTexGeni(coord, pname, param);
1570 : AFTER_GL_CALL;
1571 : }
1572 :
1573 : void fTexGenf(GLenum coord, GLenum pname, GLfloat param) {
1574 : BEFORE_GL_CALL;
1575 : mSymbols.fTexGenf(coord, pname, param);
1576 : AFTER_GL_CALL;
1577 : }
1578 :
1579 : void fTexGenfv(GLenum coord, GLenum pname, const GLfloat* params) {
1580 : BEFORE_GL_CALL;
1581 : mSymbols.fTexGenfv(coord, pname, params);
1582 : AFTER_GL_CALL;
1583 : }
1584 :
1585 : private:
1586 0 : void raw_fTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) {
1587 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1588 0 : BEFORE_GL_CALL;
1589 0 : mSymbols.fTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
1590 0 : AFTER_GL_CALL;
1591 0 : mHeavyGLCallsSinceLastFlush = true;
1592 0 : }
1593 :
1594 : public:
1595 : void fTexImage2D(GLenum target, GLint level, GLint internalformat,
1596 : GLsizei width, GLsizei height, GLint border,
1597 : GLenum format, GLenum type, const GLvoid* pixels);
1598 :
1599 0 : void fTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) {
1600 0 : ASSERT_NOT_PASSING_STACK_BUFFER_TO_GL(pixels);
1601 0 : BEFORE_GL_CALL;
1602 0 : mSymbols.fTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
1603 0 : AFTER_GL_CALL;
1604 0 : mHeavyGLCallsSinceLastFlush = true;
1605 0 : }
1606 :
1607 0 : void fUniform1f(GLint location, GLfloat v0) {
1608 0 : BEFORE_GL_CALL;
1609 0 : mSymbols.fUniform1f(location, v0);
1610 0 : AFTER_GL_CALL;
1611 0 : }
1612 :
1613 0 : void fUniform1fv(GLint location, GLsizei count, const GLfloat* value) {
1614 0 : BEFORE_GL_CALL;
1615 0 : mSymbols.fUniform1fv(location, count, value);
1616 0 : AFTER_GL_CALL;
1617 0 : }
1618 :
1619 0 : void fUniform1i(GLint location, GLint v0) {
1620 0 : BEFORE_GL_CALL;
1621 0 : mSymbols.fUniform1i(location, v0);
1622 0 : AFTER_GL_CALL;
1623 0 : }
1624 :
1625 0 : void fUniform1iv(GLint location, GLsizei count, const GLint* value) {
1626 0 : BEFORE_GL_CALL;
1627 0 : mSymbols.fUniform1iv(location, count, value);
1628 0 : AFTER_GL_CALL;
1629 0 : }
1630 :
1631 0 : void fUniform2f(GLint location, GLfloat v0, GLfloat v1) {
1632 0 : BEFORE_GL_CALL;
1633 0 : mSymbols.fUniform2f(location, v0, v1);
1634 0 : AFTER_GL_CALL;
1635 0 : }
1636 :
1637 0 : void fUniform2fv(GLint location, GLsizei count, const GLfloat* value) {
1638 0 : BEFORE_GL_CALL;
1639 0 : mSymbols.fUniform2fv(location, count, value);
1640 0 : AFTER_GL_CALL;
1641 0 : }
1642 :
1643 0 : void fUniform2i(GLint location, GLint v0, GLint v1) {
1644 0 : BEFORE_GL_CALL;
1645 0 : mSymbols.fUniform2i(location, v0, v1);
1646 0 : AFTER_GL_CALL;
1647 0 : }
1648 :
1649 0 : void fUniform2iv(GLint location, GLsizei count, const GLint* value) {
1650 0 : BEFORE_GL_CALL;
1651 0 : mSymbols.fUniform2iv(location, count, value);
1652 0 : AFTER_GL_CALL;
1653 0 : }
1654 :
1655 0 : void fUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) {
1656 0 : BEFORE_GL_CALL;
1657 0 : mSymbols.fUniform3f(location, v0, v1, v2);
1658 0 : AFTER_GL_CALL;
1659 0 : }
1660 :
1661 0 : void fUniform3fv(GLint location, GLsizei count, const GLfloat* value) {
1662 0 : BEFORE_GL_CALL;
1663 0 : mSymbols.fUniform3fv(location, count, value);
1664 0 : AFTER_GL_CALL;
1665 0 : }
1666 :
1667 0 : void fUniform3i(GLint location, GLint v0, GLint v1, GLint v2) {
1668 0 : BEFORE_GL_CALL;
1669 0 : mSymbols.fUniform3i(location, v0, v1, v2);
1670 0 : AFTER_GL_CALL;
1671 0 : }
1672 :
1673 0 : void fUniform3iv(GLint location, GLsizei count, const GLint* value) {
1674 0 : BEFORE_GL_CALL;
1675 0 : mSymbols.fUniform3iv(location, count, value);
1676 0 : AFTER_GL_CALL;
1677 0 : }
1678 :
1679 0 : void fUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
1680 0 : BEFORE_GL_CALL;
1681 0 : mSymbols.fUniform4f(location, v0, v1, v2, v3);
1682 0 : AFTER_GL_CALL;
1683 0 : }
1684 :
1685 0 : void fUniform4fv(GLint location, GLsizei count, const GLfloat* value) {
1686 0 : BEFORE_GL_CALL;
1687 0 : mSymbols.fUniform4fv(location, count, value);
1688 0 : AFTER_GL_CALL;
1689 0 : }
1690 :
1691 0 : void fUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) {
1692 0 : BEFORE_GL_CALL;
1693 0 : mSymbols.fUniform4i(location, v0, v1, v2, v3);
1694 0 : AFTER_GL_CALL;
1695 0 : }
1696 :
1697 0 : void fUniform4iv(GLint location, GLsizei count, const GLint* value) {
1698 0 : BEFORE_GL_CALL;
1699 0 : mSymbols.fUniform4iv(location, count, value);
1700 0 : AFTER_GL_CALL;
1701 0 : }
1702 :
1703 0 : void fUniformMatrix2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1704 0 : BEFORE_GL_CALL;
1705 0 : mSymbols.fUniformMatrix2fv(location, count, transpose, value);
1706 0 : AFTER_GL_CALL;
1707 0 : }
1708 :
1709 0 : void fUniformMatrix2x3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1710 0 : BEFORE_GL_CALL;
1711 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix2x3fv);
1712 0 : mSymbols.fUniformMatrix2x3fv(location, count, transpose, value);
1713 0 : AFTER_GL_CALL;
1714 0 : }
1715 :
1716 0 : void fUniformMatrix2x4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1717 0 : BEFORE_GL_CALL;
1718 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix2x4fv);
1719 0 : mSymbols.fUniformMatrix2x4fv(location, count, transpose, value);
1720 0 : AFTER_GL_CALL;
1721 0 : }
1722 :
1723 0 : void fUniformMatrix3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1724 0 : BEFORE_GL_CALL;
1725 0 : mSymbols.fUniformMatrix3fv(location, count, transpose, value);
1726 0 : AFTER_GL_CALL;
1727 0 : }
1728 :
1729 0 : void fUniformMatrix3x2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1730 0 : BEFORE_GL_CALL;
1731 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix3x2fv);
1732 0 : mSymbols.fUniformMatrix3x2fv(location, count, transpose, value);
1733 0 : AFTER_GL_CALL;
1734 0 : }
1735 :
1736 0 : void fUniformMatrix3x4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1737 0 : BEFORE_GL_CALL;
1738 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix3x4fv);
1739 0 : mSymbols.fUniformMatrix3x4fv(location, count, transpose, value);
1740 0 : AFTER_GL_CALL;
1741 0 : }
1742 :
1743 0 : void fUniformMatrix4fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1744 0 : BEFORE_GL_CALL;
1745 0 : mSymbols.fUniformMatrix4fv(location, count, transpose, value);
1746 0 : AFTER_GL_CALL;
1747 0 : }
1748 :
1749 0 : void fUniformMatrix4x2fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1750 0 : BEFORE_GL_CALL;
1751 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix4x2fv);
1752 0 : mSymbols.fUniformMatrix4x2fv(location, count, transpose, value);
1753 0 : AFTER_GL_CALL;
1754 0 : }
1755 :
1756 0 : void fUniformMatrix4x3fv(GLint location, GLsizei count, realGLboolean transpose, const GLfloat* value) {
1757 0 : BEFORE_GL_CALL;
1758 0 : ASSERT_SYMBOL_PRESENT(fUniformMatrix4x3fv);
1759 0 : mSymbols.fUniformMatrix4x3fv(location, count, transpose, value);
1760 0 : AFTER_GL_CALL;
1761 0 : }
1762 :
1763 0 : void fUseProgram(GLuint program) {
1764 0 : BEFORE_GL_CALL;
1765 0 : mSymbols.fUseProgram(program);
1766 0 : AFTER_GL_CALL;
1767 0 : }
1768 :
1769 0 : void fValidateProgram(GLuint program) {
1770 0 : BEFORE_GL_CALL;
1771 0 : mSymbols.fValidateProgram(program);
1772 0 : AFTER_GL_CALL;
1773 0 : }
1774 :
1775 0 : void fVertexAttribPointer(GLuint index, GLint size, GLenum type, realGLboolean normalized, GLsizei stride, const GLvoid* pointer) {
1776 0 : BEFORE_GL_CALL;
1777 0 : mSymbols.fVertexAttribPointer(index, size, type, normalized, stride, pointer);
1778 0 : AFTER_GL_CALL;
1779 0 : }
1780 :
1781 0 : void fVertexAttrib1f(GLuint index, GLfloat x) {
1782 0 : BEFORE_GL_CALL;
1783 0 : mSymbols.fVertexAttrib1f(index, x);
1784 0 : AFTER_GL_CALL;
1785 0 : }
1786 :
1787 : void fVertexAttrib2f(GLuint index, GLfloat x, GLfloat y) {
1788 : BEFORE_GL_CALL;
1789 : mSymbols.fVertexAttrib2f(index, x, y);
1790 : AFTER_GL_CALL;
1791 : }
1792 :
1793 : void fVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
1794 : BEFORE_GL_CALL;
1795 : mSymbols.fVertexAttrib3f(index, x, y, z);
1796 : AFTER_GL_CALL;
1797 : }
1798 :
1799 0 : void fVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
1800 0 : BEFORE_GL_CALL;
1801 0 : mSymbols.fVertexAttrib4f(index, x, y, z, w);
1802 0 : AFTER_GL_CALL;
1803 0 : }
1804 :
1805 : void fVertexAttrib1fv(GLuint index, const GLfloat* v) {
1806 : BEFORE_GL_CALL;
1807 : mSymbols.fVertexAttrib1fv(index, v);
1808 : AFTER_GL_CALL;
1809 : }
1810 :
1811 0 : void fVertexAttrib2fv(GLuint index, const GLfloat* v) {
1812 0 : BEFORE_GL_CALL;
1813 0 : mSymbols.fVertexAttrib2fv(index, v);
1814 0 : AFTER_GL_CALL;
1815 0 : }
1816 :
1817 0 : void fVertexAttrib3fv(GLuint index, const GLfloat* v) {
1818 0 : BEFORE_GL_CALL;
1819 0 : mSymbols.fVertexAttrib3fv(index, v);
1820 0 : AFTER_GL_CALL;
1821 0 : }
1822 :
1823 0 : void fVertexAttrib4fv(GLuint index, const GLfloat* v) {
1824 0 : BEFORE_GL_CALL;
1825 0 : mSymbols.fVertexAttrib4fv(index, v);
1826 0 : AFTER_GL_CALL;
1827 0 : }
1828 :
1829 : void fVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) {
1830 : BEFORE_GL_CALL;
1831 : mSymbols.fVertexPointer(size, type, stride, pointer);
1832 : AFTER_GL_CALL;
1833 : }
1834 :
1835 0 : void fCompileShader(GLuint shader) {
1836 0 : BEFORE_GL_CALL;
1837 0 : mSymbols.fCompileShader(shader);
1838 0 : AFTER_GL_CALL;
1839 0 : }
1840 :
1841 : private:
1842 :
1843 : friend class SharedSurface_IOSurface;
1844 :
1845 0 : void raw_fCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
1846 : {
1847 0 : BEFORE_GL_CALL;
1848 0 : mSymbols.fCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
1849 0 : AFTER_GL_CALL;
1850 0 : }
1851 :
1852 0 : void raw_fCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
1853 : {
1854 0 : BEFORE_GL_CALL;
1855 0 : mSymbols.fCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
1856 0 : AFTER_GL_CALL;
1857 0 : }
1858 :
1859 : public:
1860 0 : void fGetShaderiv(GLuint shader, GLenum pname, GLint* param) {
1861 0 : BEFORE_GL_CALL;
1862 0 : mSymbols.fGetShaderiv(shader, pname, param);
1863 0 : AFTER_GL_CALL;
1864 0 : }
1865 :
1866 0 : void fGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
1867 0 : BEFORE_GL_CALL;
1868 0 : mSymbols.fGetShaderInfoLog(shader, bufSize, length, infoLog);
1869 0 : AFTER_GL_CALL;
1870 0 : }
1871 :
1872 : private:
1873 0 : void raw_fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
1874 0 : MOZ_ASSERT(IsGLES());
1875 :
1876 0 : BEFORE_GL_CALL;
1877 0 : ASSERT_SYMBOL_PRESENT(fGetShaderPrecisionFormat);
1878 0 : mSymbols.fGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1879 0 : AFTER_GL_CALL;
1880 0 : }
1881 :
1882 : public:
1883 0 : void fGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
1884 0 : if (IsGLES()) {
1885 0 : raw_fGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
1886 : } else {
1887 : // Fall back to automatic values because almost all desktop hardware supports the OpenGL standard precisions.
1888 0 : GetShaderPrecisionFormatNonES2(shadertype, precisiontype, range, precision);
1889 : }
1890 0 : }
1891 :
1892 : void fGetShaderSource(GLint obj, GLsizei maxLength, GLsizei* length, GLchar* source) {
1893 : BEFORE_GL_CALL;
1894 : mSymbols.fGetShaderSource(obj, maxLength, length, source);
1895 : AFTER_GL_CALL;
1896 : }
1897 :
1898 0 : void fShaderSource(GLuint shader, GLsizei count, const GLchar* const* strings, const GLint* lengths) {
1899 0 : BEFORE_GL_CALL;
1900 0 : mSymbols.fShaderSource(shader, count, strings, lengths);
1901 0 : AFTER_GL_CALL;
1902 0 : }
1903 :
1904 : private:
1905 : friend class SharedSurface;
1906 :
1907 0 : void raw_fBindFramebuffer(GLenum target, GLuint framebuffer) {
1908 0 : BEFORE_GL_CALL;
1909 0 : mSymbols.fBindFramebuffer(target, framebuffer);
1910 0 : AFTER_GL_CALL;
1911 0 : }
1912 :
1913 : public:
1914 0 : void fBindRenderbuffer(GLenum target, GLuint renderbuffer) {
1915 0 : BEFORE_GL_CALL;
1916 0 : mSymbols.fBindRenderbuffer(target, renderbuffer);
1917 0 : AFTER_GL_CALL;
1918 0 : }
1919 :
1920 0 : GLenum fCheckFramebufferStatus(GLenum target) {
1921 0 : BEFORE_GL_CALL;
1922 0 : GLenum retval = mSymbols.fCheckFramebufferStatus(target);
1923 0 : AFTER_GL_CALL;
1924 0 : return retval;
1925 : }
1926 :
1927 0 : void fFramebufferRenderbuffer(GLenum target, GLenum attachmentPoint, GLenum renderbufferTarget, GLuint renderbuffer) {
1928 0 : BEFORE_GL_CALL;
1929 0 : mSymbols.fFramebufferRenderbuffer(target, attachmentPoint, renderbufferTarget, renderbuffer);
1930 0 : AFTER_GL_CALL;
1931 0 : }
1932 :
1933 0 : void fFramebufferTexture2D(GLenum target, GLenum attachmentPoint, GLenum textureTarget, GLuint texture, GLint level) {
1934 0 : BEFORE_GL_CALL;
1935 0 : mSymbols.fFramebufferTexture2D(target, attachmentPoint, textureTarget, texture, level);
1936 0 : AFTER_GL_CALL;
1937 0 : if (mNeedsCheckAfterAttachTextureToFb) {
1938 0 : fCheckFramebufferStatus(target);
1939 : }
1940 0 : }
1941 :
1942 0 : void fFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) {
1943 0 : BEFORE_GL_CALL;
1944 0 : ASSERT_SYMBOL_PRESENT(fFramebufferTextureLayer);
1945 0 : mSymbols.fFramebufferTextureLayer(target, attachment, texture, level, layer);
1946 0 : AFTER_GL_CALL;
1947 0 : }
1948 :
1949 0 : void fGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* value) {
1950 0 : BEFORE_GL_CALL;
1951 0 : mSymbols.fGetFramebufferAttachmentParameteriv(target, attachment, pname, value);
1952 0 : AFTER_GL_CALL;
1953 0 : }
1954 :
1955 0 : void fGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* value) {
1956 0 : BEFORE_GL_CALL;
1957 0 : mSymbols.fGetRenderbufferParameteriv(target, pname, value);
1958 0 : AFTER_GL_CALL;
1959 0 : }
1960 :
1961 0 : realGLboolean fIsFramebuffer (GLuint framebuffer) {
1962 0 : BEFORE_GL_CALL;
1963 0 : realGLboolean retval = mSymbols.fIsFramebuffer(framebuffer);
1964 0 : AFTER_GL_CALL;
1965 0 : return retval;
1966 : }
1967 :
1968 : public:
1969 0 : realGLboolean fIsRenderbuffer (GLuint renderbuffer) {
1970 0 : BEFORE_GL_CALL;
1971 0 : realGLboolean retval = mSymbols.fIsRenderbuffer(renderbuffer);
1972 0 : AFTER_GL_CALL;
1973 0 : return retval;
1974 : }
1975 :
1976 0 : void fRenderbufferStorage(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height) {
1977 0 : BEFORE_GL_CALL;
1978 0 : mSymbols.fRenderbufferStorage(target, internalFormat, width, height);
1979 0 : AFTER_GL_CALL;
1980 0 : }
1981 :
1982 : private:
1983 0 : void raw_fDepthRange(GLclampf a, GLclampf b) {
1984 0 : MOZ_ASSERT(!IsGLES());
1985 :
1986 0 : BEFORE_GL_CALL;
1987 0 : ASSERT_SYMBOL_PRESENT(fDepthRange);
1988 0 : mSymbols.fDepthRange(a, b);
1989 0 : AFTER_GL_CALL;
1990 0 : }
1991 :
1992 0 : void raw_fDepthRangef(GLclampf a, GLclampf b) {
1993 0 : MOZ_ASSERT(IsGLES());
1994 :
1995 0 : BEFORE_GL_CALL;
1996 0 : ASSERT_SYMBOL_PRESENT(fDepthRangef);
1997 0 : mSymbols.fDepthRangef(a, b);
1998 0 : AFTER_GL_CALL;
1999 0 : }
2000 :
2001 0 : void raw_fClearDepth(GLclampf v) {
2002 0 : MOZ_ASSERT(!IsGLES());
2003 :
2004 0 : BEFORE_GL_CALL;
2005 0 : ASSERT_SYMBOL_PRESENT(fClearDepth);
2006 0 : mSymbols.fClearDepth(v);
2007 0 : AFTER_GL_CALL;
2008 0 : }
2009 :
2010 0 : void raw_fClearDepthf(GLclampf v) {
2011 0 : MOZ_ASSERT(IsGLES());
2012 :
2013 0 : BEFORE_GL_CALL;
2014 0 : ASSERT_SYMBOL_PRESENT(fClearDepthf);
2015 0 : mSymbols.fClearDepthf(v);
2016 0 : AFTER_GL_CALL;
2017 0 : }
2018 :
2019 : public:
2020 0 : void fDepthRange(GLclampf a, GLclampf b) {
2021 0 : if (IsGLES()) {
2022 0 : raw_fDepthRangef(a, b);
2023 : } else {
2024 0 : raw_fDepthRange(a, b);
2025 : }
2026 0 : }
2027 :
2028 0 : void fClearDepth(GLclampf v) {
2029 0 : if (IsGLES()) {
2030 0 : raw_fClearDepthf(v);
2031 : } else {
2032 0 : raw_fClearDepth(v);
2033 : }
2034 0 : }
2035 :
2036 0 : void* fMapBuffer(GLenum target, GLenum access) {
2037 0 : BEFORE_GL_CALL;
2038 0 : ASSERT_SYMBOL_PRESENT(fMapBuffer);
2039 0 : void* ret = mSymbols.fMapBuffer(target, access);
2040 0 : AFTER_GL_CALL;
2041 0 : return ret;
2042 : }
2043 :
2044 0 : realGLboolean fUnmapBuffer(GLenum target) {
2045 0 : BEFORE_GL_CALL;
2046 0 : ASSERT_SYMBOL_PRESENT(fUnmapBuffer);
2047 0 : realGLboolean ret = mSymbols.fUnmapBuffer(target);
2048 0 : AFTER_GL_CALL;
2049 0 : return ret;
2050 : }
2051 :
2052 :
2053 : private:
2054 0 : GLuint raw_fCreateProgram() {
2055 0 : BEFORE_GL_CALL;
2056 0 : GLuint ret = mSymbols.fCreateProgram();
2057 0 : AFTER_GL_CALL;
2058 0 : return ret;
2059 : }
2060 :
2061 0 : GLuint raw_fCreateShader(GLenum t) {
2062 0 : BEFORE_GL_CALL;
2063 0 : GLuint ret = mSymbols.fCreateShader(t);
2064 0 : AFTER_GL_CALL;
2065 0 : return ret;
2066 : }
2067 :
2068 0 : void raw_fGenBuffers(GLsizei n, GLuint* names) {
2069 0 : BEFORE_GL_CALL;
2070 0 : mSymbols.fGenBuffers(n, names);
2071 0 : AFTER_GL_CALL;
2072 0 : }
2073 :
2074 0 : void raw_fGenFramebuffers(GLsizei n, GLuint* names) {
2075 0 : BEFORE_GL_CALL;
2076 0 : mSymbols.fGenFramebuffers(n, names);
2077 0 : AFTER_GL_CALL;
2078 0 : }
2079 :
2080 0 : void raw_fGenRenderbuffers(GLsizei n, GLuint* names) {
2081 0 : BEFORE_GL_CALL;
2082 0 : mSymbols.fGenRenderbuffers(n, names);
2083 0 : AFTER_GL_CALL;
2084 0 : }
2085 :
2086 0 : void raw_fGenTextures(GLsizei n, GLuint* names) {
2087 0 : BEFORE_GL_CALL;
2088 0 : mSymbols.fGenTextures(n, names);
2089 0 : AFTER_GL_CALL;
2090 0 : }
2091 :
2092 : public:
2093 0 : GLuint fCreateProgram() {
2094 0 : GLuint ret = raw_fCreateProgram();
2095 0 : TRACKING_CONTEXT(CreatedProgram(this, ret));
2096 0 : return ret;
2097 : }
2098 :
2099 0 : GLuint fCreateShader(GLenum t) {
2100 0 : GLuint ret = raw_fCreateShader(t);
2101 0 : TRACKING_CONTEXT(CreatedShader(this, ret));
2102 0 : return ret;
2103 : }
2104 :
2105 0 : void fGenBuffers(GLsizei n, GLuint* names) {
2106 0 : raw_fGenBuffers(n, names);
2107 0 : TRACKING_CONTEXT(CreatedBuffers(this, n, names));
2108 0 : }
2109 :
2110 0 : void fGenFramebuffers(GLsizei n, GLuint* names) {
2111 0 : raw_fGenFramebuffers(n, names);
2112 0 : TRACKING_CONTEXT(CreatedFramebuffers(this, n, names));
2113 0 : }
2114 :
2115 0 : void fGenRenderbuffers(GLsizei n, GLuint* names) {
2116 0 : raw_fGenRenderbuffers(n, names);
2117 0 : TRACKING_CONTEXT(CreatedRenderbuffers(this, n, names));
2118 0 : }
2119 :
2120 0 : void fGenTextures(GLsizei n, GLuint* names) {
2121 0 : raw_fGenTextures(n, names);
2122 0 : TRACKING_CONTEXT(CreatedTextures(this, n, names));
2123 0 : }
2124 :
2125 : private:
2126 0 : void raw_fDeleteProgram(GLuint program) {
2127 0 : BEFORE_GL_CALL;
2128 0 : mSymbols.fDeleteProgram(program);
2129 0 : AFTER_GL_CALL;
2130 0 : }
2131 :
2132 0 : void raw_fDeleteShader(GLuint shader) {
2133 0 : BEFORE_GL_CALL;
2134 0 : mSymbols.fDeleteShader(shader);
2135 0 : AFTER_GL_CALL;
2136 0 : }
2137 :
2138 0 : void raw_fDeleteBuffers(GLsizei n, const GLuint* names) {
2139 0 : BEFORE_GL_CALL;
2140 0 : mSymbols.fDeleteBuffers(n, names);
2141 0 : AFTER_GL_CALL;
2142 0 : }
2143 :
2144 0 : void raw_fDeleteFramebuffers(GLsizei n, const GLuint* names) {
2145 0 : BEFORE_GL_CALL;
2146 0 : mSymbols.fDeleteFramebuffers(n, names);
2147 0 : AFTER_GL_CALL;
2148 0 : }
2149 :
2150 0 : void raw_fDeleteRenderbuffers(GLsizei n, const GLuint* names) {
2151 0 : BEFORE_GL_CALL;
2152 0 : mSymbols.fDeleteRenderbuffers(n, names);
2153 0 : AFTER_GL_CALL;
2154 0 : }
2155 :
2156 0 : void raw_fDeleteTextures(GLsizei n, const GLuint* names) {
2157 0 : BEFORE_GL_CALL;
2158 0 : mSymbols.fDeleteTextures(n, names);
2159 0 : AFTER_GL_CALL;
2160 0 : }
2161 :
2162 : public:
2163 :
2164 0 : void fDeleteProgram(GLuint program) {
2165 0 : raw_fDeleteProgram(program);
2166 0 : TRACKING_CONTEXT(DeletedProgram(this, program));
2167 0 : }
2168 :
2169 0 : void fDeleteShader(GLuint shader) {
2170 0 : raw_fDeleteShader(shader);
2171 0 : TRACKING_CONTEXT(DeletedShader(this, shader));
2172 0 : }
2173 :
2174 0 : void fDeleteBuffers(GLsizei n, const GLuint* names) {
2175 0 : raw_fDeleteBuffers(n, names);
2176 0 : TRACKING_CONTEXT(DeletedBuffers(this, n, names));
2177 0 : }
2178 :
2179 : void fDeleteFramebuffers(GLsizei n, const GLuint* names);
2180 :
2181 0 : void fDeleteRenderbuffers(GLsizei n, const GLuint* names) {
2182 0 : raw_fDeleteRenderbuffers(n, names);
2183 0 : TRACKING_CONTEXT(DeletedRenderbuffers(this, n, names));
2184 0 : }
2185 :
2186 0 : void fDeleteTextures(GLsizei n, const GLuint* names) {
2187 0 : raw_fDeleteTextures(n, names);
2188 0 : TRACKING_CONTEXT(DeletedTextures(this, n, names));
2189 0 : }
2190 :
2191 0 : GLenum fGetGraphicsResetStatus() {
2192 0 : BEFORE_GL_CALL;
2193 0 : ASSERT_SYMBOL_PRESENT(fGetGraphicsResetStatus);
2194 0 : GLenum ret = mSymbols.fGetGraphicsResetStatus();
2195 0 : AFTER_GL_CALL;
2196 0 : return ret;
2197 : }
2198 :
2199 :
2200 : // -----------------------------------------------------------------------------
2201 : // Extension ARB_sync (GL)
2202 : public:
2203 0 : GLsync fFenceSync(GLenum condition, GLbitfield flags) {
2204 0 : BEFORE_GL_CALL;
2205 0 : ASSERT_SYMBOL_PRESENT(fFenceSync);
2206 0 : GLsync ret = mSymbols.fFenceSync(condition, flags);
2207 0 : AFTER_GL_CALL;
2208 0 : return ret;
2209 : }
2210 :
2211 : realGLboolean fIsSync(GLsync sync) {
2212 : BEFORE_GL_CALL;
2213 : ASSERT_SYMBOL_PRESENT(fIsSync);
2214 : realGLboolean ret = mSymbols.fIsSync(sync);
2215 : AFTER_GL_CALL;
2216 : return ret;
2217 : }
2218 :
2219 0 : void fDeleteSync(GLsync sync) {
2220 0 : BEFORE_GL_CALL;
2221 0 : ASSERT_SYMBOL_PRESENT(fDeleteSync);
2222 0 : mSymbols.fDeleteSync(sync);
2223 0 : AFTER_GL_CALL;
2224 0 : }
2225 :
2226 0 : GLenum fClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
2227 0 : BEFORE_GL_CALL;
2228 0 : ASSERT_SYMBOL_PRESENT(fClientWaitSync);
2229 0 : GLenum ret = mSymbols.fClientWaitSync(sync, flags, timeout);
2230 0 : AFTER_GL_CALL;
2231 0 : return ret;
2232 : }
2233 :
2234 0 : void fWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout) {
2235 0 : BEFORE_GL_CALL;
2236 0 : ASSERT_SYMBOL_PRESENT(fWaitSync);
2237 0 : mSymbols.fWaitSync(sync, flags, timeout);
2238 0 : AFTER_GL_CALL;
2239 0 : }
2240 :
2241 0 : void fGetInteger64v(GLenum pname, GLint64* params) {
2242 0 : BEFORE_GL_CALL;
2243 0 : ASSERT_SYMBOL_PRESENT(fGetInteger64v);
2244 0 : mSymbols.fGetInteger64v(pname, params);
2245 0 : AFTER_GL_CALL;
2246 0 : }
2247 :
2248 0 : void fGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values) {
2249 0 : BEFORE_GL_CALL;
2250 0 : ASSERT_SYMBOL_PRESENT(fGetSynciv);
2251 0 : mSymbols.fGetSynciv(sync, pname, bufSize, length, values);
2252 0 : AFTER_GL_CALL;
2253 0 : }
2254 :
2255 :
2256 : // -----------------------------------------------------------------------------
2257 : // Extension OES_EGL_image (GLES)
2258 : public:
2259 0 : void fEGLImageTargetTexture2D(GLenum target, GLeglImage image) {
2260 0 : BEFORE_GL_CALL;
2261 0 : ASSERT_SYMBOL_PRESENT(fEGLImageTargetTexture2D);
2262 0 : mSymbols.fEGLImageTargetTexture2D(target, image);
2263 0 : AFTER_GL_CALL;
2264 0 : mHeavyGLCallsSinceLastFlush = true;
2265 0 : }
2266 :
2267 : void fEGLImageTargetRenderbufferStorage(GLenum target, GLeglImage image)
2268 : {
2269 : BEFORE_GL_CALL;
2270 : ASSERT_SYMBOL_PRESENT(fEGLImageTargetRenderbufferStorage);
2271 : mSymbols.fEGLImageTargetRenderbufferStorage(target, image);
2272 : AFTER_GL_CALL;
2273 : }
2274 :
2275 :
2276 : // -----------------------------------------------------------------------------
2277 : // Package XXX_bind_buffer_offset
2278 : public:
2279 : void fBindBufferOffset(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
2280 : {
2281 : BEFORE_GL_CALL;
2282 : ASSERT_SYMBOL_PRESENT(fBindBufferOffset);
2283 : mSymbols.fBindBufferOffset(target, index, buffer, offset);
2284 : AFTER_GL_CALL;
2285 : }
2286 :
2287 :
2288 : // -----------------------------------------------------------------------------
2289 : // Package XXX_draw_buffers
2290 : public:
2291 0 : void fDrawBuffers(GLsizei n, const GLenum* bufs) {
2292 0 : BEFORE_GL_CALL;
2293 0 : ASSERT_SYMBOL_PRESENT(fDrawBuffers);
2294 0 : mSymbols.fDrawBuffers(n, bufs);
2295 0 : AFTER_GL_CALL;
2296 0 : }
2297 :
2298 :
2299 : // -----------------------------------------------------------------------------
2300 : // Package XXX_draw_instanced
2301 : public:
2302 0 : void fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
2303 : {
2304 0 : BeforeGLDrawCall();
2305 0 : raw_fDrawArraysInstanced(mode, first, count, primcount);
2306 0 : AfterGLDrawCall();
2307 0 : }
2308 :
2309 0 : void fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount)
2310 : {
2311 0 : BeforeGLDrawCall();
2312 0 : raw_fDrawElementsInstanced(mode, count, type, indices, primcount);
2313 0 : AfterGLDrawCall();
2314 0 : }
2315 :
2316 : private:
2317 0 : void raw_fDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
2318 : {
2319 0 : BEFORE_GL_CALL;
2320 0 : ASSERT_SYMBOL_PRESENT(fDrawArraysInstanced);
2321 0 : mSymbols.fDrawArraysInstanced(mode, first, count, primcount);
2322 0 : AFTER_GL_CALL;
2323 0 : }
2324 :
2325 0 : void raw_fDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices, GLsizei primcount)
2326 : {
2327 0 : BEFORE_GL_CALL;
2328 0 : ASSERT_SYMBOL_PRESENT(fDrawElementsInstanced);
2329 0 : mSymbols.fDrawElementsInstanced(mode, count, type, indices, primcount);
2330 0 : AFTER_GL_CALL;
2331 0 : }
2332 :
2333 : // -----------------------------------------------------------------------------
2334 : // Feature draw_range_elements
2335 : public:
2336 0 : void fDrawRangeElements(GLenum mode, GLuint start, GLuint end,
2337 : GLsizei count, GLenum type, const GLvoid* indices)
2338 : {
2339 0 : BeforeGLDrawCall();
2340 0 : raw_fDrawRangeElements(mode, start, end, count, type, indices);
2341 0 : AfterGLDrawCall();
2342 0 : }
2343 :
2344 : private:
2345 0 : void raw_fDrawRangeElements(GLenum mode, GLuint start, GLuint end,
2346 : GLsizei count, GLenum type, const GLvoid* indices)
2347 : {
2348 0 : BEFORE_GL_CALL;
2349 0 : ASSERT_SYMBOL_PRESENT(fDrawRangeElements);
2350 0 : mSymbols.fDrawRangeElements(mode, start, end, count, type, indices);
2351 0 : AFTER_GL_CALL;
2352 0 : }
2353 :
2354 : // -----------------------------------------------------------------------------
2355 : // Package XXX_framebuffer_blit
2356 : public:
2357 : // Draw/Read
2358 0 : void fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
2359 0 : BeforeGLDrawCall();
2360 0 : BeforeGLReadCall();
2361 0 : raw_fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
2362 0 : AfterGLReadCall();
2363 0 : AfterGLDrawCall();
2364 0 : }
2365 :
2366 :
2367 : private:
2368 0 : void raw_fBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) {
2369 0 : BEFORE_GL_CALL;
2370 0 : ASSERT_SYMBOL_PRESENT(fBlitFramebuffer);
2371 0 : mSymbols.fBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
2372 0 : AFTER_GL_CALL;
2373 0 : }
2374 :
2375 :
2376 : // -----------------------------------------------------------------------------
2377 : // Package XXX_framebuffer_multisample
2378 : public:
2379 0 : void fRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height) {
2380 0 : BEFORE_GL_CALL;
2381 0 : ASSERT_SYMBOL_PRESENT(fRenderbufferStorageMultisample);
2382 0 : mSymbols.fRenderbufferStorageMultisample(target, samples, internalFormat, width, height);
2383 0 : AFTER_GL_CALL;
2384 0 : }
2385 :
2386 : // -----------------------------------------------------------------------------
2387 : // GL 3.0, GL ES 3.0 & EXT_gpu_shader4
2388 : public:
2389 0 : void fGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
2390 : {
2391 0 : ASSERT_SYMBOL_PRESENT(fGetVertexAttribIiv);
2392 0 : BEFORE_GL_CALL;
2393 0 : mSymbols.fGetVertexAttribIiv(index, pname, params);
2394 0 : AFTER_GL_CALL;
2395 0 : }
2396 :
2397 0 : void fGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
2398 : {
2399 0 : ASSERT_SYMBOL_PRESENT(fGetVertexAttribIuiv);
2400 0 : BEFORE_GL_CALL;
2401 0 : mSymbols.fGetVertexAttribIuiv(index, pname, params);
2402 0 : AFTER_GL_CALL;
2403 0 : }
2404 :
2405 0 : void fVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
2406 : {
2407 0 : BEFORE_GL_CALL;
2408 0 : ASSERT_SYMBOL_PRESENT(fVertexAttribI4i);
2409 0 : mSymbols.fVertexAttribI4i(index, x, y, z, w);
2410 0 : AFTER_GL_CALL;
2411 0 : }
2412 :
2413 : void fVertexAttribI4iv(GLuint index, const GLint* v)
2414 : {
2415 : BEFORE_GL_CALL;
2416 : ASSERT_SYMBOL_PRESENT(fVertexAttribI4iv);
2417 : mSymbols.fVertexAttribI4iv(index, v);
2418 : AFTER_GL_CALL;
2419 : }
2420 :
2421 0 : void fVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
2422 : {
2423 0 : BEFORE_GL_CALL;
2424 0 : ASSERT_SYMBOL_PRESENT(fVertexAttribI4ui);
2425 0 : mSymbols.fVertexAttribI4ui(index, x, y, z, w);
2426 0 : AFTER_GL_CALL;
2427 0 : }
2428 :
2429 : void fVertexAttribI4uiv(GLuint index, const GLuint* v)
2430 : {
2431 : BEFORE_GL_CALL;
2432 : ASSERT_SYMBOL_PRESENT(fVertexAttribI4uiv);
2433 : mSymbols.fVertexAttribI4uiv(index, v);
2434 : AFTER_GL_CALL;
2435 : }
2436 :
2437 0 : void fVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid* offset)
2438 : {
2439 0 : BEFORE_GL_CALL;
2440 0 : ASSERT_SYMBOL_PRESENT(fVertexAttribIPointer);
2441 0 : mSymbols.fVertexAttribIPointer(index, size, type, stride, offset);
2442 0 : AFTER_GL_CALL;
2443 0 : }
2444 :
2445 0 : void fUniform1ui(GLint location, GLuint v0) {
2446 0 : BEFORE_GL_CALL;
2447 0 : ASSERT_SYMBOL_PRESENT(fUniform1ui);
2448 0 : mSymbols.fUniform1ui(location, v0);
2449 0 : AFTER_GL_CALL;
2450 0 : }
2451 :
2452 0 : void fUniform2ui(GLint location, GLuint v0, GLuint v1) {
2453 0 : BEFORE_GL_CALL;
2454 0 : ASSERT_SYMBOL_PRESENT(fUniform2ui);
2455 0 : mSymbols.fUniform2ui(location, v0, v1);
2456 0 : AFTER_GL_CALL;
2457 0 : }
2458 :
2459 0 : void fUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2) {
2460 0 : BEFORE_GL_CALL;
2461 0 : ASSERT_SYMBOL_PRESENT(fUniform3ui);
2462 0 : mSymbols.fUniform3ui(location, v0, v1, v2);
2463 0 : AFTER_GL_CALL;
2464 0 : }
2465 :
2466 0 : void fUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
2467 0 : BEFORE_GL_CALL;
2468 0 : ASSERT_SYMBOL_PRESENT(fUniform4ui);
2469 0 : mSymbols.fUniform4ui(location, v0, v1, v2, v3);
2470 0 : AFTER_GL_CALL;
2471 0 : }
2472 :
2473 0 : void fUniform1uiv(GLint location, GLsizei count, const GLuint* value) {
2474 0 : BEFORE_GL_CALL;
2475 0 : ASSERT_SYMBOL_PRESENT(fUniform1uiv);
2476 0 : mSymbols.fUniform1uiv(location, count, value);
2477 0 : AFTER_GL_CALL;
2478 0 : }
2479 :
2480 0 : void fUniform2uiv(GLint location, GLsizei count, const GLuint* value) {
2481 0 : BEFORE_GL_CALL;
2482 0 : ASSERT_SYMBOL_PRESENT(fUniform2uiv);
2483 0 : mSymbols.fUniform2uiv(location, count, value);
2484 0 : AFTER_GL_CALL;
2485 0 : }
2486 :
2487 0 : void fUniform3uiv(GLint location, GLsizei count, const GLuint* value) {
2488 0 : BEFORE_GL_CALL;
2489 0 : ASSERT_SYMBOL_PRESENT(fUniform3uiv);
2490 0 : mSymbols.fUniform3uiv(location, count, value);
2491 0 : AFTER_GL_CALL;
2492 0 : }
2493 :
2494 0 : void fUniform4uiv(GLint location, GLsizei count, const GLuint* value) {
2495 0 : BEFORE_GL_CALL;
2496 0 : ASSERT_SYMBOL_PRESENT(fUniform4uiv);
2497 0 : mSymbols.fUniform4uiv(location, count, value);
2498 0 : AFTER_GL_CALL;
2499 0 : }
2500 :
2501 0 : GLint fGetFragDataLocation(GLuint program, const GLchar* name)
2502 : {
2503 0 : BEFORE_GL_CALL;
2504 0 : ASSERT_SYMBOL_PRESENT(fGetFragDataLocation);
2505 0 : GLint result = mSymbols.fGetFragDataLocation(program, name);
2506 0 : AFTER_GL_CALL;
2507 0 : return result;
2508 : }
2509 :
2510 :
2511 : // -----------------------------------------------------------------------------
2512 : // Package XXX_instanced_arrays
2513 : public:
2514 0 : void fVertexAttribDivisor(GLuint index, GLuint divisor)
2515 : {
2516 0 : BEFORE_GL_CALL;
2517 0 : ASSERT_SYMBOL_PRESENT(fVertexAttribDivisor);
2518 0 : mSymbols.fVertexAttribDivisor(index, divisor);
2519 0 : AFTER_GL_CALL;
2520 0 : }
2521 :
2522 : // -----------------------------------------------------------------------------
2523 : // Feature internalformat_query
2524 : public:
2525 0 : void fGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params) {
2526 0 : BEFORE_GL_CALL;
2527 0 : ASSERT_SYMBOL_PRESENT(fGetInternalformativ);
2528 0 : mSymbols.fGetInternalformativ(target, internalformat, pname, bufSize, params);
2529 0 : AFTER_GL_CALL;
2530 0 : }
2531 :
2532 :
2533 : // -----------------------------------------------------------------------------
2534 : // Package XXX_query_counter
2535 : /**
2536 : * XXX_query_counter:
2537 : * - depends on XXX_query_objects
2538 : * - provide all followed entry points
2539 : * - provide GL_TIMESTAMP
2540 : */
2541 : public:
2542 0 : void fQueryCounter(GLuint id, GLenum target) {
2543 0 : BEFORE_GL_CALL;
2544 0 : ASSERT_SYMBOL_PRESENT(fQueryCounter);
2545 0 : mSymbols.fQueryCounter(id, target);
2546 0 : AFTER_GL_CALL;
2547 0 : }
2548 :
2549 :
2550 : // -----------------------------------------------------------------------------
2551 : // Package XXX_query_objects
2552 : /**
2553 : * XXX_query_objects:
2554 : * - provide all followed entry points
2555 : *
2556 : * XXX_occlusion_query2:
2557 : * - depends on XXX_query_objects
2558 : * - provide ANY_SAMPLES_PASSED
2559 : *
2560 : * XXX_occlusion_query_boolean:
2561 : * - depends on XXX_occlusion_query2
2562 : * - provide ANY_SAMPLES_PASSED_CONSERVATIVE
2563 : */
2564 : public:
2565 0 : void fDeleteQueries(GLsizei n, const GLuint* names) {
2566 0 : BEFORE_GL_CALL;
2567 0 : ASSERT_SYMBOL_PRESENT(fDeleteQueries);
2568 0 : mSymbols.fDeleteQueries(n, names);
2569 0 : AFTER_GL_CALL;
2570 0 : TRACKING_CONTEXT(DeletedQueries(this, n, names));
2571 0 : }
2572 :
2573 0 : void fGenQueries(GLsizei n, GLuint* names) {
2574 0 : BEFORE_GL_CALL;
2575 0 : ASSERT_SYMBOL_PRESENT(fGenQueries);
2576 0 : mSymbols.fGenQueries(n, names);
2577 0 : AFTER_GL_CALL;
2578 0 : TRACKING_CONTEXT(CreatedQueries(this, n, names));
2579 0 : }
2580 :
2581 0 : void fGetQueryiv(GLenum target, GLenum pname, GLint* params) {
2582 0 : BEFORE_GL_CALL;
2583 0 : ASSERT_SYMBOL_PRESENT(fGetQueryiv);
2584 0 : mSymbols.fGetQueryiv(target, pname, params);
2585 0 : AFTER_GL_CALL;
2586 0 : }
2587 :
2588 0 : void fGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params) {
2589 0 : BEFORE_GL_CALL;
2590 0 : ASSERT_SYMBOL_PRESENT(fGetQueryObjectuiv);
2591 0 : mSymbols.fGetQueryObjectuiv(id, pname, params);
2592 0 : AFTER_GL_CALL;
2593 0 : }
2594 :
2595 : realGLboolean fIsQuery(GLuint query) {
2596 : BEFORE_GL_CALL;
2597 : ASSERT_SYMBOL_PRESENT(fIsQuery);
2598 : realGLboolean retval = mSymbols.fIsQuery(query);
2599 : AFTER_GL_CALL;
2600 : return retval;
2601 : }
2602 :
2603 : // -----------------------------------------------------------------------------
2604 : // Package XXX_get_query_object_i64v
2605 : /**
2606 : * XXX_get_query_object_i64v:
2607 : * - depends on XXX_query_objects
2608 : * - provide the followed entry point
2609 : */
2610 : public:
2611 : void fGetQueryObjecti64v(GLuint id, GLenum pname, GLint64* params) {
2612 : BEFORE_GL_CALL;
2613 : ASSERT_SYMBOL_PRESENT(fGetQueryObjecti64v);
2614 : mSymbols.fGetQueryObjecti64v(id, pname, params);
2615 : AFTER_GL_CALL;
2616 : }
2617 :
2618 0 : void fGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params) {
2619 0 : BEFORE_GL_CALL;
2620 0 : ASSERT_SYMBOL_PRESENT(fGetQueryObjectui64v);
2621 0 : mSymbols.fGetQueryObjectui64v(id, pname, params);
2622 0 : AFTER_GL_CALL;
2623 0 : }
2624 :
2625 :
2626 : // -----------------------------------------------------------------------------
2627 : // Package XXX_get_query_object_iv
2628 : /**
2629 : * XXX_get_query_object_iv:
2630 : * - depends on XXX_query_objects
2631 : * - provide the followed entry point
2632 : *
2633 : * XXX_occlusion_query:
2634 : * - depends on XXX_get_query_object_iv
2635 : * - provide LOCAL_GL_SAMPLES_PASSED
2636 : */
2637 : public:
2638 0 : void fGetQueryObjectiv(GLuint id, GLenum pname, GLint* params) {
2639 0 : BEFORE_GL_CALL;
2640 0 : ASSERT_SYMBOL_PRESENT(fGetQueryObjectiv);
2641 0 : mSymbols.fGetQueryObjectiv(id, pname, params);
2642 0 : AFTER_GL_CALL;
2643 0 : }
2644 :
2645 :
2646 : // -----------------------------------------------------------------------------
2647 : // GL 4.0, GL ES 3.0, ARB_transform_feedback2, NV_transform_feedback2
2648 : public:
2649 0 : void fBindBufferBase(GLenum target, GLuint index, GLuint buffer)
2650 : {
2651 0 : BEFORE_GL_CALL;
2652 0 : ASSERT_SYMBOL_PRESENT(fBindBufferBase);
2653 0 : mSymbols.fBindBufferBase(target, index, buffer);
2654 0 : AFTER_GL_CALL;
2655 0 : }
2656 :
2657 0 : void fBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
2658 : {
2659 0 : BEFORE_GL_CALL;
2660 0 : ASSERT_SYMBOL_PRESENT(fBindBufferRange);
2661 0 : mSymbols.fBindBufferRange(target, index, buffer, offset, size);
2662 0 : AFTER_GL_CALL;
2663 0 : }
2664 :
2665 0 : void fGenTransformFeedbacks(GLsizei n, GLuint* ids)
2666 : {
2667 0 : BEFORE_GL_CALL;
2668 0 : ASSERT_SYMBOL_PRESENT(fGenTransformFeedbacks);
2669 0 : mSymbols.fGenTransformFeedbacks(n, ids);
2670 0 : AFTER_GL_CALL;
2671 0 : }
2672 :
2673 0 : void fDeleteTransformFeedbacks(GLsizei n, const GLuint* ids)
2674 : {
2675 0 : BEFORE_GL_CALL;
2676 0 : ASSERT_SYMBOL_PRESENT(fDeleteTransformFeedbacks);
2677 0 : mSymbols.fDeleteTransformFeedbacks(n, ids);
2678 0 : AFTER_GL_CALL;
2679 0 : }
2680 :
2681 0 : realGLboolean fIsTransformFeedback(GLuint id)
2682 : {
2683 0 : BEFORE_GL_CALL;
2684 0 : ASSERT_SYMBOL_PRESENT(fIsTransformFeedback);
2685 0 : realGLboolean result = mSymbols.fIsTransformFeedback(id);
2686 0 : AFTER_GL_CALL;
2687 0 : return result;
2688 : }
2689 :
2690 0 : void fBindTransformFeedback(GLenum target, GLuint id)
2691 : {
2692 0 : BEFORE_GL_CALL;
2693 0 : ASSERT_SYMBOL_PRESENT(fBindTransformFeedback);
2694 0 : mSymbols.fBindTransformFeedback(target, id);
2695 0 : AFTER_GL_CALL;
2696 0 : }
2697 :
2698 0 : void fBeginTransformFeedback(GLenum primitiveMode)
2699 : {
2700 0 : BEFORE_GL_CALL;
2701 0 : ASSERT_SYMBOL_PRESENT(fBeginTransformFeedback);
2702 0 : mSymbols.fBeginTransformFeedback(primitiveMode);
2703 0 : AFTER_GL_CALL;
2704 0 : }
2705 :
2706 0 : void fEndTransformFeedback()
2707 : {
2708 0 : BEFORE_GL_CALL;
2709 0 : ASSERT_SYMBOL_PRESENT(fEndTransformFeedback);
2710 0 : mSymbols.fEndTransformFeedback();
2711 0 : AFTER_GL_CALL;
2712 0 : }
2713 :
2714 0 : void fTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const* varyings, GLenum bufferMode)
2715 : {
2716 0 : BEFORE_GL_CALL;
2717 0 : ASSERT_SYMBOL_PRESENT(fTransformFeedbackVaryings);
2718 0 : mSymbols.fTransformFeedbackVaryings(program, count, varyings, bufferMode);
2719 0 : AFTER_GL_CALL;
2720 0 : }
2721 :
2722 0 : void fGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
2723 : {
2724 0 : BEFORE_GL_CALL;
2725 0 : ASSERT_SYMBOL_PRESENT(fGetTransformFeedbackVarying);
2726 0 : mSymbols.fGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
2727 0 : AFTER_GL_CALL;
2728 0 : }
2729 :
2730 0 : void fPauseTransformFeedback()
2731 : {
2732 0 : BEFORE_GL_CALL;
2733 0 : ASSERT_SYMBOL_PRESENT(fPauseTransformFeedback);
2734 0 : mSymbols.fPauseTransformFeedback();
2735 0 : AFTER_GL_CALL;
2736 0 : }
2737 :
2738 0 : void fResumeTransformFeedback()
2739 : {
2740 0 : BEFORE_GL_CALL;
2741 0 : ASSERT_SYMBOL_PRESENT(fResumeTransformFeedback);
2742 0 : mSymbols.fResumeTransformFeedback();
2743 0 : AFTER_GL_CALL;
2744 0 : }
2745 :
2746 : void fGetIntegeri_v(GLenum param, GLuint index, GLint* values)
2747 : {
2748 : BEFORE_GL_CALL;
2749 : ASSERT_SYMBOL_PRESENT(fGetIntegeri_v);
2750 : mSymbols.fGetIntegeri_v(param, index, values);
2751 : AFTER_GL_CALL;
2752 : }
2753 :
2754 : void fGetInteger64i_v(GLenum target, GLuint index, GLint64* data) {
2755 : ASSERT_SYMBOL_PRESENT(fGetInteger64i_v);
2756 : BEFORE_GL_CALL;
2757 : mSymbols.fGetInteger64i_v(target, index, data);
2758 : AFTER_GL_CALL;
2759 : }
2760 :
2761 : // -----------------------------------------------------------------------------
2762 : // Package XXX_vertex_array_object
2763 : public:
2764 0 : void fBindVertexArray(GLuint array)
2765 : {
2766 0 : BEFORE_GL_CALL;
2767 0 : ASSERT_SYMBOL_PRESENT(fBindVertexArray);
2768 0 : mSymbols.fBindVertexArray(array);
2769 0 : AFTER_GL_CALL;
2770 0 : }
2771 :
2772 0 : void fDeleteVertexArrays(GLsizei n, const GLuint* arrays)
2773 : {
2774 0 : BEFORE_GL_CALL;
2775 0 : ASSERT_SYMBOL_PRESENT(fDeleteVertexArrays);
2776 0 : mSymbols.fDeleteVertexArrays(n, arrays);
2777 0 : AFTER_GL_CALL;
2778 0 : }
2779 :
2780 0 : void fGenVertexArrays(GLsizei n, GLuint* arrays)
2781 : {
2782 0 : BEFORE_GL_CALL;
2783 0 : ASSERT_SYMBOL_PRESENT(fGenVertexArrays);
2784 0 : mSymbols.fGenVertexArrays(n, arrays);
2785 0 : AFTER_GL_CALL;
2786 0 : }
2787 :
2788 0 : realGLboolean fIsVertexArray(GLuint array)
2789 : {
2790 0 : BEFORE_GL_CALL;
2791 0 : ASSERT_SYMBOL_PRESENT(fIsVertexArray);
2792 0 : realGLboolean ret = mSymbols.fIsVertexArray(array);
2793 0 : AFTER_GL_CALL;
2794 0 : return ret;
2795 : }
2796 :
2797 : // -----------------------------------------------------------------------------
2798 : // Extension NV_fence
2799 : public:
2800 : void fGenFences(GLsizei n, GLuint* fences)
2801 : {
2802 : ASSERT_SYMBOL_PRESENT(fGenFences);
2803 : BEFORE_GL_CALL;
2804 : mSymbols.fGenFences(n, fences);
2805 : AFTER_GL_CALL;
2806 : }
2807 :
2808 : void fDeleteFences(GLsizei n, const GLuint* fences)
2809 : {
2810 : ASSERT_SYMBOL_PRESENT(fDeleteFences);
2811 : BEFORE_GL_CALL;
2812 : mSymbols.fDeleteFences(n, fences);
2813 : AFTER_GL_CALL;
2814 : }
2815 :
2816 : void fSetFence(GLuint fence, GLenum condition)
2817 : {
2818 : ASSERT_SYMBOL_PRESENT(fSetFence);
2819 : BEFORE_GL_CALL;
2820 : mSymbols.fSetFence(fence, condition);
2821 : AFTER_GL_CALL;
2822 : }
2823 :
2824 : realGLboolean fTestFence(GLuint fence)
2825 : {
2826 : ASSERT_SYMBOL_PRESENT(fTestFence);
2827 : BEFORE_GL_CALL;
2828 : realGLboolean ret = mSymbols.fTestFence(fence);
2829 : AFTER_GL_CALL;
2830 : return ret;
2831 : }
2832 :
2833 : void fFinishFence(GLuint fence)
2834 : {
2835 : ASSERT_SYMBOL_PRESENT(fFinishFence);
2836 : BEFORE_GL_CALL;
2837 : mSymbols.fFinishFence(fence);
2838 : AFTER_GL_CALL;
2839 : }
2840 :
2841 : realGLboolean fIsFence(GLuint fence)
2842 : {
2843 : ASSERT_SYMBOL_PRESENT(fIsFence);
2844 : BEFORE_GL_CALL;
2845 : realGLboolean ret = mSymbols.fIsFence(fence);
2846 : AFTER_GL_CALL;
2847 : return ret;
2848 : }
2849 :
2850 : void fGetFenceiv(GLuint fence, GLenum pname, GLint* params)
2851 : {
2852 : ASSERT_SYMBOL_PRESENT(fGetFenceiv);
2853 : BEFORE_GL_CALL;
2854 : mSymbols.fGetFenceiv(fence, pname, params);
2855 : AFTER_GL_CALL;
2856 : }
2857 :
2858 : // -----------------------------------------------------------------------------
2859 : // Extension NV_texture_barrier
2860 : public:
2861 0 : void fTextureBarrier()
2862 : {
2863 0 : ASSERT_SYMBOL_PRESENT(fTextureBarrier);
2864 0 : BEFORE_GL_CALL;
2865 0 : mSymbols.fTextureBarrier();
2866 0 : AFTER_GL_CALL;
2867 0 : }
2868 :
2869 : // Core GL & Extension ARB_copy_buffer
2870 : public:
2871 0 : void fCopyBufferSubData(GLenum readtarget, GLenum writetarget,
2872 : GLintptr readoffset, GLintptr writeoffset,
2873 : GLsizeiptr size)
2874 : {
2875 0 : BEFORE_GL_CALL;
2876 0 : ASSERT_SYMBOL_PRESENT(fCopyBufferSubData);
2877 0 : mSymbols.fCopyBufferSubData(readtarget, writetarget, readoffset, writeoffset, size);
2878 0 : AFTER_GL_CALL;
2879 0 : }
2880 :
2881 :
2882 : // -----------------------------------------------------------------------------
2883 : // Core GL & Extension ARB_map_buffer_range
2884 : public:
2885 0 : void* fMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
2886 : GLbitfield access)
2887 : {
2888 0 : ASSERT_SYMBOL_PRESENT(fMapBufferRange);
2889 0 : BEFORE_GL_CALL;
2890 0 : void* data = mSymbols.fMapBufferRange(target, offset, length, access);
2891 0 : AFTER_GL_CALL;
2892 0 : return data;
2893 : }
2894 :
2895 : void fFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) {
2896 : ASSERT_SYMBOL_PRESENT(fFlushMappedBufferRange);
2897 : BEFORE_GL_CALL;
2898 : mSymbols.fFlushMappedBufferRange(target, offset, length);
2899 : AFTER_GL_CALL;
2900 : }
2901 :
2902 :
2903 : // -----------------------------------------------------------------------------
2904 : // Core GL & Extension ARB_sampler_objects
2905 : public:
2906 0 : void fGenSamplers(GLsizei count, GLuint* samplers)
2907 : {
2908 0 : BEFORE_GL_CALL;
2909 0 : ASSERT_SYMBOL_PRESENT(fGenSamplers);
2910 0 : mSymbols.fGenSamplers(count, samplers);
2911 0 : AFTER_GL_CALL;
2912 0 : }
2913 :
2914 0 : void fDeleteSamplers(GLsizei count, const GLuint* samplers)
2915 : {
2916 0 : BEFORE_GL_CALL;
2917 0 : ASSERT_SYMBOL_PRESENT(fDeleteSamplers);
2918 0 : mSymbols.fDeleteSamplers(count, samplers);
2919 0 : AFTER_GL_CALL;
2920 0 : }
2921 :
2922 0 : realGLboolean fIsSampler(GLuint sampler)
2923 : {
2924 0 : BEFORE_GL_CALL;
2925 0 : ASSERT_SYMBOL_PRESENT(fIsSampler);
2926 0 : realGLboolean result = mSymbols.fIsSampler(sampler);
2927 0 : AFTER_GL_CALL;
2928 0 : return result;
2929 : }
2930 :
2931 0 : void fBindSampler(GLuint unit, GLuint sampler)
2932 : {
2933 0 : BEFORE_GL_CALL;
2934 0 : ASSERT_SYMBOL_PRESENT(fBindSampler);
2935 0 : mSymbols.fBindSampler(unit, sampler);
2936 0 : AFTER_GL_CALL;
2937 0 : }
2938 :
2939 0 : void fSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
2940 : {
2941 0 : BEFORE_GL_CALL;
2942 0 : ASSERT_SYMBOL_PRESENT(fSamplerParameteri);
2943 0 : mSymbols.fSamplerParameteri(sampler, pname, param);
2944 0 : AFTER_GL_CALL;
2945 0 : }
2946 :
2947 : void fSamplerParameteriv(GLuint sampler, GLenum pname, const GLint* param)
2948 : {
2949 : BEFORE_GL_CALL;
2950 : ASSERT_SYMBOL_PRESENT(fSamplerParameteriv);
2951 : mSymbols.fSamplerParameteriv(sampler, pname, param);
2952 : AFTER_GL_CALL;
2953 : }
2954 :
2955 0 : void fSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
2956 : {
2957 0 : BEFORE_GL_CALL;
2958 0 : ASSERT_SYMBOL_PRESENT(fSamplerParameterf);
2959 0 : mSymbols.fSamplerParameterf(sampler, pname, param);
2960 0 : AFTER_GL_CALL;
2961 0 : }
2962 :
2963 : void fSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat* param)
2964 : {
2965 : BEFORE_GL_CALL;
2966 : ASSERT_SYMBOL_PRESENT(fSamplerParameterfv);
2967 : mSymbols.fSamplerParameterfv(sampler, pname, param);
2968 : AFTER_GL_CALL;
2969 : }
2970 :
2971 0 : void fGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
2972 : {
2973 0 : BEFORE_GL_CALL;
2974 0 : ASSERT_SYMBOL_PRESENT(fGetSamplerParameteriv);
2975 0 : mSymbols.fGetSamplerParameteriv(sampler, pname, params);
2976 0 : AFTER_GL_CALL;
2977 0 : }
2978 :
2979 0 : void fGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
2980 : {
2981 0 : BEFORE_GL_CALL;
2982 0 : ASSERT_SYMBOL_PRESENT(fGetSamplerParameterfv);
2983 0 : mSymbols.fGetSamplerParameterfv(sampler, pname, params);
2984 0 : AFTER_GL_CALL;
2985 0 : }
2986 :
2987 :
2988 : // -----------------------------------------------------------------------------
2989 : // Core GL & Extension ARB_uniform_buffer_object
2990 : public:
2991 0 : void fGetUniformIndices(GLuint program, GLsizei uniformCount,
2992 : const GLchar* const* uniformNames, GLuint* uniformIndices)
2993 : {
2994 0 : ASSERT_SYMBOL_PRESENT(fGetUniformIndices);
2995 0 : BEFORE_GL_CALL;
2996 0 : mSymbols.fGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
2997 0 : AFTER_GL_CALL;
2998 0 : }
2999 :
3000 0 : void fGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint* uniformIndices,
3001 : GLenum pname, GLint* params)
3002 : {
3003 0 : ASSERT_SYMBOL_PRESENT(fGetActiveUniformsiv);
3004 0 : BEFORE_GL_CALL;
3005 0 : mSymbols.fGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
3006 0 : AFTER_GL_CALL;
3007 0 : }
3008 :
3009 0 : GLuint fGetUniformBlockIndex(GLuint program, const GLchar* uniformBlockName) {
3010 0 : ASSERT_SYMBOL_PRESENT(fGetUniformBlockIndex);
3011 0 : BEFORE_GL_CALL;
3012 0 : GLuint result = mSymbols.fGetUniformBlockIndex(program, uniformBlockName);
3013 0 : AFTER_GL_CALL;
3014 0 : return result;
3015 : }
3016 :
3017 0 : void fGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
3018 : GLenum pname, GLint* params)
3019 : {
3020 0 : ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockiv);
3021 0 : BEFORE_GL_CALL;
3022 0 : mSymbols.fGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
3023 0 : AFTER_GL_CALL;
3024 0 : }
3025 :
3026 0 : void fGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize,
3027 : GLsizei* length, GLchar* uniformBlockName)
3028 : {
3029 0 : ASSERT_SYMBOL_PRESENT(fGetActiveUniformBlockName);
3030 0 : BEFORE_GL_CALL;
3031 0 : mSymbols.fGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
3032 0 : AFTER_GL_CALL;
3033 0 : }
3034 :
3035 0 : void fUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) {
3036 0 : ASSERT_SYMBOL_PRESENT(fUniformBlockBinding);
3037 0 : BEFORE_GL_CALL;
3038 0 : mSymbols.fUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
3039 0 : AFTER_GL_CALL;
3040 0 : }
3041 :
3042 : // -----------------------------------------------------------------------------
3043 : // Core GL 4.2, GL ES 3.0 & Extension ARB_texture_storage/EXT_texture_storage
3044 0 : void fTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
3045 : {
3046 0 : BEFORE_GL_CALL;
3047 0 : ASSERT_SYMBOL_PRESENT(fTexStorage2D);
3048 0 : mSymbols.fTexStorage2D(target, levels, internalformat, width, height);
3049 0 : AFTER_GL_CALL;
3050 0 : }
3051 :
3052 0 : void fTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
3053 : {
3054 0 : BEFORE_GL_CALL;
3055 0 : ASSERT_SYMBOL_PRESENT(fTexStorage3D);
3056 0 : mSymbols.fTexStorage3D(target, levels, internalformat, width, height, depth);
3057 0 : AFTER_GL_CALL;
3058 0 : }
3059 :
3060 : // -----------------------------------------------------------------------------
3061 : // 3D Textures
3062 0 : void fTexImage3D(GLenum target, GLint level,
3063 : GLint internalFormat,
3064 : GLsizei width, GLsizei height, GLsizei depth,
3065 : GLint border, GLenum format, GLenum type,
3066 : const GLvoid * data)
3067 : {
3068 0 : BEFORE_GL_CALL;
3069 0 : ASSERT_SYMBOL_PRESENT(fTexImage3D);
3070 0 : mSymbols.fTexImage3D(target, level, internalFormat,
3071 : width, height, depth,
3072 : border, format, type,
3073 0 : data);
3074 0 : AFTER_GL_CALL;
3075 0 : }
3076 :
3077 0 : void fTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
3078 : GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
3079 : GLenum format, GLenum type, const GLvoid* pixels)
3080 : {
3081 0 : BEFORE_GL_CALL;
3082 0 : ASSERT_SYMBOL_PRESENT(fTexSubImage3D);
3083 0 : mSymbols.fTexSubImage3D(target, level, xoffset, yoffset, zoffset,
3084 : width, height, depth, format, type,
3085 0 : pixels);
3086 0 : AFTER_GL_CALL;
3087 0 : }
3088 :
3089 0 : void fCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
3090 : GLint yoffset, GLint zoffset, GLint x,
3091 : GLint y, GLsizei width, GLsizei height)
3092 : {
3093 0 : BeforeGLReadCall();
3094 0 : BEFORE_GL_CALL;
3095 0 : ASSERT_SYMBOL_PRESENT(fCopyTexSubImage3D);
3096 0 : mSymbols.fCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset,
3097 0 : x, y, width, height);
3098 0 : AFTER_GL_CALL;
3099 0 : AfterGLReadCall();
3100 0 : }
3101 :
3102 0 : void fCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat,
3103 : GLsizei width, GLsizei height, GLsizei depth,
3104 : GLint border, GLsizei imageSize, const GLvoid* data)
3105 : {
3106 0 : BEFORE_GL_CALL;
3107 0 : ASSERT_SYMBOL_PRESENT(fCompressedTexImage3D);
3108 0 : mSymbols.fCompressedTexImage3D(target, level, internalformat,
3109 : width, height, depth,
3110 0 : border, imageSize, data);
3111 0 : AFTER_GL_CALL;
3112 0 : }
3113 :
3114 0 : void fCompressedTexSubImage3D(GLenum target, GLint level,
3115 : GLint xoffset, GLint yoffset, GLint zoffset,
3116 : GLsizei width, GLsizei height, GLsizei depth,
3117 : GLenum format, GLsizei imageSize, const GLvoid* data)
3118 : {
3119 0 : BEFORE_GL_CALL;
3120 0 : ASSERT_SYMBOL_PRESENT(fCompressedTexSubImage3D);
3121 0 : mSymbols.fCompressedTexSubImage3D(target, level,
3122 : xoffset, yoffset, zoffset,
3123 : width, height, depth,
3124 0 : format, imageSize, data);
3125 0 : AFTER_GL_CALL;
3126 0 : }
3127 :
3128 : // -----------------------------------------------------------------------------
3129 : // GL3+, ES3+
3130 :
3131 0 : const GLubyte* fGetStringi(GLenum name, GLuint index) {
3132 0 : BEFORE_GL_CALL;
3133 0 : ASSERT_SYMBOL_PRESENT(fGetStringi);
3134 0 : const GLubyte* ret = mSymbols.fGetStringi(name, index);
3135 0 : AFTER_GL_CALL;
3136 0 : return ret;
3137 : }
3138 :
3139 : // -----------------------------------------------------------------------------
3140 : // APPLE_framebuffer_multisample
3141 :
3142 0 : void fResolveMultisampleFramebufferAPPLE() {
3143 0 : BEFORE_GL_CALL;
3144 0 : ASSERT_SYMBOL_PRESENT(fResolveMultisampleFramebufferAPPLE);
3145 0 : mSymbols.fResolveMultisampleFramebufferAPPLE();
3146 0 : AFTER_GL_CALL;
3147 0 : }
3148 :
3149 : // -----------------------------------------------------------------------------
3150 : // prim_restart
3151 :
3152 0 : void fPrimitiveRestartIndex(GLuint index) {
3153 0 : BEFORE_GL_CALL;
3154 0 : ASSERT_SYMBOL_PRESENT(fPrimitiveRestartIndex);
3155 0 : mSymbols.fPrimitiveRestartIndex(index);
3156 0 : AFTER_GL_CALL;
3157 0 : }
3158 :
3159 : // -----------------------------------------------------------------------------
3160 : // Constructor
3161 : protected:
3162 : explicit GLContext(CreateContextFlags flags, const SurfaceCaps& caps,
3163 : GLContext* sharedContext = nullptr,
3164 : bool isOffscreen = false, bool canUseTLSIsCurrent = false);
3165 :
3166 :
3167 : // -----------------------------------------------------------------------------
3168 : // Destructor
3169 : public:
3170 : virtual ~GLContext();
3171 :
3172 : // Mark this context as destroyed. This will nullptr out all
3173 : // the GL function pointers!
3174 : void MarkDestroyed();
3175 :
3176 : // -----------------------------------------------------------------------------
3177 : // Everything that isn't standard GL APIs
3178 : protected:
3179 : typedef gfx::SurfaceFormat SurfaceFormat;
3180 :
3181 : virtual bool MakeCurrentImpl(bool aForce) = 0;
3182 :
3183 : public:
3184 : #ifdef MOZ_GL_DEBUG
3185 3 : static void StaticInit() {
3186 3 : PR_NewThreadPrivateIndex(&sCurrentGLContextTLS, nullptr);
3187 3 : }
3188 : #endif
3189 :
3190 : bool MakeCurrent(bool aForce = false);
3191 :
3192 : virtual bool Init() = 0;
3193 :
3194 : virtual bool SetupLookupFunction() = 0;
3195 :
3196 0 : virtual void ReleaseSurface() {}
3197 :
3198 0 : bool IsDestroyed() {
3199 : // MarkDestroyed will mark all these as null.
3200 0 : return mSymbols.fUseProgram == nullptr;
3201 : }
3202 :
3203 0 : GLContext* GetSharedContext() { return mSharedContext; }
3204 :
3205 : /**
3206 : * Returns true if the thread on which this context was created is the currently
3207 : * executing thread.
3208 : */
3209 : bool IsOwningThreadCurrent();
3210 :
3211 : static void PlatformStartup();
3212 :
3213 : public:
3214 : /**
3215 : * If this context wraps a double-buffered target, swap the back
3216 : * and front buffers. It should be assumed that after a swap, the
3217 : * contents of the new back buffer are undefined.
3218 : */
3219 0 : virtual bool SwapBuffers() { return false; }
3220 :
3221 : /**
3222 : * Defines a two-dimensional texture image for context target surface
3223 : */
3224 0 : virtual bool BindTexImage() { return false; }
3225 : /*
3226 : * Releases a color buffer that is being used as a texture
3227 : */
3228 0 : virtual bool ReleaseTexImage() { return false; }
3229 :
3230 : // Before reads from offscreen texture
3231 : void GuaranteeResolve();
3232 :
3233 : /*
3234 : * Resize the current offscreen buffer. Returns true on success.
3235 : * If it returns false, the context should be treated as unusable
3236 : * and should be recreated. After the resize, the viewport is not
3237 : * changed; glViewport should be called as appropriate.
3238 : *
3239 : * Only valid if IsOffscreen() returns true.
3240 : */
3241 0 : bool ResizeOffscreen(const gfx::IntSize& size) {
3242 0 : return ResizeScreenBuffer(size);
3243 : }
3244 :
3245 : /*
3246 : * Return size of this offscreen context.
3247 : *
3248 : * Only valid if IsOffscreen() returns true.
3249 : */
3250 : const gfx::IntSize& OffscreenSize() const;
3251 :
3252 0 : void BindFB(GLuint fb) {
3253 0 : fBindFramebuffer(LOCAL_GL_FRAMEBUFFER, fb);
3254 0 : MOZ_ASSERT(!fb || fIsFramebuffer(fb));
3255 0 : }
3256 :
3257 0 : void BindDrawFB(GLuint fb) {
3258 0 : fBindFramebuffer(LOCAL_GL_DRAW_FRAMEBUFFER_EXT, fb);
3259 0 : }
3260 :
3261 0 : void BindReadFB(GLuint fb) {
3262 0 : fBindFramebuffer(LOCAL_GL_READ_FRAMEBUFFER_EXT, fb);
3263 0 : }
3264 :
3265 : GLuint GetDrawFB();
3266 :
3267 : GLuint GetReadFB();
3268 :
3269 : GLuint GetFB();
3270 :
3271 : private:
3272 0 : void GetShaderPrecisionFormatNonES2(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) {
3273 0 : switch (precisiontype) {
3274 : case LOCAL_GL_LOW_FLOAT:
3275 : case LOCAL_GL_MEDIUM_FLOAT:
3276 : case LOCAL_GL_HIGH_FLOAT:
3277 : // Assume IEEE 754 precision
3278 0 : range[0] = 127;
3279 0 : range[1] = 127;
3280 0 : *precision = 23;
3281 0 : break;
3282 : case LOCAL_GL_LOW_INT:
3283 : case LOCAL_GL_MEDIUM_INT:
3284 : case LOCAL_GL_HIGH_INT:
3285 : // Some (most) hardware only supports single-precision floating-point numbers,
3286 : // which can accurately represent integers up to +/-16777216
3287 0 : range[0] = 24;
3288 0 : range[1] = 24;
3289 0 : *precision = 0;
3290 0 : break;
3291 : }
3292 0 : }
3293 :
3294 : public:
3295 :
3296 : void ForceDirtyScreen();
3297 : void CleanDirtyScreen();
3298 :
3299 0 : virtual GLenum GetPreferredARGB32Format() const { return LOCAL_GL_RGBA; }
3300 :
3301 0 : virtual GLenum GetPreferredEGLImageTextureTarget() const {
3302 0 : return IsExtensionSupported(OES_EGL_image_external) ?
3303 0 : LOCAL_GL_TEXTURE_EXTERNAL : LOCAL_GL_TEXTURE_2D;
3304 : }
3305 :
3306 0 : virtual bool RenewSurface(widget::CompositorWidget* aWidget) { return false; }
3307 :
3308 : // Shared code for GL extensions and GLX extensions.
3309 : static bool ListHasExtension(const GLubyte* extensions,
3310 : const char* extension);
3311 :
3312 : GLint GetMaxTextureImageSize() { return mMaxTextureImageSize; }
3313 :
3314 : public:
3315 : std::map<GLuint, SharedSurface*> mFBOMapping;
3316 :
3317 : enum {
3318 : DebugFlagEnabled = 1 << 0,
3319 : DebugFlagTrace = 1 << 1,
3320 : DebugFlagAbortOnError = 1 << 2
3321 : };
3322 :
3323 : const uint8_t mDebugFlags;
3324 :
3325 : protected:
3326 : RefPtr<GLContext> mSharedContext;
3327 :
3328 : // The thread id which this context was created.
3329 : PlatformThreadId mOwningThreadId;
3330 :
3331 : GLContextSymbols mSymbols;
3332 :
3333 : #ifdef MOZ_GL_DEBUG
3334 : // Non-zero debug flags will check that we don't send call
3335 : // to a GLContext that isn't current on the current
3336 : // thread.
3337 : // Store the current context when binding to thread local
3338 : // storage to support debug flags on an arbitrary thread.
3339 : static unsigned sCurrentGLContextTLS;
3340 : #endif
3341 :
3342 : UniquePtr<GLBlitHelper> mBlitHelper;
3343 : UniquePtr<GLReadTexImageHelper> mReadTexImageHelper;
3344 :
3345 : public:
3346 : GLBlitHelper* BlitHelper();
3347 : GLBlitTextureImageHelper* BlitTextureImageHelper();
3348 : GLReadTexImageHelper* ReadTexImageHelper();
3349 :
3350 : // Assumes shares are created by all sharing with the same global context.
3351 : bool SharesWith(const GLContext* other) const {
3352 : MOZ_ASSERT(!this->mSharedContext || !this->mSharedContext->mSharedContext);
3353 : MOZ_ASSERT(!other->mSharedContext || !other->mSharedContext->mSharedContext);
3354 : MOZ_ASSERT(!this->mSharedContext ||
3355 : !other->mSharedContext ||
3356 : this->mSharedContext == other->mSharedContext);
3357 :
3358 : const GLContext* thisShared = this->mSharedContext ? this->mSharedContext
3359 : : this;
3360 : const GLContext* otherShared = other->mSharedContext ? other->mSharedContext
3361 : : other;
3362 :
3363 : return thisShared == otherShared;
3364 : }
3365 :
3366 : bool InitOffscreen(const gfx::IntSize& size, const SurfaceCaps& caps);
3367 :
3368 : protected:
3369 : // Note that it does -not- clear the resized buffers.
3370 0 : bool CreateScreenBuffer(const gfx::IntSize& size, const SurfaceCaps& caps) {
3371 0 : if (!IsOffscreenSizeAllowed(size))
3372 0 : return false;
3373 :
3374 0 : return CreateScreenBufferImpl(size, caps);
3375 : }
3376 :
3377 : bool CreateScreenBufferImpl(const gfx::IntSize& size,
3378 : const SurfaceCaps& caps);
3379 :
3380 : public:
3381 : bool ResizeScreenBuffer(const gfx::IntSize& size);
3382 :
3383 : protected:
3384 : SurfaceCaps mCaps;
3385 :
3386 : public:
3387 0 : const SurfaceCaps& Caps() const {
3388 0 : return mCaps;
3389 : }
3390 :
3391 : // Only varies based on bpp16 and alpha.
3392 : GLFormats ChooseGLFormats(const SurfaceCaps& caps) const;
3393 :
3394 : bool IsFramebufferComplete(GLuint fb, GLenum* status = nullptr);
3395 :
3396 : // Does not check completeness.
3397 : void AttachBuffersToFB(GLuint colorTex, GLuint colorRB,
3398 : GLuint depthRB, GLuint stencilRB,
3399 : GLuint fb, GLenum target = LOCAL_GL_TEXTURE_2D);
3400 :
3401 : // Passing null is fine if the value you'd get is 0.
3402 : bool AssembleOffscreenFBs(const GLuint colorMSRB,
3403 : const GLuint depthRB,
3404 : const GLuint stencilRB,
3405 : const GLuint texture,
3406 : GLuint* drawFB,
3407 : GLuint* readFB);
3408 :
3409 : protected:
3410 : friend class GLScreenBuffer;
3411 : UniquePtr<GLScreenBuffer> mScreen;
3412 :
3413 : SharedSurface* mLockedSurface;
3414 :
3415 : public:
3416 0 : void LockSurface(SharedSurface* surf) {
3417 0 : MOZ_ASSERT(!mLockedSurface);
3418 0 : mLockedSurface = surf;
3419 0 : }
3420 :
3421 0 : void UnlockSurface(SharedSurface* surf) {
3422 0 : MOZ_ASSERT(mLockedSurface == surf);
3423 0 : mLockedSurface = nullptr;
3424 0 : }
3425 :
3426 0 : SharedSurface* GetLockedSurface() const {
3427 0 : return mLockedSurface;
3428 : }
3429 :
3430 0 : bool IsOffscreen() const {
3431 0 : return mIsOffscreen;
3432 : }
3433 :
3434 0 : GLScreenBuffer* Screen() const {
3435 0 : return mScreen.get();
3436 : }
3437 :
3438 : /* Clear to transparent black, with 0 depth and stencil,
3439 : * while preserving current ClearColor etc. values.
3440 : * Useful for resizing offscreen buffers.
3441 : */
3442 : void ClearSafely();
3443 :
3444 0 : bool WorkAroundDriverBugs() const { return mWorkAroundDriverBugs; }
3445 :
3446 : bool IsDrawingToDefaultFramebuffer();
3447 :
3448 : bool IsOffscreenSizeAllowed(const gfx::IntSize& aSize) const;
3449 :
3450 : protected:
3451 : bool InitWithPrefix(const char* prefix, bool trygl);
3452 :
3453 : private:
3454 : bool InitWithPrefixImpl(const char* prefix, bool trygl);
3455 : void LoadMoreSymbols(const char* prefix, bool trygl);
3456 : bool LoadExtSymbols(const char* prefix, bool trygl, const SymLoadStruct* list,
3457 : GLExtensions ext);
3458 : bool LoadFeatureSymbols(const char* prefix, bool trygl, const SymLoadStruct* list,
3459 : GLFeature feature);
3460 :
3461 : protected:
3462 : void InitExtensions();
3463 :
3464 : GLint mViewportRect[4];
3465 : GLint mScissorRect[4];
3466 :
3467 : GLint mMaxTextureSize;
3468 : GLint mMaxCubeMapTextureSize;
3469 : GLint mMaxTextureImageSize;
3470 : GLint mMaxRenderbufferSize;
3471 : GLint mMaxViewportDims[2];
3472 : GLsizei mMaxSamples;
3473 : bool mNeedsTextureSizeChecks;
3474 : bool mNeedsFlushBeforeDeleteFB;
3475 : bool mTextureAllocCrashesOnMapFailure;
3476 : bool mNeedsCheckAfterAttachTextureToFb;
3477 : bool mWorkAroundDriverBugs;
3478 :
3479 0 : bool IsTextureSizeSafeToPassToDriver(GLenum target, GLsizei width, GLsizei height) const {
3480 0 : if (mNeedsTextureSizeChecks) {
3481 : // some drivers incorrectly handle some large texture sizes that are below the
3482 : // max texture size that they report. So we check ourselves against our own values
3483 : // (mMax[CubeMap]TextureSize).
3484 : // see bug 737182 for Mac Intel 2D textures
3485 : // see bug 684882 for Mac Intel cube map textures
3486 : // see bug 814716 for Mesa Nouveau
3487 0 : GLsizei maxSize = target == LOCAL_GL_TEXTURE_CUBE_MAP ||
3488 0 : (target >= LOCAL_GL_TEXTURE_CUBE_MAP_POSITIVE_X &&
3489 : target <= LOCAL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z)
3490 0 : ? mMaxCubeMapTextureSize
3491 0 : : mMaxTextureSize;
3492 0 : return width <= maxSize && height <= maxSize;
3493 : }
3494 0 : return true;
3495 : }
3496 :
3497 :
3498 : public:
3499 0 : GLsizei MaxSamples() const {
3500 0 : return mMaxSamples;
3501 : }
3502 :
3503 0 : void fViewport(GLint x, GLint y, GLsizei width, GLsizei height) {
3504 0 : if (mViewportRect[0] == x &&
3505 0 : mViewportRect[1] == y &&
3506 0 : mViewportRect[2] == width &&
3507 0 : mViewportRect[3] == height)
3508 : {
3509 0 : return;
3510 : }
3511 0 : mViewportRect[0] = x;
3512 0 : mViewportRect[1] = y;
3513 0 : mViewportRect[2] = width;
3514 0 : mViewportRect[3] = height;
3515 0 : BEFORE_GL_CALL;
3516 0 : mSymbols.fViewport(x, y, width, height);
3517 0 : AFTER_GL_CALL;
3518 : }
3519 :
3520 : #undef ASSERT_SYMBOL_PRESENT
3521 :
3522 : #ifdef MOZ_GL_DEBUG
3523 : void CreatedProgram(GLContext* aOrigin, GLuint aName);
3524 : void CreatedShader(GLContext* aOrigin, GLuint aName);
3525 : void CreatedBuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3526 : void CreatedQueries(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3527 : void CreatedTextures(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3528 : void CreatedFramebuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3529 : void CreatedRenderbuffers(GLContext* aOrigin, GLsizei aCount, GLuint* aNames);
3530 : void DeletedProgram(GLContext* aOrigin, GLuint aName);
3531 : void DeletedShader(GLContext* aOrigin, GLuint aName);
3532 : void DeletedBuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3533 : void DeletedQueries(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3534 : void DeletedTextures(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3535 : void DeletedFramebuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3536 : void DeletedRenderbuffers(GLContext* aOrigin, GLsizei aCount, const GLuint* aNames);
3537 :
3538 : void SharedContextDestroyed(GLContext* aChild);
3539 : void ReportOutstandingNames();
3540 :
3541 : struct NamedResource {
3542 : NamedResource()
3543 : : origin(nullptr), name(0), originDeleted(false)
3544 : { }
3545 :
3546 0 : NamedResource(GLContext* aOrigin, GLuint aName)
3547 0 : : origin(aOrigin), name(aName), originDeleted(false)
3548 0 : { }
3549 :
3550 : GLContext* origin;
3551 : GLuint name;
3552 : bool originDeleted;
3553 :
3554 : // for sorting
3555 0 : bool operator<(const NamedResource& aOther) const {
3556 0 : if (intptr_t(origin) < intptr_t(aOther.origin))
3557 0 : return true;
3558 0 : if (name < aOther.name)
3559 0 : return true;
3560 0 : return false;
3561 : }
3562 0 : bool operator==(const NamedResource& aOther) const {
3563 0 : return origin == aOther.origin &&
3564 0 : name == aOther.name &&
3565 0 : originDeleted == aOther.originDeleted;
3566 : }
3567 : };
3568 :
3569 : nsTArray<NamedResource> mTrackedPrograms;
3570 : nsTArray<NamedResource> mTrackedShaders;
3571 : nsTArray<NamedResource> mTrackedTextures;
3572 : nsTArray<NamedResource> mTrackedFramebuffers;
3573 : nsTArray<NamedResource> mTrackedRenderbuffers;
3574 : nsTArray<NamedResource> mTrackedBuffers;
3575 : nsTArray<NamedResource> mTrackedQueries;
3576 : #endif
3577 :
3578 :
3579 : protected:
3580 : bool mHeavyGLCallsSinceLastFlush;
3581 :
3582 : public:
3583 : void FlushIfHeavyGLCallsSinceLastFlush();
3584 : static bool ShouldSpew();
3585 : static bool ShouldDumpExts();
3586 : void Readback(SharedSurface* src, gfx::DataSourceSurface* dest);
3587 :
3588 : ////
3589 :
3590 : void TexParams_SetClampNoMips(GLenum target = LOCAL_GL_TEXTURE_2D) {
3591 : fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_S, LOCAL_GL_CLAMP_TO_EDGE);
3592 : fTexParameteri(target, LOCAL_GL_TEXTURE_WRAP_T, LOCAL_GL_CLAMP_TO_EDGE);
3593 : fTexParameteri(target, LOCAL_GL_TEXTURE_MAG_FILTER, LOCAL_GL_NEAREST);
3594 : fTexParameteri(target, LOCAL_GL_TEXTURE_MIN_FILTER, LOCAL_GL_NEAREST);
3595 : }
3596 : };
3597 :
3598 : bool DoesStringMatch(const char* aString, const char* aWantedString);
3599 :
3600 : void SplitByChar(const nsACString& str, const char delim,
3601 : std::vector<nsCString>* const out);
3602 :
3603 : template<size_t N>
3604 : bool
3605 0 : MarkBitfieldByString(const nsACString& str, const char* const (&markStrList)[N],
3606 : std::bitset<N>* const out_markList)
3607 : {
3608 0 : for (size_t i = 0; i < N; i++) {
3609 0 : if (str.Equals(markStrList[i])) {
3610 0 : (*out_markList)[i] = 1;
3611 0 : return true;
3612 : }
3613 : }
3614 0 : return false;
3615 : }
3616 :
3617 : template<size_t N>
3618 : void
3619 0 : MarkBitfieldByStrings(const std::vector<nsCString>& strList,
3620 : bool dumpStrings, const char* const (&markStrList)[N],
3621 : std::bitset<N>* const out_markList)
3622 : {
3623 0 : for (auto itr = strList.begin(); itr != strList.end(); ++itr) {
3624 0 : const nsACString& str = *itr;
3625 : const bool wasMarked = MarkBitfieldByString(str, markStrList,
3626 0 : out_markList);
3627 0 : if (dumpStrings)
3628 0 : printf_stderr(" %s%s\n", str.BeginReading(), wasMarked ? "(*)" : "");
3629 : }
3630 0 : }
3631 :
3632 : /**
3633 : * Helper function that creates a 2D texture aSize.width x aSize.height with
3634 : * storage type specified by aFormats. Returns GL texture object id.
3635 : *
3636 : * See mozilla::gl::CreateTexture.
3637 : */
3638 : GLuint CreateTextureForOffscreen(GLContext* aGL, const GLFormats& aFormats,
3639 : const gfx::IntSize& aSize);
3640 :
3641 : /**
3642 : * Helper function that creates a 2D texture aSize.width x aSize.height with
3643 : * storage type aInternalFormat. Returns GL texture object id.
3644 : *
3645 : * Initialize textyre parameters to:
3646 : * GL_TEXTURE_MIN_FILTER = GL_LINEAR
3647 : * GL_TEXTURE_MAG_FILTER = GL_LINEAR
3648 : * GL_TEXTURE_WRAP_S = GL_CLAMP_TO_EDGE
3649 : * GL_TEXTURE_WRAP_T = GL_CLAMP_TO_EDGE
3650 : */
3651 : GLuint CreateTexture(GLContext* aGL, GLenum aInternalFormat, GLenum aFormat,
3652 : GLenum aType, const gfx::IntSize& aSize, bool linear = true);
3653 :
3654 : /**
3655 : * Helper function that calculates the number of bytes required per
3656 : * texel for a texture from its format and type.
3657 : */
3658 : uint32_t GetBytesPerTexel(GLenum format, GLenum type);
3659 :
3660 : } /* namespace gl */
3661 : } /* namespace mozilla */
3662 :
3663 : #endif /* GLCONTEXT_H_ */
|
