michael@0: /*
michael@0:  * Copyright 2011 Google Inc.
michael@0:  *
michael@0:  * Use of this source code is governed by a BSD-style license that can be
michael@0:  * found in the LICENSE file.
michael@0:  */
michael@0: 
michael@0: #ifndef GrGLInterface_DEFINED
michael@0: #define GrGLInterface_DEFINED
michael@0: 
michael@0: #include "GrGLFunctions.h"
michael@0: #include "GrGLExtensions.h"
michael@0: #include "SkRefCnt.h"
michael@0: 
michael@0: ////////////////////////////////////////////////////////////////////////////////
michael@0: 
michael@0: /**
michael@0:  * Rather than depend on platform-specific GL headers and libraries, we require
michael@0:  * the client to provide a struct of GL function pointers. This struct can be
michael@0:  * specified per-GrContext as a parameter to GrContext::Create. If NULL is
michael@0:  * passed to Create then a "default" GL interface is created. If the default is
michael@0:  * also NULL GrContext creation will fail.
michael@0:  *
michael@0:  * The default interface is returned by GrGLDefaultInterface. This function's
michael@0:  * implementation is platform-specific. Several have been provided, along with
michael@0:  * an implementation that simply returns NULL.
michael@0:  *
michael@0:  * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a
michael@0:  * callback function that will be called prior to each GL function call. See
michael@0:  * comments in GrGLConfig.h
michael@0:  */
michael@0: 
michael@0: struct GrGLInterface;
michael@0: 
michael@0: const GrGLInterface* GrGLDefaultInterface();
michael@0: 
michael@0: /**
michael@0:  * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
michael@0:  * GLX on linux, AGL on Mac). The interface is only valid for the GL context
michael@0:  * that is current when the interface is created.
michael@0:  */
michael@0: const GrGLInterface* GrGLCreateNativeInterface();
michael@0: 
michael@0: #if SK_MESA
michael@0: /**
michael@0:  * Creates a GrGLInterface for an OSMesa context.
michael@0:  */
michael@0: const GrGLInterface* GrGLCreateMesaInterface();
michael@0: #endif
michael@0: 
michael@0: #if SK_ANGLE
michael@0: /**
michael@0:  * Creates a GrGLInterface for an ANGLE context.
michael@0:  */
michael@0: const GrGLInterface* GrGLCreateANGLEInterface();
michael@0: #endif
michael@0: 
michael@0: /**
michael@0:  * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
michael@0:  * CPU overhead.
michael@0:  */
michael@0: const SK_API GrGLInterface* GrGLCreateNullInterface();
michael@0: 
michael@0: /**
michael@0:  * Creates a debugging GrGLInterface that doesn't draw anything. Used for
michael@0:  * finding memory leaks and invalid memory accesses.
michael@0:  */
michael@0: const GrGLInterface* GrGLCreateDebugInterface();
michael@0: 
michael@0: #if GR_GL_PER_GL_FUNC_CALLBACK
michael@0: typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
michael@0: typedef intptr_t GrGLInterfaceCallbackData;
michael@0: #endif
michael@0: 
michael@0: /** Function that returns a new interface identical to "interface" but without support for
michael@0:     GL_NV_path_rendering. */
michael@0: const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);
michael@0: 
michael@0: /** Function that returns a new interface identical to "interface" but with support for
michael@0:     test version of GL_EXT_debug_marker. */
michael@0: const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
michael@0:                                                      GrGLInsertEventMarkerProc insertEventMarkerFn,
michael@0:                                                      GrGLPushGroupMarkerProc pushGroupMarkerFn,
michael@0:                                                      GrGLPopGroupMarkerProc popGroupMarkerFn);
michael@0: 
michael@0: /**
michael@0:  * GrContext uses the following interface to make all calls into OpenGL. When a
michael@0:  * GrContext is created it is given a GrGLInterface. The interface's function
michael@0:  * pointers must be valid for the OpenGL context associated with the GrContext.
michael@0:  * On some platforms, such as Windows, function pointers for OpenGL extensions
michael@0:  * may vary between OpenGL contexts. So the caller must be careful to use a
michael@0:  * GrGLInterface initialized for the correct context. All functions that should
michael@0:  * be available based on the OpenGL's version and extension string must be
michael@0:  * non-NULL or GrContext creation will fail. This can be tested with the
michael@0:  * validate() method when the OpenGL context has been made current.
michael@0:  */
michael@0: struct SK_API GrGLInterface : public SkRefCnt {
michael@0: private:
michael@0:     // simple wrapper class that exists only to initialize a pointer to NULL
michael@0:     template <typename FNPTR_TYPE> class GLPtr {
michael@0:     public:
michael@0:         GLPtr() : fPtr(NULL) {}
michael@0:         GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
michael@0:         operator FNPTR_TYPE() const { return fPtr; }
michael@0:     private:
michael@0:         FNPTR_TYPE fPtr;
michael@0:     };
michael@0: 
michael@0:     // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
michael@0:     // they're updated to use the Functions struct.
michael@0:     template <typename FNPTR_TYPE> class GLPtrAlias {
michael@0:     public:
michael@0:         GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
michael@0:         void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
michael@0:     private:
michael@0:         GLPtr<FNPTR_TYPE>* fBase;
michael@0:     };
michael@0: 
michael@0:     typedef SkRefCnt INHERITED;
michael@0: 
michael@0: public:
michael@0:     SK_DECLARE_INST_COUNT(GrGLInterface)
michael@0: 
michael@0:     GrGLInterface();
michael@0: 
michael@0:     static GrGLInterface* NewClone(const GrGLInterface*);
michael@0: 
michael@0:     // Validates that the GrGLInterface supports its advertised standard. This means the necessary
michael@0:     // function pointers have been initialized for both the GL version and any advertised
michael@0:     // extensions.
michael@0:     bool validate() const;
michael@0: 
michael@0:     // Indicates the type of GL implementation
michael@0:     union {
michael@0:         GrGLStandard fStandard;
michael@0:         GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
michael@0:     };
michael@0: 
michael@0:     GrGLExtensions fExtensions;
michael@0: 
michael@0:     bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }
michael@0: 
michael@0:     /**
michael@0:      * The function pointers are in a struct so that we can have a compiler generated assignment
michael@0:      * operator.
michael@0:      */
michael@0:     struct Functions {
michael@0:         GLPtr<GrGLActiveTextureProc> fActiveTexture;
michael@0:         GLPtr<GrGLAttachShaderProc> fAttachShader;
michael@0:         GLPtr<GrGLBeginQueryProc> fBeginQuery;
michael@0:         GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
michael@0:         GLPtr<GrGLBindBufferProc> fBindBuffer;
michael@0:         GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
michael@0:         GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
michael@0:         GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
michael@0:         GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
michael@0:         GLPtr<GrGLBindTextureProc> fBindTexture;
michael@0:         GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
michael@0:         GLPtr<GrGLBlendColorProc> fBlendColor;
michael@0:         GLPtr<GrGLBlendFuncProc> fBlendFunc;
michael@0:         GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
michael@0:         GLPtr<GrGLBufferDataProc> fBufferData;
michael@0:         GLPtr<GrGLBufferSubDataProc> fBufferSubData;
michael@0:         GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
michael@0:         GLPtr<GrGLClearProc> fClear;
michael@0:         GLPtr<GrGLClearColorProc> fClearColor;
michael@0:         GLPtr<GrGLClearStencilProc> fClearStencil;
michael@0:         GLPtr<GrGLColorMaskProc> fColorMask;
michael@0:         GLPtr<GrGLCompileShaderProc> fCompileShader;
michael@0:         GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
michael@0:         GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
michael@0:         GLPtr<GrGLCreateProgramProc> fCreateProgram;
michael@0:         GLPtr<GrGLCreateShaderProc> fCreateShader;
michael@0:         GLPtr<GrGLCullFaceProc> fCullFace;
michael@0:         GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
michael@0:         GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
michael@0:         GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
michael@0:         GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
michael@0:         GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
michael@0:         GLPtr<GrGLDeleteShaderProc> fDeleteShader;
michael@0:         GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
michael@0:         GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
michael@0:         GLPtr<GrGLDepthMaskProc> fDepthMask;
michael@0:         GLPtr<GrGLDisableProc> fDisable;
michael@0:         GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
michael@0:         GLPtr<GrGLDrawArraysProc> fDrawArrays;
michael@0:         GLPtr<GrGLDrawBufferProc> fDrawBuffer;
michael@0:         GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
michael@0:         GLPtr<GrGLDrawElementsProc> fDrawElements;
michael@0:         GLPtr<GrGLEnableProc> fEnable;
michael@0:         GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
michael@0:         GLPtr<GrGLEndQueryProc> fEndQuery;
michael@0:         GLPtr<GrGLFinishProc> fFinish;
michael@0:         GLPtr<GrGLFlushProc> fFlush;
michael@0:         GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
michael@0:         GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
michael@0:         GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
michael@0:         GLPtr<GrGLFrontFaceProc> fFrontFace;
michael@0:         GLPtr<GrGLGenBuffersProc> fGenBuffers;
michael@0:         GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
michael@0:         GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
michael@0:         GLPtr<GrGLGenQueriesProc> fGenQueries;
michael@0:         GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
michael@0:         GLPtr<GrGLGenTexturesProc> fGenTextures;
michael@0:         GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
michael@0:         GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
michael@0:         GLPtr<GrGLGetErrorProc> fGetError;
michael@0:         GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
michael@0:         GLPtr<GrGLGetIntegervProc> fGetIntegerv;
michael@0:         GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
michael@0:         GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
michael@0:         GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
michael@0:         GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
michael@0:         GLPtr<GrGLGetQueryivProc> fGetQueryiv;
michael@0:         GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
michael@0:         GLPtr<GrGLGetProgramivProc> fGetProgramiv;
michael@0:         GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
michael@0:         GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
michael@0:         GLPtr<GrGLGetShaderivProc> fGetShaderiv;
michael@0:         GLPtr<GrGLGetStringProc> fGetString;
michael@0:         GLPtr<GrGLGetStringiProc> fGetStringi;
michael@0:         GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
michael@0:         GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
michael@0:         GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
michael@0:         GLPtr<GrGLLineWidthProc> fLineWidth;
michael@0:         GLPtr<GrGLLinkProgramProc> fLinkProgram;
michael@0:         GLPtr<GrGLLoadIdentityProc> fLoadIdentity;
michael@0:         GLPtr<GrGLLoadMatrixfProc> fLoadMatrixf;
michael@0:         GLPtr<GrGLMapBufferProc> fMapBuffer;
michael@0:         GLPtr<GrGLMatrixModeProc> fMatrixMode;
michael@0:         GLPtr<GrGLPixelStoreiProc> fPixelStorei;
michael@0:         GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
michael@0:         GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
michael@0:         GLPtr<GrGLQueryCounterProc> fQueryCounter;
michael@0:         GLPtr<GrGLReadBufferProc> fReadBuffer;
michael@0:         GLPtr<GrGLReadPixelsProc> fReadPixels;
michael@0:         GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;
michael@0: 
michael@0:         //  On OpenGL ES there are multiple incompatible extensions that add support for MSAA
michael@0:         //  and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
michael@0:         //  older extensions for performance reasons or due to ES3 driver bugs. We want the function
michael@0:         //  that creates the GrGLInterface to provide all available functions and internally
michael@0:         //  we will select among them. They all have a method called glRenderbufferStorageMultisample*.
michael@0:         //  So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
michael@0:         //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
michael@0:         //  variations.
michael@0:         //
michael@0:         //  If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
michael@0:         //  assume the function pointers for the standard (or equivalent GL_ARB) version have
michael@0:         //  been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
michael@0:         //  functionality.
michael@0: 
michael@0:         //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
michael@0:         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
michael@0:         //  GL_APPLE_framebuffer_multisample
michael@0:         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;
michael@0: 
michael@0:         //  This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
michael@0:         //  the standard function in ES3+ or GL 3.0+.
michael@0:         GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
michael@0: 
michael@0:         // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
michael@0:         GLPtr<GrGLBindUniformLocation> fBindUniformLocation;
michael@0: 
michael@0:         GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
michael@0:         GLPtr<GrGLScissorProc> fScissor;
michael@0:         GLPtr<GrGLShaderSourceProc> fShaderSource;
michael@0:         GLPtr<GrGLStencilFuncProc> fStencilFunc;
michael@0:         GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
michael@0:         GLPtr<GrGLStencilMaskProc> fStencilMask;
michael@0:         GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
michael@0:         GLPtr<GrGLStencilOpProc> fStencilOp;
michael@0:         GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
michael@0:         GLPtr<GrGLTexGenfvProc> fTexGenfv;
michael@0:         GLPtr<GrGLTexGeniProc> fTexGeni;
michael@0:         GLPtr<GrGLTexImage2DProc> fTexImage2D;
michael@0:         GLPtr<GrGLTexParameteriProc> fTexParameteri;
michael@0:         GLPtr<GrGLTexParameterivProc> fTexParameteriv;
michael@0:         GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
michael@0:         GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
michael@0:         GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
michael@0:         GLPtr<GrGLUniform1fProc> fUniform1f;
michael@0:         GLPtr<GrGLUniform1iProc> fUniform1i;
michael@0:         GLPtr<GrGLUniform1fvProc> fUniform1fv;
michael@0:         GLPtr<GrGLUniform1ivProc> fUniform1iv;
michael@0:         GLPtr<GrGLUniform2fProc> fUniform2f;
michael@0:         GLPtr<GrGLUniform2iProc> fUniform2i;
michael@0:         GLPtr<GrGLUniform2fvProc> fUniform2fv;
michael@0:         GLPtr<GrGLUniform2ivProc> fUniform2iv;
michael@0:         GLPtr<GrGLUniform3fProc> fUniform3f;
michael@0:         GLPtr<GrGLUniform3iProc> fUniform3i;
michael@0:         GLPtr<GrGLUniform3fvProc> fUniform3fv;
michael@0:         GLPtr<GrGLUniform3ivProc> fUniform3iv;
michael@0:         GLPtr<GrGLUniform4fProc> fUniform4f;
michael@0:         GLPtr<GrGLUniform4iProc> fUniform4i;
michael@0:         GLPtr<GrGLUniform4fvProc> fUniform4fv;
michael@0:         GLPtr<GrGLUniform4ivProc> fUniform4iv;
michael@0:         GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
michael@0:         GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
michael@0:         GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
michael@0:         GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
michael@0:         GLPtr<GrGLUseProgramProc> fUseProgram;
michael@0:         GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
michael@0:         GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
michael@0:         GLPtr<GrGLViewportProc> fViewport;
michael@0: 
michael@0:         // Experimental: Functions for GL_NV_path_rendering. These will be
michael@0:         // alphabetized with the above functions once this is fully supported
michael@0:         // (and functions we are unlikely to use will possibly be omitted).
michael@0:         GLPtr<GrGLPathCommandsProc> fPathCommands;
michael@0:         GLPtr<GrGLPathCoordsProc> fPathCoords;
michael@0:         GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
michael@0:         GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
michael@0:         GLPtr<GrGLPathStringProc> fPathString;
michael@0:         GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
michael@0:         GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
michael@0:         GLPtr<GrGLWeightPathsProc> fWeightPaths;
michael@0:         GLPtr<GrGLCopyPathProc> fCopyPath;
michael@0:         GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
michael@0:         GLPtr<GrGLTransformPathProc> fTransformPath;
michael@0:         GLPtr<GrGLPathParameterivProc> fPathParameteriv;
michael@0:         GLPtr<GrGLPathParameteriProc> fPathParameteri;
michael@0:         GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
michael@0:         GLPtr<GrGLPathParameterfProc> fPathParameterf;
michael@0:         GLPtr<GrGLPathDashArrayProc> fPathDashArray;
michael@0:         GLPtr<GrGLGenPathsProc> fGenPaths;
michael@0:         GLPtr<GrGLDeletePathsProc> fDeletePaths;
michael@0:         GLPtr<GrGLIsPathProc> fIsPath;
michael@0:         GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
michael@0:         GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
michael@0:         GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
michael@0:         GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
michael@0:         GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
michael@0:         GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
michael@0:         GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
michael@0:         GLPtr<GrGLPathColorGenProc> fPathColorGen;
michael@0:         GLPtr<GrGLPathTexGenProc> fPathTexGen;
michael@0:         GLPtr<GrGLPathFogGenProc> fPathFogGen;
michael@0:         GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
michael@0:         GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
michael@0:         GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
michael@0:         GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
michael@0:         GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
michael@0:         GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
michael@0:         GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
michael@0:         GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
michael@0:         GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
michael@0:         GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
michael@0:         GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
michael@0:         GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
michael@0:         GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
michael@0:         GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
michael@0:         GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
michael@0:         GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
michael@0:         GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
michael@0:         GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
michael@0:         GLPtr<GrGLGetPathLengthProc> fGetPathLength;
michael@0:         GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
michael@0:     } fFunctions;
michael@0: 
michael@0:     // Per-GL func callback
michael@0: #if GR_GL_PER_GL_FUNC_CALLBACK
michael@0:     GrGLInterfaceCallbackProc fCallback;
michael@0:     GrGLInterfaceCallbackData fCallbackData;
michael@0: #endif
michael@0: };
michael@0: 
michael@0: #endif