The Tor Browser / annotate

gfx/skia/trunk/include/gpu/gl/GrGLInterface.h@129ffea94266 (annotated)

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

Sat, 03 Jan 2015 20:18:00 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Sat, 03 Jan 2015 20:18:00 +0100
branch
TOR_BUG_3246
changeset 7
129ffea94266
permissions
-rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

michael@0 1 /*
michael@0 2 * Copyright 2011 Google Inc.
michael@0 3 *
michael@0 4 * Use of this source code is governed by a BSD-style license that can be
michael@0 5 * found in the LICENSE file.
michael@0 6 */
michael@0 7
michael@0 8 #ifndef GrGLInterface_DEFINED
michael@0 9 #define GrGLInterface_DEFINED
michael@0 10
michael@0 11 #include "GrGLFunctions.h"
michael@0 12 #include "GrGLExtensions.h"
michael@0 13 #include "SkRefCnt.h"
michael@0 14
michael@0 15 ////////////////////////////////////////////////////////////////////////////////
michael@0 16
michael@0 17 /**
michael@0 18 * Rather than depend on platform-specific GL headers and libraries, we require
michael@0 19 * the client to provide a struct of GL function pointers. This struct can be
michael@0 20 * specified per-GrContext as a parameter to GrContext::Create. If NULL is
michael@0 21 * passed to Create then a "default" GL interface is created. If the default is
michael@0 22 * also NULL GrContext creation will fail.
michael@0 23 *
michael@0 24 * The default interface is returned by GrGLDefaultInterface. This function's
michael@0 25 * implementation is platform-specific. Several have been provided, along with
michael@0 26 * an implementation that simply returns NULL.
michael@0 27 *
michael@0 28 * By defining GR_GL_PER_GL_CALL_IFACE_CALLBACK to 1 the client can specify a
michael@0 29 * callback function that will be called prior to each GL function call. See
michael@0 30 * comments in GrGLConfig.h
michael@0 31 */
michael@0 32
michael@0 33 struct GrGLInterface;
michael@0 34
michael@0 35 const GrGLInterface* GrGLDefaultInterface();
michael@0 36
michael@0 37 /**
michael@0 38 * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
michael@0 39 * GLX on linux, AGL on Mac). The interface is only valid for the GL context
michael@0 40 * that is current when the interface is created.
michael@0 41 */
michael@0 42 const GrGLInterface* GrGLCreateNativeInterface();
michael@0 43
michael@0 44 #if SK_MESA
michael@0 45 /**
michael@0 46 * Creates a GrGLInterface for an OSMesa context.
michael@0 47 */
michael@0 48 const GrGLInterface* GrGLCreateMesaInterface();
michael@0 49 #endif
michael@0 50
michael@0 51 #if SK_ANGLE
michael@0 52 /**
michael@0 53 * Creates a GrGLInterface for an ANGLE context.
michael@0 54 */
michael@0 55 const GrGLInterface* GrGLCreateANGLEInterface();
michael@0 56 #endif
michael@0 57
michael@0 58 /**
michael@0 59 * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
michael@0 60 * CPU overhead.
michael@0 61 */
michael@0 62 const SK_API GrGLInterface* GrGLCreateNullInterface();
michael@0 63
michael@0 64 /**
michael@0 65 * Creates a debugging GrGLInterface that doesn't draw anything. Used for
michael@0 66 * finding memory leaks and invalid memory accesses.
michael@0 67 */
michael@0 68 const GrGLInterface* GrGLCreateDebugInterface();
michael@0 69
michael@0 70 #if GR_GL_PER_GL_FUNC_CALLBACK
michael@0 71 typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
michael@0 72 typedef intptr_t GrGLInterfaceCallbackData;
michael@0 73 #endif
michael@0 74
michael@0 75 /** Function that returns a new interface identical to "interface" but without support for
michael@0 76 GL_NV_path_rendering. */
michael@0 77 const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);
michael@0 78
michael@0 79 /** Function that returns a new interface identical to "interface" but with support for
michael@0 80 test version of GL_EXT_debug_marker. */
michael@0 81 const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
michael@0 82 GrGLInsertEventMarkerProc insertEventMarkerFn,
michael@0 83 GrGLPushGroupMarkerProc pushGroupMarkerFn,
michael@0 84 GrGLPopGroupMarkerProc popGroupMarkerFn);
michael@0 85
michael@0 86 /**
michael@0 87 * GrContext uses the following interface to make all calls into OpenGL. When a
michael@0 88 * GrContext is created it is given a GrGLInterface. The interface's function
michael@0 89 * pointers must be valid for the OpenGL context associated with the GrContext.
michael@0 90 * On some platforms, such as Windows, function pointers for OpenGL extensions
michael@0 91 * may vary between OpenGL contexts. So the caller must be careful to use a
michael@0 92 * GrGLInterface initialized for the correct context. All functions that should
michael@0 93 * be available based on the OpenGL's version and extension string must be
michael@0 94 * non-NULL or GrContext creation will fail. This can be tested with the
michael@0 95 * validate() method when the OpenGL context has been made current.
michael@0 96 */
michael@0 97 struct SK_API GrGLInterface : public SkRefCnt {
michael@0 98 private:
michael@0 99 // simple wrapper class that exists only to initialize a pointer to NULL
michael@0 100 template <typename FNPTR_TYPE> class GLPtr {
michael@0 101 public:
michael@0 102 GLPtr() : fPtr(NULL) {}
michael@0 103 GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
michael@0 104 operator FNPTR_TYPE() const { return fPtr; }
michael@0 105 private:
michael@0 106 FNPTR_TYPE fPtr;
michael@0 107 };
michael@0 108
michael@0 109 // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
michael@0 110 // they're updated to use the Functions struct.
michael@0 111 template <typename FNPTR_TYPE> class GLPtrAlias {
michael@0 112 public:
michael@0 113 GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
michael@0 114 void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
michael@0 115 private:
michael@0 116 GLPtr<FNPTR_TYPE>* fBase;
michael@0 117 };
michael@0 118
michael@0 119 typedef SkRefCnt INHERITED;
michael@0 120
michael@0 121 public:
michael@0 122 SK_DECLARE_INST_COUNT(GrGLInterface)
michael@0 123
michael@0 124 GrGLInterface();
michael@0 125
michael@0 126 static GrGLInterface* NewClone(const GrGLInterface*);
michael@0 127
michael@0 128 // Validates that the GrGLInterface supports its advertised standard. This means the necessary
michael@0 129 // function pointers have been initialized for both the GL version and any advertised
michael@0 130 // extensions.
michael@0 131 bool validate() const;
michael@0 132
michael@0 133 // Indicates the type of GL implementation
michael@0 134 union {
michael@0 135 GrGLStandard fStandard;
michael@0 136 GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
michael@0 137 };
michael@0 138
michael@0 139 GrGLExtensions fExtensions;
michael@0 140
michael@0 141 bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }
michael@0 142
michael@0 143 /**
michael@0 144 * The function pointers are in a struct so that we can have a compiler generated assignment
michael@0 145 * operator.
michael@0 146 */
michael@0 147 struct Functions {
michael@0 148 GLPtr<GrGLActiveTextureProc> fActiveTexture;
michael@0 149 GLPtr<GrGLAttachShaderProc> fAttachShader;
michael@0 150 GLPtr<GrGLBeginQueryProc> fBeginQuery;
michael@0 151 GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
michael@0 152 GLPtr<GrGLBindBufferProc> fBindBuffer;
michael@0 153 GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
michael@0 154 GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
michael@0 155 GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
michael@0 156 GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
michael@0 157 GLPtr<GrGLBindTextureProc> fBindTexture;
michael@0 158 GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
michael@0 159 GLPtr<GrGLBlendColorProc> fBlendColor;
michael@0 160 GLPtr<GrGLBlendFuncProc> fBlendFunc;
michael@0 161 GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
michael@0 162 GLPtr<GrGLBufferDataProc> fBufferData;
michael@0 163 GLPtr<GrGLBufferSubDataProc> fBufferSubData;
michael@0 164 GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
michael@0 165 GLPtr<GrGLClearProc> fClear;
michael@0 166 GLPtr<GrGLClearColorProc> fClearColor;
michael@0 167 GLPtr<GrGLClearStencilProc> fClearStencil;
michael@0 168 GLPtr<GrGLColorMaskProc> fColorMask;
michael@0 169 GLPtr<GrGLCompileShaderProc> fCompileShader;
michael@0 170 GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
michael@0 171 GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
michael@0 172 GLPtr<GrGLCreateProgramProc> fCreateProgram;
michael@0 173 GLPtr<GrGLCreateShaderProc> fCreateShader;
michael@0 174 GLPtr<GrGLCullFaceProc> fCullFace;
michael@0 175 GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
michael@0 176 GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
michael@0 177 GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
michael@0 178 GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
michael@0 179 GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
michael@0 180 GLPtr<GrGLDeleteShaderProc> fDeleteShader;
michael@0 181 GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
michael@0 182 GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
michael@0 183 GLPtr<GrGLDepthMaskProc> fDepthMask;
michael@0 184 GLPtr<GrGLDisableProc> fDisable;
michael@0 185 GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
michael@0 186 GLPtr<GrGLDrawArraysProc> fDrawArrays;
michael@0 187 GLPtr<GrGLDrawBufferProc> fDrawBuffer;
michael@0 188 GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
michael@0 189 GLPtr<GrGLDrawElementsProc> fDrawElements;
michael@0 190 GLPtr<GrGLEnableProc> fEnable;
michael@0 191 GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
michael@0 192 GLPtr<GrGLEndQueryProc> fEndQuery;
michael@0 193 GLPtr<GrGLFinishProc> fFinish;
michael@0 194 GLPtr<GrGLFlushProc> fFlush;
michael@0 195 GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
michael@0 196 GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
michael@0 197 GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
michael@0 198 GLPtr<GrGLFrontFaceProc> fFrontFace;
michael@0 199 GLPtr<GrGLGenBuffersProc> fGenBuffers;
michael@0 200 GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
michael@0 201 GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
michael@0 202 GLPtr<GrGLGenQueriesProc> fGenQueries;
michael@0 203 GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
michael@0 204 GLPtr<GrGLGenTexturesProc> fGenTextures;
michael@0 205 GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
michael@0 206 GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
michael@0 207 GLPtr<GrGLGetErrorProc> fGetError;
michael@0 208 GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
michael@0 209 GLPtr<GrGLGetIntegervProc> fGetIntegerv;
michael@0 210 GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
michael@0 211 GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
michael@0 212 GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
michael@0 213 GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
michael@0 214 GLPtr<GrGLGetQueryivProc> fGetQueryiv;
michael@0 215 GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
michael@0 216 GLPtr<GrGLGetProgramivProc> fGetProgramiv;
michael@0 217 GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
michael@0 218 GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
michael@0 219 GLPtr<GrGLGetShaderivProc> fGetShaderiv;
michael@0 220 GLPtr<GrGLGetStringProc> fGetString;
michael@0 221 GLPtr<GrGLGetStringiProc> fGetStringi;
michael@0 222 GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
michael@0 223 GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
michael@0 224 GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
michael@0 225 GLPtr<GrGLLineWidthProc> fLineWidth;
michael@0 226 GLPtr<GrGLLinkProgramProc> fLinkProgram;
michael@0 227 GLPtr<GrGLLoadIdentityProc> fLoadIdentity;
michael@0 228 GLPtr<GrGLLoadMatrixfProc> fLoadMatrixf;
michael@0 229 GLPtr<GrGLMapBufferProc> fMapBuffer;
michael@0 230 GLPtr<GrGLMatrixModeProc> fMatrixMode;
michael@0 231 GLPtr<GrGLPixelStoreiProc> fPixelStorei;
michael@0 232 GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
michael@0 233 GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
michael@0 234 GLPtr<GrGLQueryCounterProc> fQueryCounter;
michael@0 235 GLPtr<GrGLReadBufferProc> fReadBuffer;
michael@0 236 GLPtr<GrGLReadPixelsProc> fReadPixels;
michael@0 237 GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;
michael@0 238
michael@0 239 // On OpenGL ES there are multiple incompatible extensions that add support for MSAA
michael@0 240 // and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
michael@0 241 // older extensions for performance reasons or due to ES3 driver bugs. We want the function
michael@0 242 // that creates the GrGLInterface to provide all available functions and internally
michael@0 243 // we will select among them. They all have a method called glRenderbufferStorageMultisample*.
michael@0 244 // So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
michael@0 245 // GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
michael@0 246 // variations.
michael@0 247 //
michael@0 248 // If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
michael@0 249 // assume the function pointers for the standard (or equivalent GL_ARB) version have
michael@0 250 // been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
michael@0 251 // functionality.
michael@0 252
michael@0 253 // GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
michael@0 254 GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
michael@0 255 // GL_APPLE_framebuffer_multisample
michael@0 256 GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;
michael@0 257
michael@0 258 // This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
michael@0 259 // the standard function in ES3+ or GL 3.0+.
michael@0 260 GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
michael@0 261
michael@0 262 // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
michael@0 263 GLPtr<GrGLBindUniformLocation> fBindUniformLocation;
michael@0 264
michael@0 265 GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
michael@0 266 GLPtr<GrGLScissorProc> fScissor;
michael@0 267 GLPtr<GrGLShaderSourceProc> fShaderSource;
michael@0 268 GLPtr<GrGLStencilFuncProc> fStencilFunc;
michael@0 269 GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
michael@0 270 GLPtr<GrGLStencilMaskProc> fStencilMask;
michael@0 271 GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
michael@0 272 GLPtr<GrGLStencilOpProc> fStencilOp;
michael@0 273 GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
michael@0 274 GLPtr<GrGLTexGenfvProc> fTexGenfv;
michael@0 275 GLPtr<GrGLTexGeniProc> fTexGeni;
michael@0 276 GLPtr<GrGLTexImage2DProc> fTexImage2D;
michael@0 277 GLPtr<GrGLTexParameteriProc> fTexParameteri;
michael@0 278 GLPtr<GrGLTexParameterivProc> fTexParameteriv;
michael@0 279 GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
michael@0 280 GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
michael@0 281 GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
michael@0 282 GLPtr<GrGLUniform1fProc> fUniform1f;
michael@0 283 GLPtr<GrGLUniform1iProc> fUniform1i;
michael@0 284 GLPtr<GrGLUniform1fvProc> fUniform1fv;
michael@0 285 GLPtr<GrGLUniform1ivProc> fUniform1iv;
michael@0 286 GLPtr<GrGLUniform2fProc> fUniform2f;
michael@0 287 GLPtr<GrGLUniform2iProc> fUniform2i;
michael@0 288 GLPtr<GrGLUniform2fvProc> fUniform2fv;
michael@0 289 GLPtr<GrGLUniform2ivProc> fUniform2iv;
michael@0 290 GLPtr<GrGLUniform3fProc> fUniform3f;
michael@0 291 GLPtr<GrGLUniform3iProc> fUniform3i;
michael@0 292 GLPtr<GrGLUniform3fvProc> fUniform3fv;
michael@0 293 GLPtr<GrGLUniform3ivProc> fUniform3iv;
michael@0 294 GLPtr<GrGLUniform4fProc> fUniform4f;
michael@0 295 GLPtr<GrGLUniform4iProc> fUniform4i;
michael@0 296 GLPtr<GrGLUniform4fvProc> fUniform4fv;
michael@0 297 GLPtr<GrGLUniform4ivProc> fUniform4iv;
michael@0 298 GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
michael@0 299 GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
michael@0 300 GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
michael@0 301 GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
michael@0 302 GLPtr<GrGLUseProgramProc> fUseProgram;
michael@0 303 GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
michael@0 304 GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
michael@0 305 GLPtr<GrGLViewportProc> fViewport;
michael@0 306
michael@0 307 // Experimental: Functions for GL_NV_path_rendering. These will be
michael@0 308 // alphabetized with the above functions once this is fully supported
michael@0 309 // (and functions we are unlikely to use will possibly be omitted).
michael@0 310 GLPtr<GrGLPathCommandsProc> fPathCommands;
michael@0 311 GLPtr<GrGLPathCoordsProc> fPathCoords;
michael@0 312 GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
michael@0 313 GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
michael@0 314 GLPtr<GrGLPathStringProc> fPathString;
michael@0 315 GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
michael@0 316 GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
michael@0 317 GLPtr<GrGLWeightPathsProc> fWeightPaths;
michael@0 318 GLPtr<GrGLCopyPathProc> fCopyPath;
michael@0 319 GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
michael@0 320 GLPtr<GrGLTransformPathProc> fTransformPath;
michael@0 321 GLPtr<GrGLPathParameterivProc> fPathParameteriv;
michael@0 322 GLPtr<GrGLPathParameteriProc> fPathParameteri;
michael@0 323 GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
michael@0 324 GLPtr<GrGLPathParameterfProc> fPathParameterf;
michael@0 325 GLPtr<GrGLPathDashArrayProc> fPathDashArray;
michael@0 326 GLPtr<GrGLGenPathsProc> fGenPaths;
michael@0 327 GLPtr<GrGLDeletePathsProc> fDeletePaths;
michael@0 328 GLPtr<GrGLIsPathProc> fIsPath;
michael@0 329 GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
michael@0 330 GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
michael@0 331 GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
michael@0 332 GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
michael@0 333 GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
michael@0 334 GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
michael@0 335 GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
michael@0 336 GLPtr<GrGLPathColorGenProc> fPathColorGen;
michael@0 337 GLPtr<GrGLPathTexGenProc> fPathTexGen;
michael@0 338 GLPtr<GrGLPathFogGenProc> fPathFogGen;
michael@0 339 GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
michael@0 340 GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
michael@0 341 GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
michael@0 342 GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
michael@0 343 GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
michael@0 344 GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
michael@0 345 GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
michael@0 346 GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
michael@0 347 GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
michael@0 348 GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
michael@0 349 GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
michael@0 350 GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
michael@0 351 GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
michael@0 352 GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
michael@0 353 GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
michael@0 354 GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
michael@0 355 GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
michael@0 356 GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
michael@0 357 GLPtr<GrGLGetPathLengthProc> fGetPathLength;
michael@0 358 GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
michael@0 359 } fFunctions;
michael@0 360
michael@0 361 // Per-GL func callback
michael@0 362 #if GR_GL_PER_GL_FUNC_CALLBACK
michael@0 363 GrGLInterfaceCallbackProc fCallback;
michael@0 364 GrGLInterfaceCallbackData fCallbackData;
michael@0 365 #endif
michael@0 366 };
michael@0 367
michael@0 368 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial