include/gpu/gl/GrGLInterface.h - skia - Git at Google


            
            /*

            
             * Copyright 2011 Google Inc.

            
             *

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

            
             * found in the LICENSE file.

            
             */


            #ifndef GrGLInterface_DEFINED

            
            #define GrGLInterface_DEFINED


            #include "GrGLFunctions.h"

            
            #include "GrGLExtensions.h"

            
            #include "SkRefCnt.h"


            ////////////////////////////////////////////////////////////////////////////////


            /**

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

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

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

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

            
             * also NULL GrContext creation will fail.

            
             *

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

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

            
             * an implementation that simply returns NULL.

            
             *

            
             * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a

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

            
             * comments in GrGLConfig.h

            
             */


            struct GrGLInterface;


            const GrGLInterface* GrGLDefaultInterface();


            /**

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

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

            
             * that is current when the interface is created.

            
             */

            
            const GrGLInterface* GrGLCreateNativeInterface();


            #if SK_MESA

            
            /**

            
             * Creates a GrGLInterface for an OSMesa context.

            
             */

            
            const GrGLInterface* GrGLCreateMesaInterface();

            
            #endif


            #if SK_ANGLE

            
            /**

            
             * Creates a GrGLInterface for an ANGLE context.

            
             */

            
            const GrGLInterface* GrGLCreateANGLEInterface();

            
            #endif


            /**

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

            
             * CPU overhead.

            
             */

            
            const SK_API GrGLInterface* GrGLCreateNullInterface();


            /**

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

            
             * finding memory leaks and invalid memory accesses.

            
             */

            
            const GrGLInterface* GrGLCreateDebugInterface();


            #if GR_GL_PER_GL_FUNC_CALLBACK

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

            
            typedef intptr_t GrGLInterfaceCallbackData;

            
            #endif


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

            
                GL_NV_path_rendering. */

            
            const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);


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

            
                test version of GL_EXT_debug_marker. */

            
            const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,

            
                                                                 GrGLInsertEventMarkerProc insertEventMarkerFn,

            
                                                                 GrGLPushGroupMarkerProc pushGroupMarkerFn,

            
                                                                 GrGLPopGroupMarkerProc popGroupMarkerFn);


            /**

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

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

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

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

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

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

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

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

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

            
             */

            
            struct SK_API GrGLInterface : public SkRefCnt {

            
            private:

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

            
                template <typename FNPTR_TYPE> class GLPtr {

            
                public:

            
                    GLPtr() : fPtr(NULL) {}

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

            
                    operator FNPTR_TYPE() const { return fPtr; }

            
                private:

            
                    FNPTR_TYPE fPtr;

            
                };


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

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

            
                template <typename FNPTR_TYPE> class GLPtrAlias {

            
                public:

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

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

            
                private:

            
                    GLPtr<FNPTR_TYPE>* fBase;

            
                };


                typedef SkRefCnt INHERITED;


            public:

            
                SK_DECLARE_INST_COUNT(GrGLInterface)


                GrGLInterface();


                static GrGLInterface* NewClone(const GrGLInterface*);


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

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

            
                // extensions.

            
                bool validate() const;


                // Indicates the type of GL implementation

            
                union {

            
                    GrGLStandard fStandard;

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

            
                };


                GrGLExtensions fExtensions;


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


                /**

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

            
                 * operator.

            
                 */

            
                struct Functions {

            
                    GLPtr<GrGLActiveTextureProc> fActiveTexture;

            
                    GLPtr<GrGLAttachShaderProc> fAttachShader;

            
                    GLPtr<GrGLBeginQueryProc> fBeginQuery;

            
                    GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;

            
                    GLPtr<GrGLBindBufferProc> fBindBuffer;

            
                    GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;

            
                    GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;

            
                    GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;

            
                    GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;

            
                    GLPtr<GrGLBindTextureProc> fBindTexture;

            
                    GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;

            
                    GLPtr<GrGLBlendColorProc> fBlendColor;

            
                    GLPtr<GrGLBlendFuncProc> fBlendFunc;

            
                    GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;

            
                    GLPtr<GrGLBufferDataProc> fBufferData;

            
                    GLPtr<GrGLBufferSubDataProc> fBufferSubData;

            
                    GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;

            
                    GLPtr<GrGLClearProc> fClear;

            
                    GLPtr<GrGLClearColorProc> fClearColor;

            
                    GLPtr<GrGLClearStencilProc> fClearStencil;

            
                    GLPtr<GrGLColorMaskProc> fColorMask;

            
                    GLPtr<GrGLCompileShaderProc> fCompileShader;

            
                    GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;

            
                    GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;

            
                    GLPtr<GrGLCreateProgramProc> fCreateProgram;

            
                    GLPtr<GrGLCreateShaderProc> fCreateShader;

            
                    GLPtr<GrGLCullFaceProc> fCullFace;

            
                    GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;

            
                    GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;

            
                    GLPtr<GrGLDeleteProgramProc> fDeleteProgram;

            
                    GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;

            
                    GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;

            
                    GLPtr<GrGLDeleteShaderProc> fDeleteShader;

            
                    GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;

            
                    GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;

            
                    GLPtr<GrGLDepthMaskProc> fDepthMask;

            
                    GLPtr<GrGLDisableProc> fDisable;

            
                    GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;

            
                    GLPtr<GrGLDrawArraysProc> fDrawArrays;

            
                    GLPtr<GrGLDrawBufferProc> fDrawBuffer;

            
                    GLPtr<GrGLDrawBuffersProc> fDrawBuffers;

            
                    GLPtr<GrGLDrawElementsProc> fDrawElements;

            
                    GLPtr<GrGLEnableProc> fEnable;

            
                    GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;

            
                    GLPtr<GrGLEndQueryProc> fEndQuery;

            
                    GLPtr<GrGLFinishProc> fFinish;

            
                    GLPtr<GrGLFlushProc> fFlush;

            
                    GLPtr<GrGLFlushMappedBufferRangeProc> fFlushMappedBufferRange;

            
                    GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;

            
                    GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;

            
                    GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;

            
                    GLPtr<GrGLFrontFaceProc> fFrontFace;

            
                    GLPtr<GrGLGenBuffersProc> fGenBuffers;

            
                    GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;

            
                    GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;

            
                    GLPtr<GrGLGenQueriesProc> fGenQueries;

            
                    GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;

            
                    GLPtr<GrGLGenTexturesProc> fGenTextures;

            
                    GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;

            
                    GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;

            
                    GLPtr<GrGLGetErrorProc> fGetError;

            
                    GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;

            
                    GLPtr<GrGLGetIntegervProc> fGetIntegerv;

            
                    GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;

            
                    GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;

            
                    GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;

            
                    GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;

            
                    GLPtr<GrGLGetQueryivProc> fGetQueryiv;

            
                    GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;

            
                    GLPtr<GrGLGetProgramivProc> fGetProgramiv;

            
                    GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;

            
                    GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;

            
                    GLPtr<GrGLGetShaderivProc> fGetShaderiv;

            
                    GLPtr<GrGLGetStringProc> fGetString;

            
                    GLPtr<GrGLGetStringiProc> fGetStringi;

            
                    GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;

            
                    GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;

            
                    GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;

            
                    GLPtr<GrGLInvalidateBufferDataProc> fInvalidateBufferData;

            
                    GLPtr<GrGLInvalidateBufferSubDataProc> fInvalidateBufferSubData;

            
                    GLPtr<GrGLInvalidateFramebufferProc> fInvalidateFramebuffer;

            
                    GLPtr<GrGLInvalidateSubFramebufferProc> fInvalidateSubFramebuffer;

            
                    GLPtr<GrGLInvalidateTexImageProc> fInvalidateTexImage;

            
                    GLPtr<GrGLInvalidateTexSubImageProc> fInvalidateTexSubImage;

            
                    GLPtr<GrGLLineWidthProc> fLineWidth;

            
                    GLPtr<GrGLLinkProgramProc> fLinkProgram;

            
                    GLPtr<GrGLMapBufferProc> fMapBuffer;

            
                    GLPtr<GrGLMapBufferRangeProc> fMapBufferRange;

            
                    GLPtr<GrGLMapBufferSubDataProc> fMapBufferSubData;

            
                    GLPtr<GrGLMapTexSubImage2DProc> fMapTexSubImage2D;

            
                    GLPtr<GrGLMatrixLoadfProc> fMatrixLoadf;

            
                    GLPtr<GrGLMatrixLoadIdentityProc> fMatrixLoadIdentity;

            
                    GLPtr<GrGLPixelStoreiProc> fPixelStorei;

            
                    GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;

            
                    GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;

            
                    GLPtr<GrGLQueryCounterProc> fQueryCounter;

            
                    GLPtr<GrGLReadBufferProc> fReadBuffer;

            
                    GLPtr<GrGLReadPixelsProc> fReadPixels;

            
                    GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;


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

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

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

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

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

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

            
                    //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample

            
                    //  variations.

            
                    //

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

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

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

            
                    //  functionality.


                    //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture

            
                    GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;

            
                    //  GL_APPLE_framebuffer_multisample

            
                    GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;


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

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

            
                    GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;


                    // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.

            
                    GLPtr<GrGLBindUniformLocation> fBindUniformLocation;


                    GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;

            
                    GLPtr<GrGLScissorProc> fScissor;

            
                    GLPtr<GrGLShaderSourceProc> fShaderSource;

            
                    GLPtr<GrGLStencilFuncProc> fStencilFunc;

            
                    GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;

            
                    GLPtr<GrGLStencilMaskProc> fStencilMask;

            
                    GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;

            
                    GLPtr<GrGLStencilOpProc> fStencilOp;

            
                    GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;

            
                    GLPtr<GrGLTexImage2DProc> fTexImage2D;

            
                    GLPtr<GrGLTexParameteriProc> fTexParameteri;

            
                    GLPtr<GrGLTexParameterivProc> fTexParameteriv;

            
                    GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;

            
                    GLPtr<GrGLTexStorage2DProc> fTexStorage2D;

            
                    GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;

            
                    GLPtr<GrGLUniform1fProc> fUniform1f;

            
                    GLPtr<GrGLUniform1iProc> fUniform1i;

            
                    GLPtr<GrGLUniform1fvProc> fUniform1fv;

            
                    GLPtr<GrGLUniform1ivProc> fUniform1iv;

            
                    GLPtr<GrGLUniform2fProc> fUniform2f;

            
                    GLPtr<GrGLUniform2iProc> fUniform2i;

            
                    GLPtr<GrGLUniform2fvProc> fUniform2fv;

            
                    GLPtr<GrGLUniform2ivProc> fUniform2iv;

            
                    GLPtr<GrGLUniform3fProc> fUniform3f;

            
                    GLPtr<GrGLUniform3iProc> fUniform3i;

            
                    GLPtr<GrGLUniform3fvProc> fUniform3fv;

            
                    GLPtr<GrGLUniform3ivProc> fUniform3iv;

            
                    GLPtr<GrGLUniform4fProc> fUniform4f;

            
                    GLPtr<GrGLUniform4iProc> fUniform4i;

            
                    GLPtr<GrGLUniform4fvProc> fUniform4fv;

            
                    GLPtr<GrGLUniform4ivProc> fUniform4iv;

            
                    GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;

            
                    GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;

            
                    GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;

            
                    GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;

            
                    GLPtr<GrGLUnmapBufferSubDataProc> fUnmapBufferSubData;

            
                    GLPtr<GrGLUnmapTexSubImage2DProc> fUnmapTexSubImage2D;

            
                    GLPtr<GrGLUseProgramProc> fUseProgram;

            
                    GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;

            
                    GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;

            
                    GLPtr<GrGLViewportProc> fViewport;


                    // Experimental: Functions for GL_NV_path_rendering. These will be

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

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

            
                    GLPtr<GrGLPathCommandsProc> fPathCommands;

            
                    GLPtr<GrGLPathCoordsProc> fPathCoords;

            
                    GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;

            
                    GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;

            
                    GLPtr<GrGLPathStringProc> fPathString;

            
                    GLPtr<GrGLPathGlyphsProc> fPathGlyphs;

            
                    GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;

            
                    GLPtr<GrGLWeightPathsProc> fWeightPaths;

            
                    GLPtr<GrGLCopyPathProc> fCopyPath;

            
                    GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;

            
                    GLPtr<GrGLTransformPathProc> fTransformPath;

            
                    GLPtr<GrGLPathParameterivProc> fPathParameteriv;

            
                    GLPtr<GrGLPathParameteriProc> fPathParameteri;

            
                    GLPtr<GrGLPathParameterfvProc> fPathParameterfv;

            
                    GLPtr<GrGLPathParameterfProc> fPathParameterf;

            
                    GLPtr<GrGLPathDashArrayProc> fPathDashArray;

            
                    GLPtr<GrGLGenPathsProc> fGenPaths;

            
                    GLPtr<GrGLDeletePathsProc> fDeletePaths;

            
                    GLPtr<GrGLIsPathProc> fIsPath;

            
                    GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;

            
                    GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;

            
                    GLPtr<GrGLStencilFillPathProc> fStencilFillPath;

            
                    GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;

            
                    GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;

            
                    GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;

            
                    GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;

            
                    GLPtr<GrGLPathColorGenProc> fPathColorGen;

            
                    GLPtr<GrGLPathTexGenProc> fPathTexGen;

            
                    GLPtr<GrGLPathFogGenProc> fPathFogGen;

            
                    GLPtr<GrGLCoverFillPathProc> fCoverFillPath;

            
                    GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;

            
                    GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;

            
                    GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;

            
                    GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;

            
                    GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;

            
                    GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;

            
                    GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;

            
                    GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;

            
                    GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;

            
                    GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;

            
                    GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;

            
                    GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;

            
                    GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;

            
                    GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;

            
                    GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;

            
                    GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;

            
                    GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;

            
                    GLPtr<GrGLGetPathLengthProc> fGetPathLength;

            
                    GLPtr<GrGLPointAlongPathProc> fPointAlongPath;

            
                } fFunctions;


                // Per-GL func callback

            
            #if GR_GL_PER_GL_FUNC_CALLBACK

            
                GrGLInterfaceCallbackProc fCallback;

            
                GrGLInterfaceCallbackData fCallbackData;

            
            #endif

            
            };


            #endif
	/*
	* Copyright 2011 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#ifndef GrGLInterface_DEFINED
	#define GrGLInterface_DEFINED

	#include "GrGLFunctions.h"
	#include "GrGLExtensions.h"
	#include "SkRefCnt.h"

	////////////////////////////////////////////////////////////////////////////////

	/**
	* Rather than depend on platform-specific GL headers and libraries, we require
	* the client to provide a struct of GL function pointers. This struct can be
	* specified per-GrContext as a parameter to GrContext::Create. If NULL is
	* passed to Create then a "default" GL interface is created. If the default is
	* also NULL GrContext creation will fail.
	*
	* The default interface is returned by GrGLDefaultInterface. This function's
	* implementation is platform-specific. Several have been provided, along with
	* an implementation that simply returns NULL.
	*
	* By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a
	* callback function that will be called prior to each GL function call. See
	* comments in GrGLConfig.h
	*/

	struct GrGLInterface;

	const GrGLInterface* GrGLDefaultInterface();

	/**
	* Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
	* GLX on linux, AGL on Mac). The interface is only valid for the GL context
	* that is current when the interface is created.
	*/
	const GrGLInterface* GrGLCreateNativeInterface();

	#if SK_MESA
	/**
	* Creates a GrGLInterface for an OSMesa context.
	*/
	const GrGLInterface* GrGLCreateMesaInterface();
	#endif

	#if SK_ANGLE
	/**
	* Creates a GrGLInterface for an ANGLE context.
	*/
	const GrGLInterface* GrGLCreateANGLEInterface();
	#endif

	/**
	* Creates a null GrGLInterface that doesn't draw anything. Used for measuring
	* CPU overhead.
	*/
	const SK_API GrGLInterface* GrGLCreateNullInterface();

	/**
	* Creates a debugging GrGLInterface that doesn't draw anything. Used for
	* finding memory leaks and invalid memory accesses.
	*/
	const GrGLInterface* GrGLCreateDebugInterface();

	#if GR_GL_PER_GL_FUNC_CALLBACK
	typedef void (GrGLInterfaceCallbackProc)(const GrGLInterface);
	typedef intptr_t GrGLInterfaceCallbackData;
	#endif

	/** Function that returns a new interface identical to "interface" but without support for
	GL_NV_path_rendering. */
	const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);

	/** Function that returns a new interface identical to "interface" but with support for
	test version of GL_EXT_debug_marker. */
	const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
	GrGLInsertEventMarkerProc insertEventMarkerFn,
	GrGLPushGroupMarkerProc pushGroupMarkerFn,
	GrGLPopGroupMarkerProc popGroupMarkerFn);

	/**
	* GrContext uses the following interface to make all calls into OpenGL. When a
	* GrContext is created it is given a GrGLInterface. The interface's function
	* pointers must be valid for the OpenGL context associated with the GrContext.
	* On some platforms, such as Windows, function pointers for OpenGL extensions
	* may vary between OpenGL contexts. So the caller must be careful to use a
	* GrGLInterface initialized for the correct context. All functions that should
	* be available based on the OpenGL's version and extension string must be
	* non-NULL or GrContext creation will fail. This can be tested with the
	* validate() method when the OpenGL context has been made current.
	*/
	struct SK_API GrGLInterface : public SkRefCnt {
	private:
	// simple wrapper class that exists only to initialize a pointer to NULL
	template <typename FNPTR_TYPE> class GLPtr {
	public:
	GLPtr() : fPtr(NULL) {}
	GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
	operator FNPTR_TYPE() const { return fPtr; }
	private:
	FNPTR_TYPE fPtr;
	};

	// This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
	// they're updated to use the Functions struct.
	template <typename FNPTR_TYPE> class GLPtrAlias {
	public:
	GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
	void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
	private:
	GLPtr<FNPTR_TYPE>* fBase;
	};

	typedef SkRefCnt INHERITED;

	public:
	SK_DECLARE_INST_COUNT(GrGLInterface)

	GrGLInterface();

	static GrGLInterface* NewClone(const GrGLInterface*);

	// Validates that the GrGLInterface supports its advertised standard. This means the necessary
	// function pointers have been initialized for both the GL version and any advertised
	// extensions.
	bool validate() const;

	// Indicates the type of GL implementation
	union {
	GrGLStandard fStandard;
	GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
	};

	GrGLExtensions fExtensions;

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

	/**
	* The function pointers are in a struct so that we can have a compiler generated assignment
	* operator.
	*/
	struct Functions {
	GLPtr<GrGLActiveTextureProc> fActiveTexture;
	GLPtr<GrGLAttachShaderProc> fAttachShader;
	GLPtr<GrGLBeginQueryProc> fBeginQuery;
	GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
	GLPtr<GrGLBindBufferProc> fBindBuffer;
	GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
	GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
	GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
	GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
	GLPtr<GrGLBindTextureProc> fBindTexture;
	GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
	GLPtr<GrGLBlendColorProc> fBlendColor;
	GLPtr<GrGLBlendFuncProc> fBlendFunc;
	GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
	GLPtr<GrGLBufferDataProc> fBufferData;
	GLPtr<GrGLBufferSubDataProc> fBufferSubData;
	GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
	GLPtr<GrGLClearProc> fClear;
	GLPtr<GrGLClearColorProc> fClearColor;
	GLPtr<GrGLClearStencilProc> fClearStencil;
	GLPtr<GrGLColorMaskProc> fColorMask;
	GLPtr<GrGLCompileShaderProc> fCompileShader;
	GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
	GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
	GLPtr<GrGLCreateProgramProc> fCreateProgram;
	GLPtr<GrGLCreateShaderProc> fCreateShader;
	GLPtr<GrGLCullFaceProc> fCullFace;
	GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
	GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
	GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
	GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
	GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
	GLPtr<GrGLDeleteShaderProc> fDeleteShader;
	GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
	GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
	GLPtr<GrGLDepthMaskProc> fDepthMask;
	GLPtr<GrGLDisableProc> fDisable;
	GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
	GLPtr<GrGLDrawArraysProc> fDrawArrays;
	GLPtr<GrGLDrawBufferProc> fDrawBuffer;
	GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
	GLPtr<GrGLDrawElementsProc> fDrawElements;
	GLPtr<GrGLEnableProc> fEnable;
	GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
	GLPtr<GrGLEndQueryProc> fEndQuery;
	GLPtr<GrGLFinishProc> fFinish;
	GLPtr<GrGLFlushProc> fFlush;
	GLPtr<GrGLFlushMappedBufferRangeProc> fFlushMappedBufferRange;
	GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
	GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
	GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
	GLPtr<GrGLFrontFaceProc> fFrontFace;
	GLPtr<GrGLGenBuffersProc> fGenBuffers;
	GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
	GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
	GLPtr<GrGLGenQueriesProc> fGenQueries;
	GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
	GLPtr<GrGLGenTexturesProc> fGenTextures;
	GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
	GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
	GLPtr<GrGLGetErrorProc> fGetError;
	GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
	GLPtr<GrGLGetIntegervProc> fGetIntegerv;
	GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
	GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
	GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
	GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
	GLPtr<GrGLGetQueryivProc> fGetQueryiv;
	GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
	GLPtr<GrGLGetProgramivProc> fGetProgramiv;
	GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
	GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
	GLPtr<GrGLGetShaderivProc> fGetShaderiv;
	GLPtr<GrGLGetStringProc> fGetString;
	GLPtr<GrGLGetStringiProc> fGetStringi;
	GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
	GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
	GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
	GLPtr<GrGLInvalidateBufferDataProc> fInvalidateBufferData;
	GLPtr<GrGLInvalidateBufferSubDataProc> fInvalidateBufferSubData;
	GLPtr<GrGLInvalidateFramebufferProc> fInvalidateFramebuffer;
	GLPtr<GrGLInvalidateSubFramebufferProc> fInvalidateSubFramebuffer;
	GLPtr<GrGLInvalidateTexImageProc> fInvalidateTexImage;
	GLPtr<GrGLInvalidateTexSubImageProc> fInvalidateTexSubImage;
	GLPtr<GrGLLineWidthProc> fLineWidth;
	GLPtr<GrGLLinkProgramProc> fLinkProgram;
	GLPtr<GrGLMapBufferProc> fMapBuffer;
	GLPtr<GrGLMapBufferRangeProc> fMapBufferRange;
	GLPtr<GrGLMapBufferSubDataProc> fMapBufferSubData;
	GLPtr<GrGLMapTexSubImage2DProc> fMapTexSubImage2D;
	GLPtr<GrGLMatrixLoadfProc> fMatrixLoadf;
	GLPtr<GrGLMatrixLoadIdentityProc> fMatrixLoadIdentity;
	GLPtr<GrGLPixelStoreiProc> fPixelStorei;
	GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
	GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
	GLPtr<GrGLQueryCounterProc> fQueryCounter;
	GLPtr<GrGLReadBufferProc> fReadBuffer;
	GLPtr<GrGLReadPixelsProc> fReadPixels;
	GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;

	// On OpenGL ES there are multiple incompatible extensions that add support for MSAA
	// and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
	// older extensions for performance reasons or due to ES3 driver bugs. We want the function
	// that creates the GrGLInterface to provide all available functions and internally
	// we will select among them. They all have a method called glRenderbufferStorageMultisample*.
	// So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
	// GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
	// variations.
	//
	// If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
	// assume the function pointers for the standard (or equivalent GL_ARB) version have
	// been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
	// functionality.

	// GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
	GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
	// GL_APPLE_framebuffer_multisample
	GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;

	// This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
	// the standard function in ES3+ or GL 3.0+.
	GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;

	// Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
	GLPtr<GrGLBindUniformLocation> fBindUniformLocation;

	GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
	GLPtr<GrGLScissorProc> fScissor;
	GLPtr<GrGLShaderSourceProc> fShaderSource;
	GLPtr<GrGLStencilFuncProc> fStencilFunc;
	GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
	GLPtr<GrGLStencilMaskProc> fStencilMask;
	GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
	GLPtr<GrGLStencilOpProc> fStencilOp;
	GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
	GLPtr<GrGLTexImage2DProc> fTexImage2D;
	GLPtr<GrGLTexParameteriProc> fTexParameteri;
	GLPtr<GrGLTexParameterivProc> fTexParameteriv;
	GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
	GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
	GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
	GLPtr<GrGLUniform1fProc> fUniform1f;
	GLPtr<GrGLUniform1iProc> fUniform1i;
	GLPtr<GrGLUniform1fvProc> fUniform1fv;
	GLPtr<GrGLUniform1ivProc> fUniform1iv;
	GLPtr<GrGLUniform2fProc> fUniform2f;
	GLPtr<GrGLUniform2iProc> fUniform2i;
	GLPtr<GrGLUniform2fvProc> fUniform2fv;
	GLPtr<GrGLUniform2ivProc> fUniform2iv;
	GLPtr<GrGLUniform3fProc> fUniform3f;
	GLPtr<GrGLUniform3iProc> fUniform3i;
	GLPtr<GrGLUniform3fvProc> fUniform3fv;
	GLPtr<GrGLUniform3ivProc> fUniform3iv;
	GLPtr<GrGLUniform4fProc> fUniform4f;
	GLPtr<GrGLUniform4iProc> fUniform4i;
	GLPtr<GrGLUniform4fvProc> fUniform4fv;
	GLPtr<GrGLUniform4ivProc> fUniform4iv;
	GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
	GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
	GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
	GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
	GLPtr<GrGLUnmapBufferSubDataProc> fUnmapBufferSubData;
	GLPtr<GrGLUnmapTexSubImage2DProc> fUnmapTexSubImage2D;
	GLPtr<GrGLUseProgramProc> fUseProgram;
	GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
	GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
	GLPtr<GrGLViewportProc> fViewport;

	// Experimental: Functions for GL_NV_path_rendering. These will be
	// alphabetized with the above functions once this is fully supported
	// (and functions we are unlikely to use will possibly be omitted).
	GLPtr<GrGLPathCommandsProc> fPathCommands;
	GLPtr<GrGLPathCoordsProc> fPathCoords;
	GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
	GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
	GLPtr<GrGLPathStringProc> fPathString;
	GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
	GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
	GLPtr<GrGLWeightPathsProc> fWeightPaths;
	GLPtr<GrGLCopyPathProc> fCopyPath;
	GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
	GLPtr<GrGLTransformPathProc> fTransformPath;
	GLPtr<GrGLPathParameterivProc> fPathParameteriv;
	GLPtr<GrGLPathParameteriProc> fPathParameteri;
	GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
	GLPtr<GrGLPathParameterfProc> fPathParameterf;
	GLPtr<GrGLPathDashArrayProc> fPathDashArray;
	GLPtr<GrGLGenPathsProc> fGenPaths;
	GLPtr<GrGLDeletePathsProc> fDeletePaths;
	GLPtr<GrGLIsPathProc> fIsPath;
	GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
	GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
	GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
	GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
	GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
	GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
	GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
	GLPtr<GrGLPathColorGenProc> fPathColorGen;
	GLPtr<GrGLPathTexGenProc> fPathTexGen;
	GLPtr<GrGLPathFogGenProc> fPathFogGen;
	GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
	GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
	GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
	GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
	GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
	GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
	GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
	GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
	GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
	GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
	GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
	GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
	GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
	GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
	GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
	GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
	GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
	GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
	GLPtr<GrGLGetPathLengthProc> fGetPathLength;
	GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
	} fFunctions;

	// Per-GL func callback
	#if GR_GL_PER_GL_FUNC_CALLBACK
	GrGLInterfaceCallbackProc fCallback;
	GrGLInterfaceCallbackData fCallbackData;
	#endif
	};

	#endif