The Tor Browser: gfx/skia/trunk/include/gpu/gl/GrGLInterface.h@deefc01c0e14

Integrate friendly tips from Tor colleagues to make (or not) 4.5 alpha 3;
This includes removal of overloaded (but unused) methods, and addition of
a overlooked call to DataStruct::SetData(nsISupports, uint32_t, bool.)

     1 /*

     2  * Copyright 2011 Google Inc.

     3  *

     4  * Use of this source code is governed by a BSD-style license that can be

     5  * found in the LICENSE file.

     6  */

     8 #ifndef GrGLInterface_DEFINED

     9 #define GrGLInterface_DEFINED

    11 #include "GrGLFunctions.h"

    12 #include "GrGLExtensions.h"

    13 #include "SkRefCnt.h"

    15 ////////////////////////////////////////////////////////////////////////////////

    17 /**

    18  * Rather than depend on platform-specific GL headers and libraries, we require

    19  * the client to provide a struct of GL function pointers. This struct can be

    20  * specified per-GrContext as a parameter to GrContext::Create. If NULL is

    21  * passed to Create then a "default" GL interface is created. If the default is

    22  * also NULL GrContext creation will fail.

    23  *

    24  * The default interface is returned by GrGLDefaultInterface. This function's

    25  * implementation is platform-specific. Several have been provided, along with

    26  * an implementation that simply returns NULL.

    27  *

    28  * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a

    29  * callback function that will be called prior to each GL function call. See

    30  * comments in GrGLConfig.h

    31  */

    33 struct GrGLInterface;

    35 const GrGLInterface* GrGLDefaultInterface();

    37 /**

    38  * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,

    39  * GLX on linux, AGL on Mac). The interface is only valid for the GL context

    40  * that is current when the interface is created.

    41  */

    42 const GrGLInterface* GrGLCreateNativeInterface();

    44 #if SK_MESA

    45 /**

    46  * Creates a GrGLInterface for an OSMesa context.

    47  */

    48 const GrGLInterface* GrGLCreateMesaInterface();

    49 #endif

    51 #if SK_ANGLE

    52 /**

    53  * Creates a GrGLInterface for an ANGLE context.

    54  */

    55 const GrGLInterface* GrGLCreateANGLEInterface();

    56 #endif

    58 /**

    59  * Creates a null GrGLInterface that doesn't draw anything. Used for measuring

    60  * CPU overhead.

    61  */

    62 const SK_API GrGLInterface* GrGLCreateNullInterface();

    64 /**

    65  * Creates a debugging GrGLInterface that doesn't draw anything. Used for

    66  * finding memory leaks and invalid memory accesses.

    67  */

    68 const GrGLInterface* GrGLCreateDebugInterface();

    70 #if GR_GL_PER_GL_FUNC_CALLBACK

    71 typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);

    72 typedef intptr_t GrGLInterfaceCallbackData;

    73 #endif

    75 /** Function that returns a new interface identical to "interface" but without support for

    76     GL_NV_path_rendering. */

    77 const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);

    79 /** Function that returns a new interface identical to "interface" but with support for

    80     test version of GL_EXT_debug_marker. */

    81 const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,

    82                                                      GrGLInsertEventMarkerProc insertEventMarkerFn,

    83                                                      GrGLPushGroupMarkerProc pushGroupMarkerFn,

    84                                                      GrGLPopGroupMarkerProc popGroupMarkerFn);

    86 /**

    87  * GrContext uses the following interface to make all calls into OpenGL. When a

    88  * GrContext is created it is given a GrGLInterface. The interface's function

    89  * pointers must be valid for the OpenGL context associated with the GrContext.

    90  * On some platforms, such as Windows, function pointers for OpenGL extensions

    91  * may vary between OpenGL contexts. So the caller must be careful to use a

    92  * GrGLInterface initialized for the correct context. All functions that should

    93  * be available based on the OpenGL's version and extension string must be

    94  * non-NULL or GrContext creation will fail. This can be tested with the

    95  * validate() method when the OpenGL context has been made current.

    96  */

    97 struct SK_API GrGLInterface : public SkRefCnt {

    98 private:

    99     // simple wrapper class that exists only to initialize a pointer to NULL

   100     template <typename FNPTR_TYPE> class GLPtr {

   101     public:

   102         GLPtr() : fPtr(NULL) {}

   103         GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }

   104         operator FNPTR_TYPE() const { return fPtr; }

   105     private:

   106         FNPTR_TYPE fPtr;

   107     };

   109     // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until

   110     // they're updated to use the Functions struct.

   111     template <typename FNPTR_TYPE> class GLPtrAlias {

   112     public:

   113         GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}

   114         void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }

   115     private:

   116         GLPtr<FNPTR_TYPE>* fBase;

   117     };

   119     typedef SkRefCnt INHERITED;

   121 public:

   122     SK_DECLARE_INST_COUNT(GrGLInterface)

   124     GrGLInterface();

   126     static GrGLInterface* NewClone(const GrGLInterface*);

   128     // Validates that the GrGLInterface supports its advertised standard. This means the necessary

   129     // function pointers have been initialized for both the GL version and any advertised

   130     // extensions.

   131     bool validate() const;

   133     // Indicates the type of GL implementation

   134     union {

   135         GrGLStandard fStandard;

   136         GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.

   137     };

   139     GrGLExtensions fExtensions;

   141     bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }

   143     /**

   144      * The function pointers are in a struct so that we can have a compiler generated assignment

   145      * operator.

   146      */

   147     struct Functions {

   148         GLPtr<GrGLActiveTextureProc> fActiveTexture;

   149         GLPtr<GrGLAttachShaderProc> fAttachShader;

   150         GLPtr<GrGLBeginQueryProc> fBeginQuery;

   151         GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;

   152         GLPtr<GrGLBindBufferProc> fBindBuffer;

   153         GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;

   154         GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;

   155         GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;

   156         GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;

   157         GLPtr<GrGLBindTextureProc> fBindTexture;

   158         GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;

   159         GLPtr<GrGLBlendColorProc> fBlendColor;

   160         GLPtr<GrGLBlendFuncProc> fBlendFunc;

   161         GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;

   162         GLPtr<GrGLBufferDataProc> fBufferData;

   163         GLPtr<GrGLBufferSubDataProc> fBufferSubData;

   164         GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;

   165         GLPtr<GrGLClearProc> fClear;

   166         GLPtr<GrGLClearColorProc> fClearColor;

   167         GLPtr<GrGLClearStencilProc> fClearStencil;

   168         GLPtr<GrGLColorMaskProc> fColorMask;

   169         GLPtr<GrGLCompileShaderProc> fCompileShader;

   170         GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;

   171         GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;

   172         GLPtr<GrGLCreateProgramProc> fCreateProgram;

   173         GLPtr<GrGLCreateShaderProc> fCreateShader;

   174         GLPtr<GrGLCullFaceProc> fCullFace;

   175         GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;

   176         GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;

   177         GLPtr<GrGLDeleteProgramProc> fDeleteProgram;

   178         GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;

   179         GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;

   180         GLPtr<GrGLDeleteShaderProc> fDeleteShader;

   181         GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;

   182         GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;

   183         GLPtr<GrGLDepthMaskProc> fDepthMask;

   184         GLPtr<GrGLDisableProc> fDisable;

   185         GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;

   186         GLPtr<GrGLDrawArraysProc> fDrawArrays;

   187         GLPtr<GrGLDrawBufferProc> fDrawBuffer;

   188         GLPtr<GrGLDrawBuffersProc> fDrawBuffers;

   189         GLPtr<GrGLDrawElementsProc> fDrawElements;

   190         GLPtr<GrGLEnableProc> fEnable;

   191         GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;

   192         GLPtr<GrGLEndQueryProc> fEndQuery;

   193         GLPtr<GrGLFinishProc> fFinish;

   194         GLPtr<GrGLFlushProc> fFlush;

   195         GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;

   196         GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;

   197         GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;

   198         GLPtr<GrGLFrontFaceProc> fFrontFace;

   199         GLPtr<GrGLGenBuffersProc> fGenBuffers;

   200         GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;

   201         GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;

   202         GLPtr<GrGLGenQueriesProc> fGenQueries;

   203         GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;

   204         GLPtr<GrGLGenTexturesProc> fGenTextures;

   205         GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;

   206         GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;

   207         GLPtr<GrGLGetErrorProc> fGetError;

   208         GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;

   209         GLPtr<GrGLGetIntegervProc> fGetIntegerv;

   210         GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;

   211         GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;

   212         GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;

   213         GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;

   214         GLPtr<GrGLGetQueryivProc> fGetQueryiv;

   215         GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;

   216         GLPtr<GrGLGetProgramivProc> fGetProgramiv;

   217         GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;

   218         GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;

   219         GLPtr<GrGLGetShaderivProc> fGetShaderiv;

   220         GLPtr<GrGLGetStringProc> fGetString;

   221         GLPtr<GrGLGetStringiProc> fGetStringi;

   222         GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;

   223         GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;

   224         GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;

   225         GLPtr<GrGLLineWidthProc> fLineWidth;

   226         GLPtr<GrGLLinkProgramProc> fLinkProgram;

   227         GLPtr<GrGLLoadIdentityProc> fLoadIdentity;

   228         GLPtr<GrGLLoadMatrixfProc> fLoadMatrixf;

   229         GLPtr<GrGLMapBufferProc> fMapBuffer;

   230         GLPtr<GrGLMatrixModeProc> fMatrixMode;

   231         GLPtr<GrGLPixelStoreiProc> fPixelStorei;

   232         GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;

   233         GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;

   234         GLPtr<GrGLQueryCounterProc> fQueryCounter;

   235         GLPtr<GrGLReadBufferProc> fReadBuffer;

   236         GLPtr<GrGLReadPixelsProc> fReadPixels;

   237         GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;

   239         //  On OpenGL ES there are multiple incompatible extensions that add support for MSAA

   240         //  and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the

   241         //  older extensions for performance reasons or due to ES3 driver bugs. We want the function

   242         //  that creates the GrGLInterface to provide all available functions and internally

   243         //  we will select among them. They all have a method called glRenderbufferStorageMultisample*.

   244         //  So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,

   245         //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample

   246         //  variations.

   247         //

   248         //  If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will

   249         //  assume the function pointers for the standard (or equivalent GL_ARB) version have

   250         //  been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced

   251         //  functionality.

   253         //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture

   254         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;

   255         //  GL_APPLE_framebuffer_multisample

   256         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;

   258         //  This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or

   259         //  the standard function in ES3+ or GL 3.0+.

   260         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;

   262         // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.

   263         GLPtr<GrGLBindUniformLocation> fBindUniformLocation;

   265         GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;

   266         GLPtr<GrGLScissorProc> fScissor;

   267         GLPtr<GrGLShaderSourceProc> fShaderSource;

   268         GLPtr<GrGLStencilFuncProc> fStencilFunc;

   269         GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;

   270         GLPtr<GrGLStencilMaskProc> fStencilMask;

   271         GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;

   272         GLPtr<GrGLStencilOpProc> fStencilOp;

   273         GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;

   274         GLPtr<GrGLTexGenfvProc> fTexGenfv;

   275         GLPtr<GrGLTexGeniProc> fTexGeni;

   276         GLPtr<GrGLTexImage2DProc> fTexImage2D;

   277         GLPtr<GrGLTexParameteriProc> fTexParameteri;

   278         GLPtr<GrGLTexParameterivProc> fTexParameteriv;

   279         GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;

   280         GLPtr<GrGLTexStorage2DProc> fTexStorage2D;

   281         GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;

   282         GLPtr<GrGLUniform1fProc> fUniform1f;

   283         GLPtr<GrGLUniform1iProc> fUniform1i;

   284         GLPtr<GrGLUniform1fvProc> fUniform1fv;

   285         GLPtr<GrGLUniform1ivProc> fUniform1iv;

   286         GLPtr<GrGLUniform2fProc> fUniform2f;

   287         GLPtr<GrGLUniform2iProc> fUniform2i;

   288         GLPtr<GrGLUniform2fvProc> fUniform2fv;

   289         GLPtr<GrGLUniform2ivProc> fUniform2iv;

   290         GLPtr<GrGLUniform3fProc> fUniform3f;

   291         GLPtr<GrGLUniform3iProc> fUniform3i;

   292         GLPtr<GrGLUniform3fvProc> fUniform3fv;

   293         GLPtr<GrGLUniform3ivProc> fUniform3iv;

   294         GLPtr<GrGLUniform4fProc> fUniform4f;

   295         GLPtr<GrGLUniform4iProc> fUniform4i;

   296         GLPtr<GrGLUniform4fvProc> fUniform4fv;

   297         GLPtr<GrGLUniform4ivProc> fUniform4iv;

   298         GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;

   299         GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;

   300         GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;

   301         GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;

   302         GLPtr<GrGLUseProgramProc> fUseProgram;

   303         GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;

   304         GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;

   305         GLPtr<GrGLViewportProc> fViewport;

   307         // Experimental: Functions for GL_NV_path_rendering. These will be

   308         // alphabetized with the above functions once this is fully supported

   309         // (and functions we are unlikely to use will possibly be omitted).

   310         GLPtr<GrGLPathCommandsProc> fPathCommands;

   311         GLPtr<GrGLPathCoordsProc> fPathCoords;

   312         GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;

   313         GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;

   314         GLPtr<GrGLPathStringProc> fPathString;

   315         GLPtr<GrGLPathGlyphsProc> fPathGlyphs;

   316         GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;

   317         GLPtr<GrGLWeightPathsProc> fWeightPaths;

   318         GLPtr<GrGLCopyPathProc> fCopyPath;

   319         GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;

   320         GLPtr<GrGLTransformPathProc> fTransformPath;

   321         GLPtr<GrGLPathParameterivProc> fPathParameteriv;

   322         GLPtr<GrGLPathParameteriProc> fPathParameteri;

   323         GLPtr<GrGLPathParameterfvProc> fPathParameterfv;

   324         GLPtr<GrGLPathParameterfProc> fPathParameterf;

   325         GLPtr<GrGLPathDashArrayProc> fPathDashArray;

   326         GLPtr<GrGLGenPathsProc> fGenPaths;

   327         GLPtr<GrGLDeletePathsProc> fDeletePaths;

   328         GLPtr<GrGLIsPathProc> fIsPath;

   329         GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;

   330         GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;

   331         GLPtr<GrGLStencilFillPathProc> fStencilFillPath;

   332         GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;

   333         GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;

   334         GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;

   335         GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;

   336         GLPtr<GrGLPathColorGenProc> fPathColorGen;

   337         GLPtr<GrGLPathTexGenProc> fPathTexGen;

   338         GLPtr<GrGLPathFogGenProc> fPathFogGen;

   339         GLPtr<GrGLCoverFillPathProc> fCoverFillPath;

   340         GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;

   341         GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;

   342         GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;

   343         GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;

   344         GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;

   345         GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;

   346         GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;

   347         GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;

   348         GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;

   349         GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;

   350         GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;

   351         GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;

   352         GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;

   353         GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;

   354         GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;

   355         GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;

   356         GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;

   357         GLPtr<GrGLGetPathLengthProc> fGetPathLength;

   358         GLPtr<GrGLPointAlongPathProc> fPointAlongPath;

   359     } fFunctions;

   361     // Per-GL func callback

   362 #if GR_GL_PER_GL_FUNC_CALLBACK

   363     GrGLInterfaceCallbackProc fCallback;

   364     GrGLInterfaceCallbackData fCallbackData;

   365 #endif

   366 };

   368 #endif

The Tor Browser / file revision

gfx/skia/trunk/include/gpu/gl/GrGLInterface.h@deefc01c0e14

gfx/skia/trunk/include/gpu/gl/GrGLInterface.h