GrGLInterface.h revision 27a048700778d4cebfc23301d1780649791b0e03 
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
33typedef void(*GrGLFuncPtr)();
34
35struct GrGLInterface;
36
37const GrGLInterface* GrGLDefaultInterface();
38
39/**
40 * Creates a GrGLInterface for a "native" GL context (e.g. WGL on windows,
41 * GLX on linux, AGL on Mac). The interface is only valid for the GL context
42 * that is current when the interface is created.
43 */
44SK_API const GrGLInterface* GrGLCreateNativeInterface();
45
46#if SK_MESA
47/**
48 * Creates a GrGLInterface for an OSMesa context.
49 */
50SK_API const GrGLInterface* GrGLCreateMesaInterface();
51#endif
52
53#if SK_ANGLE
54/**
55 * Creates a GrGLInterface for an ANGLE context.
56 */
57SK_API const GrGLInterface* GrGLCreateANGLEInterface();
58#endif
59
60#if SK_COMMAND_BUFFER
61/**
62 * Creates a GrGLInterface for a Command Buffer context.
63 */
64SK_API const GrGLInterface* GrGLCreateCommandBufferInterface();
65#endif
66
67/**
68 * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
69 * CPU overhead.
70 */
71const SK_API GrGLInterface* GrGLCreateNullInterface();
72
73/**
74 * Creates a debugging GrGLInterface that doesn't draw anything. Used for
75 * finding memory leaks and invalid memory accesses.
76 */
77const GrGLInterface* GrGLCreateDebugInterface();
78
79#if GR_GL_PER_GL_FUNC_CALLBACK
80typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
81typedef intptr_t GrGLInterfaceCallbackData;
82#endif
83
84/** Function that returns a new interface identical to "interface" but without support for
85    GL_NV_path_rendering. */
86const GrGLInterface* GrGLInterfaceRemoveNVPR(const GrGLInterface*);
87
88/** Function that returns a new interface identical to "interface" but with support for
89    test version of GL_EXT_debug_marker. */
90const GrGLInterface* GrGLInterfaceAddTestDebugMarker(const GrGLInterface*,
91                                                     GrGLInsertEventMarkerProc insertEventMarkerFn,
92                                                     GrGLPushGroupMarkerProc pushGroupMarkerFn,
93                                                     GrGLPopGroupMarkerProc popGroupMarkerFn);
94
95/**
96 * GrContext uses the following interface to make all calls into OpenGL. When a
97 * GrContext is created it is given a GrGLInterface. The interface's function
98 * pointers must be valid for the OpenGL context associated with the GrContext.
99 * On some platforms, such as Windows, function pointers for OpenGL extensions
100 * may vary between OpenGL contexts. So the caller must be careful to use a
101 * GrGLInterface initialized for the correct context. All functions that should
102 * be available based on the OpenGL's version and extension string must be
103 * non-NULL or GrContext creation will fail. This can be tested with the
104 * validate() method when the OpenGL context has been made current.
105 */
106struct SK_API GrGLInterface : public SkRefCnt {
107private:
108    // simple wrapper class that exists only to initialize a pointer to NULL
109    template <typename FNPTR_TYPE> class GLPtr {
110    public:
111        GLPtr() : fPtr(NULL) {}
112        GLPtr operator=(FNPTR_TYPE ptr) { fPtr = ptr; return *this; }
113        operator FNPTR_TYPE() const { return fPtr; }
114    private:
115        FNPTR_TYPE fPtr;
116    };
117
118    // This is a temporary workaround to keep Chromium's GrGLInterface factories compiling until
119    // they're updated to use the Functions struct.
120    template <typename FNPTR_TYPE> class GLPtrAlias {
121    public:
122        GLPtrAlias(GLPtr<FNPTR_TYPE>* base) : fBase(base) {}
123        void operator=(FNPTR_TYPE ptr) { *fBase = ptr; }
124    private:
125        GLPtr<FNPTR_TYPE>* fBase;
126    };
127
128    typedef SkRefCnt INHERITED;
129
130public:
131    GrGLInterface();
132
133    static GrGLInterface* NewClone(const GrGLInterface*);
134
135    // Validates that the GrGLInterface supports its advertised standard. This means the necessary
136    // function pointers have been initialized for both the GL version and any advertised
137    // extensions.
138    bool validate() const;
139
140    // Indicates the type of GL implementation
141    union {
142        GrGLStandard fStandard;
143        GrGLStandard fBindingsExported; // Legacy name, will be remove when Chromium is updated.
144    };
145
146    GrGLExtensions fExtensions;
147
148    bool hasExtension(const char ext[]) const { return fExtensions.has(ext); }
149
150    /**
151     * The function pointers are in a struct so that we can have a compiler generated assignment
152     * operator.
153     */
154    struct Functions {
155        GLPtr<GrGLActiveTextureProc> fActiveTexture;
156        GLPtr<GrGLAttachShaderProc> fAttachShader;
157        GLPtr<GrGLBeginQueryProc> fBeginQuery;
158        GLPtr<GrGLBindAttribLocationProc> fBindAttribLocation;
159        GLPtr<GrGLBindBufferProc> fBindBuffer;
160        GLPtr<GrGLBindFragDataLocationProc> fBindFragDataLocation;
161        GLPtr<GrGLBindFragDataLocationIndexedProc> fBindFragDataLocationIndexed;
162        GLPtr<GrGLBindFramebufferProc> fBindFramebuffer;
163        GLPtr<GrGLBindRenderbufferProc> fBindRenderbuffer;
164        GLPtr<GrGLBindTextureProc> fBindTexture;
165        GLPtr<GrGLBindVertexArrayProc> fBindVertexArray;
166        GLPtr<GrGLBlendBarrierProc> fBlendBarrier;
167        GLPtr<GrGLBlendColorProc> fBlendColor;
168        GLPtr<GrGLBlendEquationProc> fBlendEquation;
169        GLPtr<GrGLBlendFuncProc> fBlendFunc;
170        GLPtr<GrGLBlitFramebufferProc> fBlitFramebuffer;
171        GLPtr<GrGLBufferDataProc> fBufferData;
172        GLPtr<GrGLBufferSubDataProc> fBufferSubData;
173        GLPtr<GrGLCheckFramebufferStatusProc> fCheckFramebufferStatus;
174        GLPtr<GrGLClearProc> fClear;
175        GLPtr<GrGLClearColorProc> fClearColor;
176        GLPtr<GrGLClearStencilProc> fClearStencil;
177        GLPtr<GrGLColorMaskProc> fColorMask;
178        GLPtr<GrGLCompileShaderProc> fCompileShader;
179        GLPtr<GrGLCompressedTexImage2DProc> fCompressedTexImage2D;
180        GLPtr<GrGLCompressedTexSubImage2DProc> fCompressedTexSubImage2D;
181        GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
182        GLPtr<GrGLCreateProgramProc> fCreateProgram;
183        GLPtr<GrGLCreateShaderProc> fCreateShader;
184        GLPtr<GrGLCullFaceProc> fCullFace;
185        GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
186        GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
187        GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
188        GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
189        GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
190        GLPtr<GrGLDeleteShaderProc> fDeleteShader;
191        GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
192        GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
193        GLPtr<GrGLDepthMaskProc> fDepthMask;
194        GLPtr<GrGLDisableProc> fDisable;
195        GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
196        GLPtr<GrGLDrawArraysProc> fDrawArrays;
197        GLPtr<GrGLDrawBufferProc> fDrawBuffer;
198        GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
199        GLPtr<GrGLDrawElementsProc> fDrawElements;
200        GLPtr<GrGLEnableProc> fEnable;
201        GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
202        GLPtr<GrGLEndQueryProc> fEndQuery;
203        GLPtr<GrGLFinishProc> fFinish;
204        GLPtr<GrGLFlushProc> fFlush;
205        GLPtr<GrGLFlushMappedBufferRangeProc> fFlushMappedBufferRange;
206        GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
207        GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
208        GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
209        GLPtr<GrGLFrontFaceProc> fFrontFace;
210        GLPtr<GrGLGenBuffersProc> fGenBuffers;
211        GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
212        GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
213        GLPtr<GrGLGenQueriesProc> fGenQueries;
214        GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
215        GLPtr<GrGLGenTexturesProc> fGenTextures;
216        GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
217        GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
218        GLPtr<GrGLGetErrorProc> fGetError;
219        GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
220        GLPtr<GrGLGetIntegervProc> fGetIntegerv;
221        GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
222        GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
223        GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
224        GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
225        GLPtr<GrGLGetQueryivProc> fGetQueryiv;
226        GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
227        GLPtr<GrGLGetProgramivProc> fGetProgramiv;
228        GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
229        GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
230        GLPtr<GrGLGetShaderivProc> fGetShaderiv;
231        GLPtr<GrGLGetShaderPrecisionFormatProc> fGetShaderPrecisionFormat;
232        GLPtr<GrGLGetStringProc> fGetString;
233        GLPtr<GrGLGetStringiProc> fGetStringi;
234        GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
235        GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
236        GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
237        GLPtr<GrGLInvalidateBufferDataProc> fInvalidateBufferData;
238        GLPtr<GrGLInvalidateBufferSubDataProc> fInvalidateBufferSubData;
239        GLPtr<GrGLInvalidateFramebufferProc> fInvalidateFramebuffer;
240        GLPtr<GrGLInvalidateSubFramebufferProc> fInvalidateSubFramebuffer;
241        GLPtr<GrGLInvalidateTexImageProc> fInvalidateTexImage;
242        GLPtr<GrGLInvalidateTexSubImageProc> fInvalidateTexSubImage;
243        GLPtr<GrGLIsTextureProc> fIsTexture;
244        GLPtr<GrGLLineWidthProc> fLineWidth;
245        GLPtr<GrGLLinkProgramProc> fLinkProgram;
246        GLPtr<GrGLMapBufferProc> fMapBuffer;
247        GLPtr<GrGLMapBufferRangeProc> fMapBufferRange;
248        GLPtr<GrGLMapBufferSubDataProc> fMapBufferSubData;
249        GLPtr<GrGLMapTexSubImage2DProc> fMapTexSubImage2D;
250        GLPtr<GrGLPixelStoreiProc> fPixelStorei;
251        GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
252        GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
253        GLPtr<GrGLQueryCounterProc> fQueryCounter;
254        GLPtr<GrGLRasterSamplesProc> fRasterSamples;
255        GLPtr<GrGLReadBufferProc> fReadBuffer;
256        GLPtr<GrGLReadPixelsProc> fReadPixels;
257        GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;
258
259        //  On OpenGL ES there are multiple incompatible extensions that add support for MSAA
260        //  and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
261        //  older extensions for performance reasons or due to ES3 driver bugs. We want the function
262        //  that creates the GrGLInterface to provide all available functions and internally
263        //  we will select among them. They all have a method called glRenderbufferStorageMultisample*.
264        //  So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
265        //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
266        //  variations.
267        //
268        //  If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
269        //  assume the function pointers for the standard (or equivalent GL_ARB) version have
270        //  been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
271        //  functionality.
272
273        //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
274        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
275        //  GL_APPLE_framebuffer_multisample
276        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;
277
278        //  This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
279        //  the standard function in ES3+ or GL 3.0+.
280        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
281
282        // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
283        GLPtr<GrGLBindUniformLocationProc> fBindUniformLocation;
284
285        GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
286        GLPtr<GrGLScissorProc> fScissor;
287        GLPtr<GrGLShaderSourceProc> fShaderSource;
288        GLPtr<GrGLStencilFuncProc> fStencilFunc;
289        GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
290        GLPtr<GrGLStencilMaskProc> fStencilMask;
291        GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
292        GLPtr<GrGLStencilOpProc> fStencilOp;
293        GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
294        GLPtr<GrGLTexImage2DProc> fTexImage2D;
295        GLPtr<GrGLTexParameteriProc> fTexParameteri;
296        GLPtr<GrGLTexParameterivProc> fTexParameteriv;
297        GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
298        GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
299        GLPtr<GrGLTextureBarrierProc> fTextureBarrier;
300        GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
301        GLPtr<GrGLUniform1fProc> fUniform1f;
302        GLPtr<GrGLUniform1iProc> fUniform1i;
303        GLPtr<GrGLUniform1fvProc> fUniform1fv;
304        GLPtr<GrGLUniform1ivProc> fUniform1iv;
305        GLPtr<GrGLUniform2fProc> fUniform2f;
306        GLPtr<GrGLUniform2iProc> fUniform2i;
307        GLPtr<GrGLUniform2fvProc> fUniform2fv;
308        GLPtr<GrGLUniform2ivProc> fUniform2iv;
309        GLPtr<GrGLUniform3fProc> fUniform3f;
310        GLPtr<GrGLUniform3iProc> fUniform3i;
311        GLPtr<GrGLUniform3fvProc> fUniform3fv;
312        GLPtr<GrGLUniform3ivProc> fUniform3iv;
313        GLPtr<GrGLUniform4fProc> fUniform4f;
314        GLPtr<GrGLUniform4iProc> fUniform4i;
315        GLPtr<GrGLUniform4fvProc> fUniform4fv;
316        GLPtr<GrGLUniform4ivProc> fUniform4iv;
317        GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
318        GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
319        GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
320        GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
321        GLPtr<GrGLUnmapBufferSubDataProc> fUnmapBufferSubData;
322        GLPtr<GrGLUnmapTexSubImage2DProc> fUnmapTexSubImage2D;
323        GLPtr<GrGLUseProgramProc> fUseProgram;
324        GLPtr<GrGLVertexAttrib1fProc> fVertexAttrib1f;
325        GLPtr<GrGLVertexAttrib2fvProc> fVertexAttrib2fv;
326        GLPtr<GrGLVertexAttrib3fvProc> fVertexAttrib3fv;
327        GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
328        GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
329        GLPtr<GrGLViewportProc> fViewport;
330
331        /* GL_NV_path_rendering */
332        GLPtr<GrGLMatrixLoadfProc> fMatrixLoadf;
333        GLPtr<GrGLMatrixLoadIdentityProc> fMatrixLoadIdentity;
334        GLPtr<GrGLGetProgramResourceLocationProc> fGetProgramResourceLocation;
335        GLPtr<GrGLPathCommandsProc> fPathCommands;
336        GLPtr<GrGLPathParameteriProc> fPathParameteri;
337        GLPtr<GrGLPathParameterfProc> fPathParameterf;
338        GLPtr<GrGLGenPathsProc> fGenPaths;
339        GLPtr<GrGLDeletePathsProc> fDeletePaths;
340        GLPtr<GrGLIsPathProc> fIsPath;
341        GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
342        GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
343        GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
344        GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
345        GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
346        GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
347        GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
348        GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
349        GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
350        // NV_path_rendering v1.2
351        GLPtr<GrGLStencilThenCoverFillPathProc> fStencilThenCoverFillPath;
352        GLPtr<GrGLStencilThenCoverStrokePathProc> fStencilThenCoverStrokePath;
353        GLPtr<GrGLStencilThenCoverFillPathInstancedProc> fStencilThenCoverFillPathInstanced;
354        GLPtr<GrGLStencilThenCoverStrokePathInstancedProc> fStencilThenCoverStrokePathInstanced;
355        // NV_path_rendering v1.3
356        GLPtr<GrGLProgramPathFragmentInputGenProc> fProgramPathFragmentInputGen;
357        // CHROMIUM_path_rendering
358        GLPtr<GrGLBindFragmentInputLocationProc> fBindFragmentInputLocation;
359
360        /* NV_framebuffer_mixed_samples */
361        GLPtr<GrGLCoverageModulationProc> fCoverageModulation;
362
363        /* ARB_draw_instanced */
364        GLPtr<GrGLDrawArraysInstancedProc> fDrawArraysInstanced;
365        GLPtr<GrGLDrawElementsInstancedProc> fDrawElementsInstanced;
366
367        /* ARB_instanced_arrays */
368        GLPtr<GrGLVertexAttribDivisorProc> fVertexAttribDivisor;
369
370        /* NV_bindless_texture */
371        // We use the NVIDIA verson for now because it does not require dynamically uniform handles.
372        // We may switch the the ARB version and/or omit methods in the future.
373        GLPtr<GrGLGetTextureHandleProc> fGetTextureHandle;
374        GLPtr<GrGLGetTextureSamplerHandleProc> fGetTextureSamplerHandle;
375        GLPtr<GrGLMakeTextureHandleResidentProc> fMakeTextureHandleResident;
376        GLPtr<GrGLMakeTextureHandleNonResidentProc> fMakeTextureHandleNonResident;
377        GLPtr<GrGLGetImageHandleProc> fGetImageHandle;
378        GLPtr<GrGLMakeImageHandleResidentProc> fMakeImageHandleResident;
379        GLPtr<GrGLMakeImageHandleNonResidentProc> fMakeImageHandleNonResident;
380        GLPtr<GrGLIsTextureHandleResidentProc> fIsTextureHandleResident;
381        GLPtr<GrGLIsImageHandleResidentProc> fIsImageHandleResident;
382        GLPtr<GrGLUniformHandleui64Proc> fUniformHandleui64;
383        GLPtr<GrGLUniformHandleui64vProc> fUniformHandleui64v;
384        GLPtr<GrGLProgramUniformHandleui64Proc> fProgramUniformHandleui64;
385        GLPtr<GrGLProgramUniformHandleui64vProc> fProgramUniformHandleui64v;
386
387        /* EXT_direct_state_access */
388        // We use the EXT verson because it is more expansive and interacts with more extensions
389        // than the ARB or core (4.5) versions. We may switch and/or omit methods in the future.
390        GLPtr<GrGLTextureParameteriProc> fTextureParameteri;
391        GLPtr<GrGLTextureParameterivProc> fTextureParameteriv;
392        GLPtr<GrGLTextureParameterfProc> fTextureParameterf;
393        GLPtr<GrGLTextureParameterfvProc> fTextureParameterfv;
394        GLPtr<GrGLTextureImage1DProc> fTextureImage1D;
395        GLPtr<GrGLTextureImage2DProc> fTextureImage2D;
396        GLPtr<GrGLTextureSubImage1DProc> fTextureSubImage1D;
397        GLPtr<GrGLTextureSubImage2DProc> fTextureSubImage2D;
398        GLPtr<GrGLCopyTextureImage1DProc> fCopyTextureImage1D;
399        GLPtr<GrGLCopyTextureImage2DProc> fCopyTextureImage2D;
400        GLPtr<GrGLCopyTextureSubImage1DProc> fCopyTextureSubImage1D;
401        GLPtr<GrGLCopyTextureSubImage2DProc> fCopyTextureSubImage2D;
402        GLPtr<GrGLGetTextureImageProc> fGetTextureImage;
403        GLPtr<GrGLGetTextureParameterfvProc> fGetTextureParameterfv;
404        GLPtr<GrGLGetTextureParameterivProc> fGetTextureParameteriv;
405        GLPtr<GrGLGetTextureLevelParameterfvProc> fGetTextureLevelParameterfv;
406        GLPtr<GrGLGetTextureLevelParameterivProc> fGetTextureLevelParameteriv;
407        // OpenGL 1.2
408        GLPtr<GrGLTextureImage3DProc> fTextureImage3D;
409        GLPtr<GrGLTextureSubImage3DProc> fTextureSubImage3D;
410        GLPtr<GrGLCopyTextureSubImage3DProc> fCopyTextureSubImage3D;
411        GLPtr<GrGLCompressedTextureImage3DProc> fCompressedTextureImage3D;
412        GLPtr<GrGLCompressedTextureImage2DProc> fCompressedTextureImage2D;
413        GLPtr<GrGLCompressedTextureImage1DProc> fCompressedTextureImage1D;
414        GLPtr<GrGLCompressedTextureSubImage3DProc> fCompressedTextureSubImage3D;
415        GLPtr<GrGLCompressedTextureSubImage2DProc> fCompressedTextureSubImage2D;
416        GLPtr<GrGLCompressedTextureSubImage1DProc> fCompressedTextureSubImage1D;
417        GLPtr<GrGLGetCompressedTextureImageProc> fGetCompressedTextureImage;
418        // OpenGL 1.5
419        GLPtr<GrGLNamedBufferDataProc> fNamedBufferData;
420        GLPtr<GrGLNamedBufferSubDataProc> fNamedBufferSubData;
421        GLPtr<GrGLMapNamedBufferProc> fMapNamedBuffer;
422        GLPtr<GrGLUnmapNamedBufferProc> fUnmapNamedBuffer;
423        GLPtr<GrGLGetNamedBufferParameterivProc> fGetNamedBufferParameteriv;
424        GLPtr<GrGLGetNamedBufferPointervProc> fGetNamedBufferPointerv;
425        GLPtr<GrGLGetNamedBufferSubDataProc> fGetNamedBufferSubData;
426        // OpenGL 2.0
427        GLPtr<GrGLProgramUniform1fProc> fProgramUniform1f;
428        GLPtr<GrGLProgramUniform2fProc> fProgramUniform2f;
429        GLPtr<GrGLProgramUniform3fProc> fProgramUniform3f;
430        GLPtr<GrGLProgramUniform4fProc> fProgramUniform4f;
431        GLPtr<GrGLProgramUniform1iProc> fProgramUniform1i;
432        GLPtr<GrGLProgramUniform2iProc> fProgramUniform2i;
433        GLPtr<GrGLProgramUniform3iProc> fProgramUniform3i;
434        GLPtr<GrGLProgramUniform4iProc> fProgramUniform4i;
435        GLPtr<GrGLProgramUniform1fvProc> fProgramUniform1fv;
436        GLPtr<GrGLProgramUniform2fvProc> fProgramUniform2fv;
437        GLPtr<GrGLProgramUniform3fvProc> fProgramUniform3fv;
438        GLPtr<GrGLProgramUniform4fvProc> fProgramUniform4fv;
439        GLPtr<GrGLProgramUniform1ivProc> fProgramUniform1iv;
440        GLPtr<GrGLProgramUniform2ivProc> fProgramUniform2iv;
441        GLPtr<GrGLProgramUniform3ivProc> fProgramUniform3iv;
442        GLPtr<GrGLProgramUniform4ivProc> fProgramUniform4iv;
443        GLPtr<GrGLProgramUniformMatrix2fvProc> fProgramUniformMatrix2fv;
444        GLPtr<GrGLProgramUniformMatrix3fvProc> fProgramUniformMatrix3fv;
445        GLPtr<GrGLProgramUniformMatrix4fvProc> fProgramUniformMatrix4fv;
446        // OpenGL 2.1
447        GLPtr<GrGLProgramUniformMatrix2x3fvProc> fProgramUniformMatrix2x3fv;
448        GLPtr<GrGLProgramUniformMatrix3x2fvProc> fProgramUniformMatrix3x2fv;
449        GLPtr<GrGLProgramUniformMatrix2x4fvProc> fProgramUniformMatrix2x4fv;
450        GLPtr<GrGLProgramUniformMatrix4x2fvProc> fProgramUniformMatrix4x2fv;
451        GLPtr<GrGLProgramUniformMatrix3x4fvProc> fProgramUniformMatrix3x4fv;
452        GLPtr<GrGLProgramUniformMatrix4x3fvProc> fProgramUniformMatrix4x3fv;
453        // OpenGL 3.0
454        GLPtr<GrGLNamedRenderbufferStorageProc> fNamedRenderbufferStorage;
455        GLPtr<GrGLGetNamedRenderbufferParameterivProc> fGetNamedRenderbufferParameteriv;
456        GLPtr<GrGLNamedRenderbufferStorageMultisampleProc> fNamedRenderbufferStorageMultisample;
457        GLPtr<GrGLCheckNamedFramebufferStatusProc> fCheckNamedFramebufferStatus;
458        GLPtr<GrGLNamedFramebufferTexture1DProc> fNamedFramebufferTexture1D;
459        GLPtr<GrGLNamedFramebufferTexture2DProc> fNamedFramebufferTexture2D;
460        GLPtr<GrGLNamedFramebufferTexture3DProc> fNamedFramebufferTexture3D;
461        GLPtr<GrGLNamedFramebufferRenderbufferProc> fNamedFramebufferRenderbuffer;
462        GLPtr<GrGLGetNamedFramebufferAttachmentParameterivProc> fGetNamedFramebufferAttachmentParameteriv;
463        GLPtr<GrGLGenerateTextureMipmapProc> fGenerateTextureMipmap;
464        GLPtr<GrGLFramebufferDrawBufferProc> fFramebufferDrawBuffer;
465        GLPtr<GrGLFramebufferDrawBuffersProc> fFramebufferDrawBuffers;
466        GLPtr<GrGLFramebufferReadBufferProc> fFramebufferReadBuffer;
467        GLPtr<GrGLGetFramebufferParameterivProc> fGetFramebufferParameteriv;
468        GLPtr<GrGLNamedCopyBufferSubDataProc> fNamedCopyBufferSubData;
469        GLPtr<GrGLVertexArrayVertexOffsetProc> fVertexArrayVertexOffset;
470        GLPtr<GrGLVertexArrayColorOffsetProc> fVertexArrayColorOffset;
471        GLPtr<GrGLVertexArrayEdgeFlagOffsetProc> fVertexArrayEdgeFlagOffset;
472        GLPtr<GrGLVertexArrayIndexOffsetProc> fVertexArrayIndexOffset;
473        GLPtr<GrGLVertexArrayNormalOffsetProc> fVertexArrayNormalOffset;
474        GLPtr<GrGLVertexArrayTexCoordOffsetProc> fVertexArrayTexCoordOffset;
475        GLPtr<GrGLVertexArrayMultiTexCoordOffsetProc> fVertexArrayMultiTexCoordOffset;
476        GLPtr<GrGLVertexArrayFogCoordOffsetProc> fVertexArrayFogCoordOffset;
477        GLPtr<GrGLVertexArraySecondaryColorOffsetProc> fVertexArraySecondaryColorOffset;
478        GLPtr<GrGLVertexArrayVertexAttribOffsetProc> fVertexArrayVertexAttribOffset;
479        GLPtr<GrGLVertexArrayVertexAttribIOffsetProc> fVertexArrayVertexAttribIOffset;
480        GLPtr<GrGLEnableVertexArrayProc> fEnableVertexArray;
481        GLPtr<GrGLDisableVertexArrayProc> fDisableVertexArray;
482        GLPtr<GrGLEnableVertexArrayAttribProc> fEnableVertexArrayAttrib;
483        GLPtr<GrGLDisableVertexArrayAttribProc> fDisableVertexArrayAttrib;
484        GLPtr<GrGLGetVertexArrayIntegervProc> fGetVertexArrayIntegerv;
485        GLPtr<GrGLGetVertexArrayPointervProc> fGetVertexArrayPointerv;
486        GLPtr<GrGLGetVertexArrayIntegeri_vProc> fGetVertexArrayIntegeri_v;
487        GLPtr<GrGLGetVertexArrayPointeri_vProc> fGetVertexArrayPointeri_v;
488        GLPtr<GrGLMapNamedBufferRangeProc> fMapNamedBufferRange;
489        GLPtr<GrGLFlushMappedNamedBufferRangeProc> fFlushMappedNamedBufferRange;
490
491        /* KHR_debug */
492        GLPtr<GrGLDebugMessageControlProc> fDebugMessageControl;
493        GLPtr<GrGLDebugMessageInsertProc> fDebugMessageInsert;
494        GLPtr<GrGLDebugMessageCallbackProc> fDebugMessageCallback;
495        GLPtr<GrGLGetDebugMessageLogProc> fGetDebugMessageLog;
496        GLPtr<GrGLPushDebugGroupProc> fPushDebugGroup;
497        GLPtr<GrGLPopDebugGroupProc> fPopDebugGroup;
498        GLPtr<GrGLObjectLabelProc> fObjectLabel;
499
500        /* EGL functions */
501        GLPtr<GrEGLCreateImageProc> fEGLCreateImage;
502        GLPtr<GrEGLDestroyImageProc> fEGLDestroyImage;
503    } fFunctions;
504
505    // Per-GL func callback
506#if GR_GL_PER_GL_FUNC_CALLBACK
507    GrGLInterfaceCallbackProc fCallback;
508    GrGLInterfaceCallbackData fCallbackData;
509#endif
510
511    // This exists for internal testing.
512    virtual void abandon() const {}
513};
514
515#endif
516