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
33struct GrGLInterface;
34
35const 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 */
42const GrGLInterface* GrGLCreateNativeInterface();
43
44#if SK_MESA
45/**
46 * Creates a GrGLInterface for an OSMesa context.
47 */
48const GrGLInterface* GrGLCreateMesaInterface();
49#endif
50
51#if SK_ANGLE
52/**
53 * Creates a GrGLInterface for an ANGLE context.
54 */
55const GrGLInterface* GrGLCreateANGLEInterface();
56#endif
57
58/**
59 * Creates a null GrGLInterface that doesn't draw anything. Used for measuring
60 * CPU overhead.
61 */
62const 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 */
68const GrGLInterface* GrGLCreateDebugInterface();
69
70#if GR_GL_PER_GL_FUNC_CALLBACK
71typedef void (*GrGLInterfaceCallbackProc)(const GrGLInterface*);
72typedef 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. */
77const 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. */
81const 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 */
97struct SK_API GrGLInterface : public SkRefCnt {
98private:
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
121public:
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<GrGLCompressedTexSubImage2DProc> fCompressedTexSubImage2D;
172        GLPtr<GrGLCopyTexSubImage2DProc> fCopyTexSubImage2D;
173        GLPtr<GrGLCreateProgramProc> fCreateProgram;
174        GLPtr<GrGLCreateShaderProc> fCreateShader;
175        GLPtr<GrGLCullFaceProc> fCullFace;
176        GLPtr<GrGLDeleteBuffersProc> fDeleteBuffers;
177        GLPtr<GrGLDeleteFramebuffersProc> fDeleteFramebuffers;
178        GLPtr<GrGLDeleteProgramProc> fDeleteProgram;
179        GLPtr<GrGLDeleteQueriesProc> fDeleteQueries;
180        GLPtr<GrGLDeleteRenderbuffersProc> fDeleteRenderbuffers;
181        GLPtr<GrGLDeleteShaderProc> fDeleteShader;
182        GLPtr<GrGLDeleteTexturesProc> fDeleteTextures;
183        GLPtr<GrGLDeleteVertexArraysProc> fDeleteVertexArrays;
184        GLPtr<GrGLDepthMaskProc> fDepthMask;
185        GLPtr<GrGLDisableProc> fDisable;
186        GLPtr<GrGLDisableVertexAttribArrayProc> fDisableVertexAttribArray;
187        GLPtr<GrGLDrawArraysProc> fDrawArrays;
188        GLPtr<GrGLDrawBufferProc> fDrawBuffer;
189        GLPtr<GrGLDrawBuffersProc> fDrawBuffers;
190        GLPtr<GrGLDrawElementsProc> fDrawElements;
191        GLPtr<GrGLEnableProc> fEnable;
192        GLPtr<GrGLEnableVertexAttribArrayProc> fEnableVertexAttribArray;
193        GLPtr<GrGLEndQueryProc> fEndQuery;
194        GLPtr<GrGLFinishProc> fFinish;
195        GLPtr<GrGLFlushProc> fFlush;
196        GLPtr<GrGLFlushMappedBufferRangeProc> fFlushMappedBufferRange;
197        GLPtr<GrGLFramebufferRenderbufferProc> fFramebufferRenderbuffer;
198        GLPtr<GrGLFramebufferTexture2DProc> fFramebufferTexture2D;
199        GLPtr<GrGLFramebufferTexture2DMultisampleProc> fFramebufferTexture2DMultisample;
200        GLPtr<GrGLFrontFaceProc> fFrontFace;
201        GLPtr<GrGLGenBuffersProc> fGenBuffers;
202        GLPtr<GrGLGenFramebuffersProc> fGenFramebuffers;
203        GLPtr<GrGLGenerateMipmapProc> fGenerateMipmap;
204        GLPtr<GrGLGenQueriesProc> fGenQueries;
205        GLPtr<GrGLGenRenderbuffersProc> fGenRenderbuffers;
206        GLPtr<GrGLGenTexturesProc> fGenTextures;
207        GLPtr<GrGLGenVertexArraysProc> fGenVertexArrays;
208        GLPtr<GrGLGetBufferParameterivProc> fGetBufferParameteriv;
209        GLPtr<GrGLGetErrorProc> fGetError;
210        GLPtr<GrGLGetFramebufferAttachmentParameterivProc> fGetFramebufferAttachmentParameteriv;
211        GLPtr<GrGLGetIntegervProc> fGetIntegerv;
212        GLPtr<GrGLGetQueryObjecti64vProc> fGetQueryObjecti64v;
213        GLPtr<GrGLGetQueryObjectivProc> fGetQueryObjectiv;
214        GLPtr<GrGLGetQueryObjectui64vProc> fGetQueryObjectui64v;
215        GLPtr<GrGLGetQueryObjectuivProc> fGetQueryObjectuiv;
216        GLPtr<GrGLGetQueryivProc> fGetQueryiv;
217        GLPtr<GrGLGetProgramInfoLogProc> fGetProgramInfoLog;
218        GLPtr<GrGLGetProgramivProc> fGetProgramiv;
219        GLPtr<GrGLGetRenderbufferParameterivProc> fGetRenderbufferParameteriv;
220        GLPtr<GrGLGetShaderInfoLogProc> fGetShaderInfoLog;
221        GLPtr<GrGLGetShaderivProc> fGetShaderiv;
222        GLPtr<GrGLGetStringProc> fGetString;
223        GLPtr<GrGLGetStringiProc> fGetStringi;
224        GLPtr<GrGLGetTexLevelParameterivProc> fGetTexLevelParameteriv;
225        GLPtr<GrGLGetUniformLocationProc> fGetUniformLocation;
226        GLPtr<GrGLInsertEventMarkerProc> fInsertEventMarker;
227        GLPtr<GrGLInvalidateBufferDataProc> fInvalidateBufferData;
228        GLPtr<GrGLInvalidateBufferSubDataProc> fInvalidateBufferSubData;
229        GLPtr<GrGLInvalidateFramebufferProc> fInvalidateFramebuffer;
230        GLPtr<GrGLInvalidateSubFramebufferProc> fInvalidateSubFramebuffer;
231        GLPtr<GrGLInvalidateTexImageProc> fInvalidateTexImage;
232        GLPtr<GrGLInvalidateTexSubImageProc> fInvalidateTexSubImage;
233        GLPtr<GrGLLineWidthProc> fLineWidth;
234        GLPtr<GrGLLinkProgramProc> fLinkProgram;
235        GLPtr<GrGLMapBufferProc> fMapBuffer;
236        GLPtr<GrGLMapBufferRangeProc> fMapBufferRange;
237        GLPtr<GrGLMapBufferSubDataProc> fMapBufferSubData;
238        GLPtr<GrGLMapTexSubImage2DProc> fMapTexSubImage2D;
239        GLPtr<GrGLMatrixLoadfProc> fMatrixLoadf;
240        GLPtr<GrGLMatrixLoadIdentityProc> fMatrixLoadIdentity;
241        GLPtr<GrGLPixelStoreiProc> fPixelStorei;
242        GLPtr<GrGLPopGroupMarkerProc> fPopGroupMarker;
243        GLPtr<GrGLPushGroupMarkerProc> fPushGroupMarker;
244        GLPtr<GrGLQueryCounterProc> fQueryCounter;
245        GLPtr<GrGLReadBufferProc> fReadBuffer;
246        GLPtr<GrGLReadPixelsProc> fReadPixels;
247        GLPtr<GrGLRenderbufferStorageProc> fRenderbufferStorage;
248
249        //  On OpenGL ES there are multiple incompatible extensions that add support for MSAA
250        //  and ES3 adds MSAA support to the standard. On an ES3 driver we may still use the
251        //  older extensions for performance reasons or due to ES3 driver bugs. We want the function
252        //  that creates the GrGLInterface to provide all available functions and internally
253        //  we will select among them. They all have a method called glRenderbufferStorageMultisample*.
254        //  So we have separate function pointers for GL_IMG/EXT_multisampled_to_texture,
255        //  GL_CHROMIUM/ANGLE_framebuffer_multisample/ES3, and GL_APPLE_framebuffer_multisample
256        //  variations.
257        //
258        //  If a driver supports multiple GL_ARB_framebuffer_multisample-style extensions then we will
259        //  assume the function pointers for the standard (or equivalent GL_ARB) version have
260        //  been preferred over GL_EXT, GL_CHROMIUM, or GL_ANGLE variations that have reduced
261        //  functionality.
262
263        //  GL_EXT_multisampled_render_to_texture (preferred) or GL_IMG_multisampled_render_to_texture
264        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2EXT;
265        //  GL_APPLE_framebuffer_multisample
266        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisampleES2APPLE;
267
268        //  This is used to store the pointer for GL_ARB/EXT/ANGLE/CHROMIUM_framebuffer_multisample or
269        //  the standard function in ES3+ or GL 3.0+.
270        GLPtr<GrGLRenderbufferStorageMultisampleProc> fRenderbufferStorageMultisample;
271
272        // Pointer to BindUniformLocationCHROMIUM from the GL_CHROMIUM_bind_uniform_location extension.
273        GLPtr<GrGLBindUniformLocation> fBindUniformLocation;
274
275        GLPtr<GrGLResolveMultisampleFramebufferProc> fResolveMultisampleFramebuffer;
276        GLPtr<GrGLScissorProc> fScissor;
277        GLPtr<GrGLShaderSourceProc> fShaderSource;
278        GLPtr<GrGLStencilFuncProc> fStencilFunc;
279        GLPtr<GrGLStencilFuncSeparateProc> fStencilFuncSeparate;
280        GLPtr<GrGLStencilMaskProc> fStencilMask;
281        GLPtr<GrGLStencilMaskSeparateProc> fStencilMaskSeparate;
282        GLPtr<GrGLStencilOpProc> fStencilOp;
283        GLPtr<GrGLStencilOpSeparateProc> fStencilOpSeparate;
284        GLPtr<GrGLTexImage2DProc> fTexImage2D;
285        GLPtr<GrGLTexParameteriProc> fTexParameteri;
286        GLPtr<GrGLTexParameterivProc> fTexParameteriv;
287        GLPtr<GrGLTexSubImage2DProc> fTexSubImage2D;
288        GLPtr<GrGLTexStorage2DProc> fTexStorage2D;
289        GLPtr<GrGLDiscardFramebufferProc> fDiscardFramebuffer;
290        GLPtr<GrGLUniform1fProc> fUniform1f;
291        GLPtr<GrGLUniform1iProc> fUniform1i;
292        GLPtr<GrGLUniform1fvProc> fUniform1fv;
293        GLPtr<GrGLUniform1ivProc> fUniform1iv;
294        GLPtr<GrGLUniform2fProc> fUniform2f;
295        GLPtr<GrGLUniform2iProc> fUniform2i;
296        GLPtr<GrGLUniform2fvProc> fUniform2fv;
297        GLPtr<GrGLUniform2ivProc> fUniform2iv;
298        GLPtr<GrGLUniform3fProc> fUniform3f;
299        GLPtr<GrGLUniform3iProc> fUniform3i;
300        GLPtr<GrGLUniform3fvProc> fUniform3fv;
301        GLPtr<GrGLUniform3ivProc> fUniform3iv;
302        GLPtr<GrGLUniform4fProc> fUniform4f;
303        GLPtr<GrGLUniform4iProc> fUniform4i;
304        GLPtr<GrGLUniform4fvProc> fUniform4fv;
305        GLPtr<GrGLUniform4ivProc> fUniform4iv;
306        GLPtr<GrGLUniformMatrix2fvProc> fUniformMatrix2fv;
307        GLPtr<GrGLUniformMatrix3fvProc> fUniformMatrix3fv;
308        GLPtr<GrGLUniformMatrix4fvProc> fUniformMatrix4fv;
309        GLPtr<GrGLUnmapBufferProc> fUnmapBuffer;
310        GLPtr<GrGLUnmapBufferSubDataProc> fUnmapBufferSubData;
311        GLPtr<GrGLUnmapTexSubImage2DProc> fUnmapTexSubImage2D;
312        GLPtr<GrGLUseProgramProc> fUseProgram;
313        GLPtr<GrGLVertexAttrib4fvProc> fVertexAttrib4fv;
314        GLPtr<GrGLVertexAttribPointerProc> fVertexAttribPointer;
315        GLPtr<GrGLViewportProc> fViewport;
316
317        // Experimental: Functions for GL_NV_path_rendering. These will be
318        // alphabetized with the above functions once this is fully supported
319        // (and functions we are unlikely to use will possibly be omitted).
320        GLPtr<GrGLPathCommandsProc> fPathCommands;
321        GLPtr<GrGLPathCoordsProc> fPathCoords;
322        GLPtr<GrGLPathSubCommandsProc> fPathSubCommands;
323        GLPtr<GrGLPathSubCoordsProc> fPathSubCoords;
324        GLPtr<GrGLPathStringProc> fPathString;
325        GLPtr<GrGLPathGlyphsProc> fPathGlyphs;
326        GLPtr<GrGLPathGlyphRangeProc> fPathGlyphRange;
327        GLPtr<GrGLWeightPathsProc> fWeightPaths;
328        GLPtr<GrGLCopyPathProc> fCopyPath;
329        GLPtr<GrGLInterpolatePathsProc> fInterpolatePaths;
330        GLPtr<GrGLTransformPathProc> fTransformPath;
331        GLPtr<GrGLPathParameterivProc> fPathParameteriv;
332        GLPtr<GrGLPathParameteriProc> fPathParameteri;
333        GLPtr<GrGLPathParameterfvProc> fPathParameterfv;
334        GLPtr<GrGLPathParameterfProc> fPathParameterf;
335        GLPtr<GrGLPathDashArrayProc> fPathDashArray;
336        GLPtr<GrGLGenPathsProc> fGenPaths;
337        GLPtr<GrGLDeletePathsProc> fDeletePaths;
338        GLPtr<GrGLIsPathProc> fIsPath;
339        GLPtr<GrGLPathStencilFuncProc> fPathStencilFunc;
340        GLPtr<GrGLPathStencilDepthOffsetProc> fPathStencilDepthOffset;
341        GLPtr<GrGLStencilFillPathProc> fStencilFillPath;
342        GLPtr<GrGLStencilStrokePathProc> fStencilStrokePath;
343        GLPtr<GrGLStencilFillPathInstancedProc> fStencilFillPathInstanced;
344        GLPtr<GrGLStencilStrokePathInstancedProc> fStencilStrokePathInstanced;
345        GLPtr<GrGLPathCoverDepthFuncProc> fPathCoverDepthFunc;
346        GLPtr<GrGLPathColorGenProc> fPathColorGen;
347        GLPtr<GrGLPathTexGenProc> fPathTexGen;
348        GLPtr<GrGLPathFogGenProc> fPathFogGen;
349        GLPtr<GrGLCoverFillPathProc> fCoverFillPath;
350        GLPtr<GrGLCoverStrokePathProc> fCoverStrokePath;
351        GLPtr<GrGLCoverFillPathInstancedProc> fCoverFillPathInstanced;
352        GLPtr<GrGLCoverStrokePathInstancedProc> fCoverStrokePathInstanced;
353        GLPtr<GrGLGetPathParameterivProc> fGetPathParameteriv;
354        GLPtr<GrGLGetPathParameterfvProc> fGetPathParameterfv;
355        GLPtr<GrGLGetPathCommandsProc> fGetPathCommands;
356        GLPtr<GrGLGetPathCoordsProc> fGetPathCoords;
357        GLPtr<GrGLGetPathDashArrayProc> fGetPathDashArray;
358        GLPtr<GrGLGetPathMetricsProc> fGetPathMetrics;
359        GLPtr<GrGLGetPathMetricRangeProc> fGetPathMetricRange;
360        GLPtr<GrGLGetPathSpacingProc> fGetPathSpacing;
361        GLPtr<GrGLGetPathColorGenivProc> fGetPathColorGeniv;
362        GLPtr<GrGLGetPathColorGenfvProc> fGetPathColorGenfv;
363        GLPtr<GrGLGetPathTexGenivProc> fGetPathTexGeniv;
364        GLPtr<GrGLGetPathTexGenfvProc> fGetPathTexGenfv;
365        GLPtr<GrGLIsPointInFillPathProc> fIsPointInFillPath;
366        GLPtr<GrGLIsPointInStrokePathProc> fIsPointInStrokePath;
367        GLPtr<GrGLGetPathLengthProc> fGetPathLength;
368        GLPtr<GrGLPointAlongPathProc> fPointAlongPath;
369    } fFunctions;
370
371    // Per-GL func callback
372#if GR_GL_PER_GL_FUNC_CALLBACK
373    GrGLInterfaceCallbackProc fCallback;
374    GrGLInterfaceCallbackData fCallbackData;
375#endif
376};
377
378#endif
379