1 2 /* 3 * Copyright 2013 Google Inc. 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 #ifndef SkGLContext_DEFINED 9 #define SkGLContext_DEFINED 10 11 #include "GrGLInterface.h" 12 #include "../private/SkGpuFenceSync.h" 13 14 /** 15 * Create an offscreen opengl context with an RGBA8 / 8bit stencil FBO. 16 * Provides a GrGLInterface struct of function pointers for the context. 17 * This class is intended for Skia's testing needs and not for general 18 * use. 19 */ 20 class SK_API SkGLContext : public SkNoncopyable { 21 public: 22 virtual ~SkGLContext(); 23 isValid()24 bool isValid() const { return NULL != gl(); } 25 gl()26 const GrGLInterface* gl() const { return fGL.get(); } 27 fenceSyncSupport()28 bool fenceSyncSupport() const { return SkToBool(fFenceSync); } 29 getMaxGpuFrameLag(int * maxFrameLag)30 bool getMaxGpuFrameLag(int* maxFrameLag) const { 31 if (!fFenceSync) { 32 return false; 33 } 34 *maxFrameLag = kMaxFrameLag; 35 return true; 36 } 37 38 void makeCurrent() const; 39 40 /** Used for testing EGLImage integration. Take a GL_TEXTURE_2D and wraps it in an EGL Image */ texture2DToEGLImage(GrGLuint)41 virtual GrEGLImage texture2DToEGLImage(GrGLuint /*texID*/) const { return 0; } destroyEGLImage(GrEGLImage)42 virtual void destroyEGLImage(GrEGLImage) const {} 43 44 /** Used for testing GL_TEXTURE_RECTANGLE integration. */ 45 GrGLint createTextureRectangle(int width, int height, GrGLenum internalFormat, 46 GrGLenum externalFormat, GrGLenum externalType, 47 GrGLvoid* data); 48 49 /** 50 * Used for testing EGLImage integration. Takes a EGLImage and wraps it in a 51 * GL_TEXTURE_EXTERNAL_OES. 52 */ eglImageToExternalTexture(GrEGLImage)53 virtual GrGLuint eglImageToExternalTexture(GrEGLImage) const { return 0; } 54 55 void swapBuffers(); 56 57 /** 58 * The only purpose of this function it to provide a means of scheduling 59 * work on the GPU (since all of the subclasses create primary buffers for 60 * testing that are small and not meant to be rendered to the screen). 61 * 62 * If the platform supports fence sync (OpenGL 3.2+ or EGL_KHR_fence_sync), 63 * this will not swap any buffers, but rather emulate triple buffer 64 * synchronization using fences. 65 * 66 * Otherwise it will call the platform SwapBuffers method. This may or may 67 * not perform some sort of synchronization, depending on whether the 68 * drawing surface provided by the platform is double buffered. 69 */ 70 void waitOnSyncOrSwap(); 71 72 /** 73 * This notifies the context that we are deliberately testing abandoning 74 * the context. It is useful for debugging contexts that would otherwise 75 * test that GPU resources are properly deleted. It also allows a debugging 76 * context to test that further GL calls are not made by Skia GPU code. 77 */ 78 void testAbandon(); 79 80 /** 81 * Creates a new GL context of the same type and makes the returned context current 82 * (if not null). 83 */ createNew()84 virtual SkGLContext* createNew() const { return nullptr; } 85 86 class GLFenceSync; // SkGpuFenceSync implementation that uses the OpenGL functionality. 87 88 /* 89 * returns the fencesync object owned by this SkGLContext 90 */ fenceSync()91 SkGpuFenceSync* fenceSync() { return fFenceSync.get(); } 92 93 protected: 94 SkGLContext(); 95 96 /* 97 * Methods that sublcasses must call from their constructors and destructors. 98 */ 99 void init(const GrGLInterface*, SkGpuFenceSync* = NULL); 100 void teardown(); 101 102 /* 103 * Operations that have a platform-dependent implementation. 104 */ 105 virtual void onPlatformMakeCurrent() const = 0; 106 virtual void onPlatformSwapBuffers() const = 0; 107 virtual GrGLFuncPtr onPlatformGetProcAddress(const char*) const = 0; 108 109 private: 110 enum { kMaxFrameLag = 3 }; 111 112 SkAutoTDelete<SkGpuFenceSync> fFenceSync; 113 SkPlatformGpuFence fFrameFences[kMaxFrameLag - 1]; 114 int fCurrentFenceIdx; 115 116 /** Subclass provides the gl interface object if construction was 117 * successful. */ 118 SkAutoTUnref<const GrGLInterface> fGL; 119 120 friend class GLFenceSync; // For onPlatformGetProcAddress. 121 }; 122 123 /** Creates platform-dependent GL context object. The shareContext parameter is in an optional 124 * context with which to share display lists. This should be a pointer to an SkGLContext created 125 * with SkCreatePlatformGLContext. NULL indicates that no sharing is to take place. Returns a valid 126 * gl context object or NULL if such can not be created. 127 * Note: If Skia embedder needs a custom GL context that sets up the GL interface, this function 128 * should be implemented by the embedder. Otherwise, the default implementation for the platform 129 * should be compiled in the library. 130 */ 131 SK_API SkGLContext* SkCreatePlatformGLContext(GrGLStandard forcedGpuAPI, 132 SkGLContext* shareContext = nullptr); 133 134 /** 135 * Helper macros for using the GL context through the GrGLInterface. Example: 136 * SK_GL(glCtx, GenTextures(1, &texID)); 137 */ 138 #define SK_GL(ctx, X) (ctx).gl()->fFunctions.f ## X; \ 139 SkASSERT(0 == (ctx).gl()->fFunctions.fGetError()) 140 #define SK_GL_RET(ctx, RET, X) (RET) = (ctx).gl()->fFunctions.f ## X; \ 141 SkASSERT(0 == (ctx).gl()->fFunctions.fGetError()) 142 #define SK_GL_NOERRCHECK(ctx, X) (ctx).gl()->fFunctions.f ## X 143 #define SK_GL_RET_NOERRCHECK(ctx, RET, X) (RET) = (ctx).gl()->fFunctions.f ## X 144 145 #endif 146