The Tor Browser / file comparison
comparison: gfx/skia/trunk/include/gpu/gl/GrGLInterface.h
gfx/skia/trunk/include/gpu/gl/GrGLInterface.h
- changeset 1
- ca08bd8f51b2
equal
deleted
inserted
replaced
| -1:000000000000 | 0:757d3f3bd66a |
|---|---|
| 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 */ | |
| 7 | |
| 8 #ifndef GrGLInterface_DEFINED | |
| 9 #define GrGLInterface_DEFINED | |
| 10 | |
| 11 #include "GrGLFunctions.h" | |
| 12 #include "GrGLExtensions.h" | |
| 13 #include "SkRefCnt.h" | |
| 14 | |
| 15 //////////////////////////////////////////////////////////////////////////////// | |
| 16 | |
| 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 */ | |
| 32 | |
| 33 struct GrGLInterface; | |
| 34 | |
| 35 const GrGLInterface* GrGLDefaultInterface(); | |
| 36 | |
| 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(); | |
| 43 | |
| 44 #if SK_MESA | |
| 45 /** | |
| 46 * Creates a GrGLInterface for an OSMesa context. | |
| 47 */ | |
| 48 const GrGLInterface* GrGLCreateMesaInterface(); | |
| 49 #endif | |
| 50 | |
| 51 #if SK_ANGLE | |
| 52 /** | |
| 53 * Creates a GrGLInterface for an ANGLE context. | |
| 54 */ | |
| 55 const GrGLInterface* GrGLCreateANGLEInterface(); | |
| 56 #endif | |
| 57 | |
| 58 /** | |
| 59 * Creates a null GrGLInterface that doesn't draw anything. Used for measuring | |
| 60 * CPU overhead. | |
| 61 */ | |
| 62 const SK_API GrGLInterface* GrGLCreateNullInterface(); | |
| 63 | |
| 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(); | |
| 69 | |
| 70 #if GR_GL_PER_GL_FUNC_CALLBACK | |
| 71 typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*); | |
| 72 typedef intptr_t GrGLInterfaceCallbackData; | |
| 73 #endif | |
| 74 | |
| 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*); | |
| 78 | |
| 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); | |
| 85 | |
| 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 }; | |
| 108 | |
| 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 }; | |
| 118 | |
| 119 typedef SkRefCnt INHERITED; | |
| 120 | |
| 121 public: | |
| 122 SK_DECLARE_INST_COUNT(GrGLInterface) | |
| 123 | |
| 124 GrGLInterface(); | |
| 125 | |
| 126 static GrGLInterface* NewClone(const GrGLInterface*); | |
| 127 | |
| 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; | |
| 132 | |
| 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 }; | |
| 138 | |
| 139 GrGLExtensions fExtensions; | |
| 140 | |
| 141 bool hasExtension(const char ext[]) const { return fExtensions.has(ext); } | |
| 142 | |
| 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; | |
| 238 | |
| 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. | |
| 252 | |
| 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; | |
| 257 | |
| 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; | |
| 261 | |
| 262 // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension. | |
| 263 GLPtr<GrGLBindUniformLocation> fBindUniformLocation; | |
| 264 | |
| 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; | |
| 306 | |
| 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; | |
| 360 | |
| 361 // Per-GL func callback | |
| 362 #if GR_GL_PER_GL_FUNC_CALLBACK | |
| 363 GrGLInterfaceCallbackProc fCallback; | |
| 364 GrGLInterfaceCallbackData fCallbackData; | |
| 365 #endif | |
| 366 }; | |
| 367 | |
| 368 #endif |
