1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/gfx/skia/trunk/include/gpu/gl/GrGLInterface.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,368 @@
1.4 +/*
1.5 + * Copyright 2011 Google Inc.
1.6 + *
1.7 + * Use of this source code is governed by a BSD-style license that can be
1.8 + * found in the LICENSE file.
1.9 + */
1.10 +
1.11 +#ifndef GrGLInterface_DEFINED
1.12 +#define GrGLInterface_DEFINED
1.13 +
1.14 +#include "GrGLFunctions.h"
1.15 +#include "GrGLExtensions.h"
1.16 +#include "SkRefCnt.h"
1.17 +
1.18 +////////////////////////////////////////////////////////////////////////////////
1.19 +
1.20 +/**
1.21 + * Rather than depend on platform-specific GL headers and libraries, we require
1.22 + * the client to provide a struct of GL function pointers. This struct can be
1.23 + * specified per-GrContext as a parameter to GrContext::Create. If NULL is
1.24 + * passed to Create then a "default" GL interface is created. If the default is
1.25 + * also NULL GrContext creation will fail.
1.26 + *
1.27 + * The default interface is returned by GrGLDefaultInterface. This function's
1.28 + * implementation is platform-specific. Several have been provided, along with
1.29 + * an implementation that simply returns NULL.
1.30 + *
1.31 + * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a
1.32 + * callback function that will be called prior to each GL function call. See
1.33 + * comments in GrGLConfig.h
1.34 + */
1.35 +
1.36 +struct GrGLInterface;
1.37 +
1.38 +const GrGLInterface* GrGLDefaultInterface();
1.39 +
1.40 +/**
1.41 + * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
1.42 + * GLX on linux, AGL on Mac). The interface is only valid for the GL context
1.43 + * that is current when the interface is created.
1.44 + */
1.45 +const GrGLInterface* GrGLCreateNativeInterface();
1.46 +
1.47 +#if SK_MESA
1.48 +/**
1.49 + * Creates a GrGLInterface for an OSMesa context.
1.50 + */
1.51 +const GrGLInterface* GrGLCreateMesaInterface();
1.52 +#endif
1.53 +
1.54 +#if SK_ANGLE
1.55 +/**
1.56 + * Creates a GrGLInterface for an ANGLE context.
1.57 + */
1.58 +const GrGLInterface* GrGLCreateANGLEInterface();
1.59 +#endif
1.60 +
1.61 +/**
1.62 + * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
1.63 + * CPU overhead.
1.64 + */
1.65 +const SK_API GrGLInterface* GrGLCreateNullInterface();
1.66 +
1.67 +/**
1.68 + * Creates a debugging GrGLInterface that doesn't draw anything. Used for
1.69 + * finding memory leaks and invalid memory accesses.
1.70 + */
1.71 +const GrGLInterface* GrGLCreateDebugInterface();
1.72 +
1.73 +#if GR_GL_PER_GL_FUNC_CALLBACK
1.74 +typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
1.75 +typedef intptr_t GrGLInterfaceCallbackData;
1.76 +#endif
1.77 +
1.78 +/** Function that returns a new interface identical to "interface" but without support for
1.79 + GL_NV_path_rendering. */
1.80 +const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);
1.81 +
1.82 +/** Function that returns a new interface identical to "interface" but with support for
1.83 + test version of GL_EXT_debug_marker. */
1.84 +const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
1.85 + GrGLInsertEventMarkerProc insertEventMarkerFn,
1.86 + GrGLPushGroupMarkerProc pushGroupMarkerFn,
1.87 + GrGLPopGroupMarkerProc popGroupMarkerFn);
1.88 +
1.89 +/**
1.90 + * GrContext uses the following interface to make all calls into OpenGL. When a
1.91 + * GrContext is created it is given a GrGLInterface. The interface's function
1.92 + * pointers must be valid for the OpenGL context associated with the GrContext.
1.93 + * On some platforms, such as Windows, function pointers for OpenGL extensions
1.94 + * may vary between OpenGL contexts. So the caller must be careful to use a
1.95 + * GrGLInterface initialized for the correct context. All functions that should
1.96 + * be available based on the OpenGL's version and extension string must be
1.97 + * non-NULL or GrContext creation will fail. This can be tested with the
1.98 + * validate() method when the OpenGL context has been made current.
1.99 + */
1.100 +struct SK_API GrGLInterface : public SkRefCnt {
1.101 +private:
1.102 + // simple wrapper class that exists only to initialize a pointer to NULL
1.103 + template <typename FNPTR_TYPE> class GLPtr {
1.104 + public:
1.105 + GLPtr() : fPtr(NULL) {}
1.106 + GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
1.107 + operator FNPTR_TYPE() const { return fPtr; }
1.108 + private:
1.109 + FNPTR_TYPE fPtr;
1.110 + };
1.111 +
1.112 + // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
1.113 + // they're updated to use the Functions struct.
1.114 + template <typename FNPTR_TYPE> class GLPtrAlias {
1.115 + public:
1.116 + GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
1.117 + void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
1.118 + private:
1.119 + GLPtr<FNPTR_TYPE>* fBase;
1.120 + };
1.121 +
1.122 + typedef SkRefCnt INHERITED;
1.123 +
1.124 +public:
1.125 + SK_DECLARE_INST_COUNT(GrGLInterface)
1.126 +
1.127 + GrGLInterface();
1.128 +
1.129 + static GrGLInterface* NewClone(const GrGLInterface*);
1.130 +
1.131 + // Validates that the GrGLInterface supports its advertised standard. This means the necessary
1.132 + // function pointers have been initialized for both the GL version and any advertised
1.133 + // extensions.
1.134 + bool validate() const;
1.135 +
1.136 + // Indicates the type of GL implementation
1.137 + union {
1.138 + GrGLStandard fStandard;
1.139 + GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
1.140 + };
1.141 +
1.142 + GrGLExtensions fExtensions;
1.143 +
1.144 + bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }
1.145 +
1.146 + /**
1.147 + * The function pointers are in a struct so that we can have a compiler generated assignment
1.148 + * operator.
1.149 + */
1.150 + struct Functions {
1.151 + GLPtr<GrGLActiveTextureProc> fActiveTexture;
1.152 + GLPtr<GrGLAttachShaderProc> fAttachShader;
1.153 + GLPtr<GrGLBeginQueryProc> fBeginQuery;
1.154 + GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
1.155 + GLPtr<GrGLBindBufferProc> fBindBuffer;
1.156 + GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
1.157 + GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
1.158 + GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
1.159 + GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
1.160 + GLPtr<GrGLBindTextureProc> fBindTexture;
1.161 + GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
1.162 + GLPtr<GrGLBlendColorProc> fBlendColor;
1.163 + GLPtr<GrGLBlendFuncProc> fBlendFunc;
1.164 + GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
1.165 + GLPtr<GrGLBufferDataProc> fBufferData;
1.166 + GLPtr<GrGLBufferSubDataProc> fBufferSubData;
1.167 + GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
1.168 + GLPtr<GrGLClearProc> fClear;
1.169 + GLPtr<GrGLClearColorProc> fClearColor;
1.170 + GLPtr<GrGLClearStencilProc> fClearStencil;
1.171 + GLPtr<GrGLColorMaskProc> fColorMask;
1.172 + GLPtr<GrGLCompileShaderProc> fCompileShader;
1.173 + GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
1.174 + GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
1.175 + GLPtr<GrGLCreateProgramProc> fCreateProgram;
1.176 + GLPtr<GrGLCreateShaderProc> fCreateShader;
1.177 + GLPtr<GrGLCullFaceProc> fCullFace;
1.178 + GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
1.179 + GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
1.180 + GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
1.181 + GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
1.182 + GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
1.183 + GLPtr<GrGLDeleteShaderProc> fDeleteShader;
1.184 + GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
1.185 + GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
1.186 + GLPtr<GrGLDepthMaskProc> fDepthMask;
1.187 + GLPtr<GrGLDisableProc> fDisable;
1.188 + GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
1.189 + GLPtr<GrGLDrawArraysProc> fDrawArrays;
1.190 + GLPtr<GrGLDrawBufferProc> fDrawBuffer;
1.191 + GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
1.192 + GLPtr<GrGLDrawElementsProc> fDrawElements;
1.193 + GLPtr<GrGLEnableProc> fEnable;
1.194 + GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
1.195 + GLPtr<GrGLEndQueryProc> fEndQuery;
1.196 + GLPtr<GrGLFinishProc> fFinish;
1.197 + GLPtr<GrGLFlushProc> fFlush;
1.198 + GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
1.199 + GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
1.200 + GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
1.201 + GLPtr<GrGLFrontFaceProc> fFrontFace;
1.202 + GLPtr<GrGLGenBuffersProc> fGenBuffers;
1.203 + GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
1.204 + GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
1.205 + GLPtr<GrGLGenQueriesProc> fGenQueries;
1.206 + GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
1.207 + GLPtr<GrGLGenTexturesProc> fGenTextures;
1.208 + GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
1.209 + GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
1.210 + GLPtr<GrGLGetErrorProc> fGetError;
1.211 + GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
1.212 + GLPtr<GrGLGetIntegervProc> fGetIntegerv;
1.213 + GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
1.214 + GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
1.215 + GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
1.216 + GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
1.217 + GLPtr<GrGLGetQueryivProc> fGetQueryiv;
1.218 + GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
1.219 + GLPtr<GrGLGetProgramivProc> fGetProgramiv;
1.220 + GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
1.221 + GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
1.222 + GLPtr<GrGLGetShaderivProc> fGetShaderiv;
1.223 + GLPtr<GrGLGetStringProc> fGetString;
1.224 + GLPtr<GrGLGetStringiProc> fGetStringi;
1.225 + GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
1.226 + GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
1.227 + GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
1.228 + GLPtr<GrGLLineWidthProc> fLineWidth;
1.229 + GLPtr<GrGLLinkProgramProc> fLinkProgram;
1.230 + GLPtr<GrGLLoadIdentityProc> fLoadIdentity;
1.231 + GLPtr<GrGLLoadMatrixfProc> fLoadMatrixf;
1.232 + GLPtr<GrGLMapBufferProc> fMapBuffer;
1.233 + GLPtr<GrGLMatrixModeProc> fMatrixMode;
1.234 + GLPtr<GrGLPixelStoreiProc> fPixelStorei;
1.235 + GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
1.236 + GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
1.237 + GLPtr<GrGLQueryCounterProc> fQueryCounter;
1.238 + GLPtr<GrGLReadBufferProc> fReadBuffer;
1.239 + GLPtr<GrGLReadPixelsProc> fReadPixels;
1.240 + GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;
1.241 +
1.242 + // On OpenGL ES there are multiple incompatible extensions that add support for MSAA
1.243 + // and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
1.244 + // older extensions for performance reasons or due to ES3 driver bugs. We want the function
1.245 + // that creates the GrGLInterface to provide all available functions and internally
1.246 + // we will select among them. They all have a method called glRenderbufferStorageMultisample*.
1.247 + // So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
1.248 + // GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
1.249 + // variations.
1.250 + //
1.251 + // If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
1.252 + // assume the function pointers for the standard (or equivalent GL_ARB) version have
1.253 + // been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
1.254 + // functionality.
1.255 +
1.256 + // GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
1.257 + GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
1.258 + // GL_APPLE_framebuffer_multisample
1.259 + GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;
1.260 +
1.261 + // This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
1.262 + // the standard function in ES3+ or GL 3.0+.
1.263 + GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
1.264 +
1.265 + // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
1.266 + GLPtr<GrGLBindUniformLocation> fBindUniformLocation;
1.267 +
1.268 + GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
1.269 + GLPtr<GrGLScissorProc> fScissor;
1.270 + GLPtr<GrGLShaderSourceProc> fShaderSource;
1.271 + GLPtr<GrGLStencilFuncProc> fStencilFunc;
1.272 + GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
1.273 + GLPtr<GrGLStencilMaskProc> fStencilMask;
1.274 + GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
1.275 + GLPtr<GrGLStencilOpProc> fStencilOp;
1.276 + GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
1.277 + GLPtr<GrGLTexGenfvProc> fTexGenfv;
1.278 + GLPtr<GrGLTexGeniProc> fTexGeni;
1.279 + GLPtr<GrGLTexImage2DProc> fTexImage2D;
1.280 + GLPtr<GrGLTexParameteriProc> fTexParameteri;
1.281 + GLPtr<GrGLTexParameterivProc> fTexParameteriv;
1.282 + GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
1.283 + GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
1.284 + GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
1.285 + GLPtr<GrGLUniform1fProc> fUniform1f;
1.286 + GLPtr<GrGLUniform1iProc> fUniform1i;
1.287 + GLPtr<GrGLUniform1fvProc> fUniform1fv;
1.288 + GLPtr<GrGLUniform1ivProc> fUniform1iv;
1.289 + GLPtr<GrGLUniform2fProc> fUniform2f;
1.290 + GLPtr<GrGLUniform2iProc> fUniform2i;
1.291 + GLPtr<GrGLUniform2fvProc> fUniform2fv;
1.292 + GLPtr<GrGLUniform2ivProc> fUniform2iv;
1.293 + GLPtr<GrGLUniform3fProc> fUniform3f;
1.294 + GLPtr<GrGLUniform3iProc> fUniform3i;
1.295 + GLPtr<GrGLUniform3fvProc> fUniform3fv;
1.296 + GLPtr<GrGLUniform3ivProc> fUniform3iv;
1.297 + GLPtr<GrGLUniform4fProc> fUniform4f;
1.298 + GLPtr<GrGLUniform4iProc> fUniform4i;
1.299 + GLPtr<GrGLUniform4fvProc> fUniform4fv;
1.300 + GLPtr<GrGLUniform4ivProc> fUniform4iv;
1.301 + GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
1.302 + GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
1.303 + GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
1.304 + GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
1.305 + GLPtr<GrGLUseProgramProc> fUseProgram;
1.306 + GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
1.307 + GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
1.308 + GLPtr<GrGLViewportProc> fViewport;
1.309 +
1.310 + // Experimental: Functions for GL_NV_path_rendering. These will be
1.311 + // alphabetized with the above functions once this is fully supported
1.312 + // (and functions we are unlikely to use will possibly be omitted).
1.313 + GLPtr<GrGLPathCommandsProc> fPathCommands;
1.314 + GLPtr<GrGLPathCoordsProc> fPathCoords;
1.315 + GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
1.316 + GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
1.317 + GLPtr<GrGLPathStringProc> fPathString;
1.318 + GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
1.319 + GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
1.320 + GLPtr<GrGLWeightPathsProc> fWeightPaths;
1.321 + GLPtr<GrGLCopyPathProc> fCopyPath;
1.322 + GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
1.323 + GLPtr<GrGLTransformPathProc> fTransformPath;
1.324 + GLPtr<GrGLPathParameterivProc> fPathParameteriv;
1.325 + GLPtr<GrGLPathParameteriProc> fPathParameteri;
1.326 + GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
1.327 + GLPtr<GrGLPathParameterfProc> fPathParameterf;
1.328 + GLPtr<GrGLPathDashArrayProc> fPathDashArray;
1.329 + GLPtr<GrGLGenPathsProc> fGenPaths;
1.330 + GLPtr<GrGLDeletePathsProc> fDeletePaths;
1.331 + GLPtr<GrGLIsPathProc> fIsPath;
1.332 + GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
1.333 + GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
1.334 + GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
1.335 + GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
1.336 + GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
1.337 + GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
1.338 + GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
1.339 + GLPtr<GrGLPathColorGenProc> fPathColorGen;
1.340 + GLPtr<GrGLPathTexGenProc> fPathTexGen;
1.341 + GLPtr<GrGLPathFogGenProc> fPathFogGen;
1.342 + GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
1.343 + GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
1.344 + GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
1.345 + GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
1.346 + GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
1.347 + GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
1.348 + GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
1.349 + GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
1.350 + GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
1.351 + GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
1.352 + GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
1.353 + GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
1.354 + GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
1.355 + GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
1.356 + GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
1.357 + GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
1.358 + GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
1.359 + GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
1.360 + GLPtr<GrGLGetPathLengthProc> fGetPathLength;
1.361 + GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
1.362 + } fFunctions;
1.363 +
1.364 + // Per-GL func callback
1.365 +#if GR_GL_PER_GL_FUNC_CALLBACK
1.366 + GrGLInterfaceCallbackProc fCallback;
1.367 + GrGLInterfaceCallbackData fCallbackData;
1.368 +#endif
1.369 +};
1.370 +
1.371 +#endif
