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<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
