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