bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 1 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 2 | * Copyright 2010 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. |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
| 8 | #ifndef GrContext_DEFINED |
| 9 | #define GrContext_DEFINED |
| 10 | |
commit-bot@chromium.org | a0b4028 | 2013-09-18 13:00:55 +0000 | [diff] [blame] | 11 | #include "SkMatrix.h" |
egdaniel | e61c411 | 2014-06-12 10:24:21 -0700 | [diff] [blame] | 12 | #include "SkPathEffect.h" |
commit-bot@chromium.org | a0b4028 | 2013-09-18 13:00:55 +0000 | [diff] [blame] | 13 | #include "SkTypes.h" |
Robert Phillips | 4217ea7 | 2019-01-30 13:08:28 -0500 | [diff] [blame] | 14 | #include "../private/GrRecordingContext.h" |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 15 | #include "GrContextOptions.h" |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 16 | |
Brian Salomon | 79bf7ac | 2018-05-11 13:08:30 -0400 | [diff] [blame] | 17 | // We shouldn't need this but currently Android is relying on this being include transitively. |
| 18 | #include "SkUnPreMultiply.h" |
| 19 | |
Robert Phillips | c4039ea | 2018-03-01 11:36:45 -0500 | [diff] [blame] | 20 | class GrAtlasManager; |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 21 | class GrBackendFormat; |
Greg Daniel | 5131678 | 2017-08-02 15:10:09 +0000 | [diff] [blame] | 22 | class GrBackendSemaphore; |
Brian Salomon | c7fe0f7 | 2018-05-11 10:14:21 -0400 | [diff] [blame] | 23 | class GrCaps; |
robertphillips | 4fd74ae | 2016-08-03 14:26:53 -0700 | [diff] [blame] | 24 | class GrContextPriv; |
bsalomon | 41b952c | 2016-03-11 06:46:33 -0800 | [diff] [blame] | 25 | class GrContextThreadSafeProxy; |
robertphillips | 77a2e52 | 2015-10-17 07:43:27 -0700 | [diff] [blame] | 26 | class GrDrawingManager; |
joshualitt | b0a8a37 | 2014-09-23 09:50:21 -0700 | [diff] [blame] | 27 | class GrFragmentProcessor; |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 28 | struct GrGLInterface; |
Herb Derby | 081e6f3 | 2019-01-16 13:46:02 -0500 | [diff] [blame] | 29 | class GrStrikeCache; |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 30 | class GrGpu; |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 31 | struct GrMockOptions; |
commit-bot@chromium.org | 5c8ee25 | 2013-11-01 15:23:44 +0000 | [diff] [blame] | 32 | class GrPath; |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 33 | class GrRenderTargetContext; |
bsalomon | 0ea80f4 | 2015-02-11 10:49:59 -0800 | [diff] [blame] | 34 | class GrResourceCache; |
bsalomon | d309e7a | 2015-04-30 14:18:54 -0700 | [diff] [blame] | 35 | class GrResourceProvider; |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 36 | class GrSamplerState; |
Robert Phillips | a0bc39d | 2019-01-29 13:14:47 -0500 | [diff] [blame] | 37 | class GrSkSLFPFactoryCache; |
Robert Phillips | 7ee385e | 2017-03-30 08:02:11 -0400 | [diff] [blame] | 38 | class GrSurfaceProxy; |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 39 | class GrSwizzle; |
joshualitt | b7133be | 2015-04-08 09:08:31 -0700 | [diff] [blame] | 40 | class GrTextBlobCache; |
kkinnunen | c6cb56f | 2014-06-24 00:12:27 -0700 | [diff] [blame] | 41 | class GrTextContext; |
Mike Reed | 84dd857 | 2017-03-08 22:21:00 -0500 | [diff] [blame] | 42 | class GrTextureProxy; |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 43 | struct GrVkBackendContext; |
bsalomon@google.com | 50398bf | 2011-07-26 20:45:30 +0000 | [diff] [blame] | 44 | |
Mike Reed | 84dd857 | 2017-03-08 22:21:00 -0500 | [diff] [blame] | 45 | class SkImage; |
| 46 | class SkSurfaceProps; |
Brian Osman | 5127998 | 2017-08-23 10:12:00 -0400 | [diff] [blame] | 47 | class SkTaskGroup; |
Robert Phillips | fc711a2 | 2018-02-13 17:03:00 -0500 | [diff] [blame] | 48 | class SkTraceMemoryDump; |
Mike Reed | 84dd857 | 2017-03-08 22:21:00 -0500 | [diff] [blame] | 49 | |
Robert Phillips | 4217ea7 | 2019-01-30 13:08:28 -0500 | [diff] [blame] | 50 | class SK_API GrContext : public GrRecordingContext { |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 51 | public: |
| 52 | /** |
Brian Salomon | c1b9c10 | 2018-04-06 09:18:00 -0400 | [diff] [blame] | 53 | * Creates a GrContext for a backend context. If no GrGLInterface is provided then the result of |
| 54 | * GrGLMakeNativeInterface() is used if it succeeds. |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 55 | */ |
Brian Salomon | 384fab4 | 2017-12-07 12:33:05 -0500 | [diff] [blame] | 56 | static sk_sp<GrContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&); |
| 57 | static sk_sp<GrContext> MakeGL(sk_sp<const GrGLInterface>); |
Brian Salomon | c1b9c10 | 2018-04-06 09:18:00 -0400 | [diff] [blame] | 58 | static sk_sp<GrContext> MakeGL(const GrContextOptions&); |
| 59 | static sk_sp<GrContext> MakeGL(); |
| 60 | |
Greg Daniel | 10a83da | 2018-06-14 09:31:11 -0400 | [diff] [blame] | 61 | static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&); |
| 62 | static sk_sp<GrContext> MakeVulkan(const GrVkBackendContext&); |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 63 | |
Greg Daniel | b76a72a | 2017-07-13 15:07:54 -0400 | [diff] [blame] | 64 | #ifdef SK_METAL |
| 65 | /** |
| 66 | * Makes a GrContext which uses Metal as the backend. The device parameter is an MTLDevice |
| 67 | * and queue is an MTLCommandQueue which should be used by the backend. These objects must |
| 68 | * have a ref on them which can be transferred to Ganesh which will release the ref when the |
| 69 | * GrContext is destroyed. |
| 70 | */ |
| 71 | static sk_sp<GrContext> MakeMetal(void* device, void* queue, const GrContextOptions& options); |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 72 | static sk_sp<GrContext> MakeMetal(void* device, void* queue); |
Greg Daniel | b76a72a | 2017-07-13 15:07:54 -0400 | [diff] [blame] | 73 | #endif |
| 74 | |
Greg Daniel | 02611d9 | 2017-07-25 10:05:01 -0400 | [diff] [blame] | 75 | static sk_sp<GrContext> MakeMock(const GrMockOptions*, const GrContextOptions&); |
| 76 | static sk_sp<GrContext> MakeMock(const GrMockOptions*); |
| 77 | |
Robert Phillips | bb60677 | 2019-02-04 17:50:57 -0500 | [diff] [blame] | 78 | ~GrContext() override; |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 79 | |
bungeman | 6bd5284 | 2016-10-27 09:30:08 -0700 | [diff] [blame] | 80 | sk_sp<GrContextThreadSafeProxy> threadSafeProxy(); |
bsalomon | 41b952c | 2016-03-11 06:46:33 -0800 | [diff] [blame] | 81 | |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 82 | /** |
| 83 | * The GrContext normally assumes that no outsider is setting state |
| 84 | * within the underlying 3D API's context/device/whatever. This call informs |
| 85 | * the context that the state was modified and it should resend. Shouldn't |
| 86 | * be called frequently for good performance. |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 87 | * The flag bits, state, is dpendent on which backend is used by the |
| 88 | * context, either GL or D3D (possible in future). |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 89 | */ |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 90 | void resetContext(uint32_t state = kAll_GrBackendState); |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 91 | |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 92 | /** |
Robert Phillips | 88260b5 | 2018-01-19 12:56:09 -0500 | [diff] [blame] | 93 | * Abandons all GPU resources and assumes the underlying backend 3D API context is no longer |
bsalomon | 6e2aad4 | 2016-04-01 11:54:31 -0700 | [diff] [blame] | 94 | * usable. Call this if you have lost the associated GPU context, and thus internal texture, |
| 95 | * buffer, etc. references/IDs are now invalid. Calling this ensures that the destructors of the |
| 96 | * GrContext and any of its created resource objects will not make backend 3D API calls. Content |
| 97 | * rendered but not previously flushed may be lost. After this function is called all subsequent |
| 98 | * calls on the GrContext will fail or be no-ops. |
| 99 | * |
| 100 | * The typical use case for this function is that the underlying 3D context was lost and further |
| 101 | * API calls may crash. |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 102 | */ |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 103 | virtual void abandonContext(); |
junov@google.com | 53a5584 | 2011-06-08 22:55:10 +0000 | [diff] [blame] | 104 | |
bsalomon | 6e2aad4 | 2016-04-01 11:54:31 -0700 | [diff] [blame] | 105 | /** |
Khushal | c421ca1 | 2018-06-26 14:38:34 -0700 | [diff] [blame] | 106 | * Returns true if the context was abandoned. |
| 107 | */ |
| 108 | bool abandoned() const; |
| 109 | |
| 110 | /** |
bsalomon | 6e2aad4 | 2016-04-01 11:54:31 -0700 | [diff] [blame] | 111 | * This is similar to abandonContext() however the underlying 3D context is not yet lost and |
| 112 | * the GrContext will cleanup all allocated resources before returning. After returning it will |
| 113 | * assume that the underlying context may no longer be valid. |
| 114 | * |
| 115 | * The typical use case for this function is that the client is going to destroy the 3D context |
| 116 | * but can't guarantee that GrContext will be destroyed first (perhaps because it may be ref'ed |
| 117 | * elsewhere by either the client or Skia objects). |
| 118 | */ |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 119 | virtual void releaseResourcesAndAbandonContext(); |
bsalomon | 6e2aad4 | 2016-04-01 11:54:31 -0700 | [diff] [blame] | 120 | |
commit-bot@chromium.org | 95c2003 | 2014-05-09 14:29:32 +0000 | [diff] [blame] | 121 | /////////////////////////////////////////////////////////////////////////// |
| 122 | // Resource Cache |
| 123 | |
| 124 | /** |
| 125 | * Return the current GPU resource cache limits. |
| 126 | * |
| 127 | * @param maxResources If non-null, returns maximum number of resources that |
| 128 | * can be held in the cache. |
| 129 | * @param maxResourceBytes If non-null, returns maximum number of bytes of |
| 130 | * video memory that can be held in the cache. |
| 131 | */ |
| 132 | void getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const; |
commit-bot@chromium.org | 95c2003 | 2014-05-09 14:29:32 +0000 | [diff] [blame] | 133 | |
| 134 | /** |
| 135 | * Gets the current GPU resource cache usage. |
| 136 | * |
| 137 | * @param resourceCount If non-null, returns the number of resources that are held in the |
| 138 | * cache. |
| 139 | * @param maxResourceBytes If non-null, returns the total number of bytes of video memory held |
| 140 | * in the cache. |
| 141 | */ |
| 142 | void getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const; |
| 143 | |
commit-bot@chromium.org | 95c2003 | 2014-05-09 14:29:32 +0000 | [diff] [blame] | 144 | /** |
Derek Sollenberger | ee47914 | 2017-05-24 11:41:33 -0400 | [diff] [blame] | 145 | * Gets the number of bytes in the cache consumed by purgeable (e.g. unlocked) resources. |
| 146 | */ |
| 147 | size_t getResourceCachePurgeableBytes() const; |
| 148 | |
| 149 | /** |
commit-bot@chromium.org | 95c2003 | 2014-05-09 14:29:32 +0000 | [diff] [blame] | 150 | * Specify the GPU resource cache limits. If the current cache exceeds either |
| 151 | * of these, it will be purged (LRU) to keep the cache within these limits. |
| 152 | * |
| 153 | * @param maxResources The maximum number of resources that can be held in |
| 154 | * the cache. |
| 155 | * @param maxResourceBytes The maximum number of bytes of video memory |
| 156 | * that can be held in the cache. |
| 157 | */ |
| 158 | void setResourceCacheLimits(int maxResources, size_t maxResourceBytes); |
commit-bot@chromium.org | 95c2003 | 2014-05-09 14:29:32 +0000 | [diff] [blame] | 159 | |
junov@google.com | 53a5584 | 2011-06-08 22:55:10 +0000 | [diff] [blame] | 160 | /** |
bsalomon@google.com | 1e269b5 | 2012-10-15 14:25:31 +0000 | [diff] [blame] | 161 | * Frees GPU created by the context. Can be called to reduce GPU memory |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 162 | * pressure. |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 163 | */ |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 164 | virtual void freeGpuResources(); |
bsalomon@google.com | 8fe7247 | 2011-03-30 21:26:44 +0000 | [diff] [blame] | 165 | |
bsalomon@google.com | 07fc0d1 | 2012-06-22 15:15:59 +0000 | [diff] [blame] | 166 | /** |
Jim Van Verth | 76d917c | 2017-12-13 09:26:37 -0500 | [diff] [blame] | 167 | * Purge GPU resources that haven't been used in the past 'msNotUsed' milliseconds or are |
| 168 | * otherwise marked for deletion, regardless of whether the context is under budget. |
Brian Salomon | 5e15085 | 2017-03-22 14:53:13 -0400 | [diff] [blame] | 169 | */ |
Jim Van Verth | 76d917c | 2017-12-13 09:26:37 -0500 | [diff] [blame] | 170 | void performDeferredCleanup(std::chrono::milliseconds msNotUsed); |
Brian Salomon | 5e15085 | 2017-03-22 14:53:13 -0400 | [diff] [blame] | 171 | |
Mike Klein | 4b6bde7 | 2017-12-14 07:46:55 -0500 | [diff] [blame] | 172 | // Temporary compatibility API for Android. |
| 173 | void purgeResourcesNotUsedInMs(std::chrono::milliseconds msNotUsed) { |
| 174 | this->performDeferredCleanup(msNotUsed); |
| 175 | } |
| 176 | |
Derek Sollenberger | 5480a18 | 2017-05-25 16:43:59 -0400 | [diff] [blame] | 177 | /** |
| 178 | * Purge unlocked resources from the cache until the the provided byte count has been reached |
| 179 | * or we have purged all unlocked resources. The default policy is to purge in LRU order, but |
| 180 | * can be overridden to prefer purging scratch resources (in LRU order) prior to purging other |
| 181 | * resource types. |
| 182 | * |
| 183 | * @param maxBytesToPurge the desired number of bytes to be purged. |
| 184 | * @param preferScratchResources If true scratch resources will be purged prior to other |
| 185 | * resource types. |
| 186 | */ |
| 187 | void purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources); |
| 188 | |
Robert Phillips | 6eba063 | 2018-03-28 12:25:42 -0400 | [diff] [blame] | 189 | /** |
| 190 | * This entry point is intended for instances where an app has been backgrounded or |
| 191 | * suspended. |
| 192 | * If 'scratchResourcesOnly' is true all unlocked scratch resources will be purged but the |
| 193 | * unlocked resources with persistent data will remain. If 'scratchResourcesOnly' is false |
| 194 | * then all unlocked resources will be purged. |
| 195 | * In either case, after the unlocked resources are purged a separate pass will be made to |
| 196 | * ensure that resource usage is under budget (i.e., even if 'scratchResourcesOnly' is true |
| 197 | * some resources with persistent data may be purged to be under budget). |
| 198 | * |
| 199 | * @param scratchResourcesOnly If true only unlocked scratch resources will be purged prior |
| 200 | * enforcing the budget requirements. |
| 201 | */ |
| 202 | void purgeUnlockedResources(bool scratchResourcesOnly); |
| 203 | |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 204 | /** |
Brian Salomon | f932a63 | 2018-04-05 12:46:09 -0400 | [diff] [blame] | 205 | * Gets the maximum supported texture size. |
| 206 | */ |
| 207 | int maxTextureSize() const; |
| 208 | |
| 209 | /** |
| 210 | * Gets the maximum supported render target size. |
| 211 | */ |
| 212 | int maxRenderTargetSize() const; |
| 213 | |
| 214 | /** |
Brian Salomon | bdecacf | 2018-02-02 20:32:49 -0500 | [diff] [blame] | 215 | * Can a SkImage be created with the given color type. |
| 216 | */ |
| 217 | bool colorTypeSupportedAsImage(SkColorType) const; |
| 218 | |
| 219 | /** |
| 220 | * Can a SkSurface be created with the given color type. To check whether MSAA is supported |
| 221 | * use maxSurfaceSampleCountForColorType(). |
| 222 | */ |
| 223 | bool colorTypeSupportedAsSurface(SkColorType colorType) const { |
| 224 | return this->maxSurfaceSampleCountForColorType(colorType) > 0; |
| 225 | } |
| 226 | |
| 227 | /** |
| 228 | * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA |
| 229 | * rendering is supported for the color type. 0 is returned if rendering to this color type |
| 230 | * is not supported at all. |
| 231 | */ |
| 232 | int maxSurfaceSampleCountForColorType(SkColorType) const; |
| 233 | |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 234 | /////////////////////////////////////////////////////////////////////////// |
| 235 | // Misc. |
| 236 | |
| 237 | /** |
Greg Daniel | 5131678 | 2017-08-02 15:10:09 +0000 | [diff] [blame] | 238 | * Call to ensure all drawing to the context has been issued to the underlying 3D API. |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 239 | */ |
bsalomon | b77a907 | 2016-09-07 10:02:04 -0700 | [diff] [blame] | 240 | void flush(); |
robertphillips | ea46150 | 2015-05-26 11:38:03 -0700 | [diff] [blame] | 241 | |
senorblanco@chromium.org | 027de5f | 2011-07-08 18:03:33 +0000 | [diff] [blame] | 242 | /** |
Greg Daniel | 5131678 | 2017-08-02 15:10:09 +0000 | [diff] [blame] | 243 | * Call to ensure all drawing to the context has been issued to the underlying 3D API. After |
| 244 | * issuing all commands, numSemaphore semaphores will be signaled by the gpu. The client passes |
| 245 | * in an array of numSemaphores GrBackendSemaphores. In general these GrBackendSemaphore's can |
| 246 | * be either initialized or not. If they are initialized, the backend uses the passed in |
| 247 | * semaphore. If it is not initialized, a new semaphore is created and the GrBackendSemaphore |
| 248 | * object is initialized with that semaphore. |
| 249 | * |
| 250 | * The client will own and be responsible for deleting the underlying semaphores that are stored |
| 251 | * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects |
| 252 | * themselves can be deleted as soon as this function returns. |
| 253 | * |
| 254 | * If the backend API is OpenGL only uninitialized GrBackendSemaphores are supported. |
| 255 | * If the backend API is Vulkan either initialized or unitialized semaphores are supported. |
| 256 | * If unitialized, the semaphores which are created will be valid for use only with the VkDevice |
| 257 | * with which they were created. |
| 258 | * |
| 259 | * If this call returns GrSemaphoresSubmited::kNo, the GPU backend will not have created or |
| 260 | * added any semaphores to signal on the GPU. Thus the client should not have the GPU wait on |
| 261 | * any of the semaphores. However, any pending commands to the context will still be flushed. |
| 262 | */ |
| 263 | GrSemaphoresSubmitted flushAndSignalSemaphores(int numSemaphores, |
| 264 | GrBackendSemaphore signalSemaphores[]); |
| 265 | |
robertphillips | 4fd74ae | 2016-08-03 14:26:53 -0700 | [diff] [blame] | 266 | // Provides access to functions that aren't part of the public API. |
Robert Phillips | 9da87e0 | 2019-02-04 13:26:26 -0500 | [diff] [blame] | 267 | GrContextPriv priv(); |
| 268 | const GrContextPriv priv() const; |
robertphillips | 4fd74ae | 2016-08-03 14:26:53 -0700 | [diff] [blame] | 269 | |
Robert Phillips | 0c4b7b1 | 2018-03-06 08:20:37 -0500 | [diff] [blame] | 270 | /** Enumerates all cached GPU resources and dumps their memory to traceMemoryDump. */ |
| 271 | // Chrome is using this! |
| 272 | void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const; |
| 273 | |
Khushal | 3e7548c | 2018-05-23 15:45:01 -0700 | [diff] [blame] | 274 | bool supportsDistanceFieldText() const; |
| 275 | |
Greg Daniel | a870b46 | 2019-01-08 15:49:46 -0500 | [diff] [blame] | 276 | void storeVkPipelineCacheData(); |
| 277 | |
Robert Phillips | 88260b5 | 2018-01-19 12:56:09 -0500 | [diff] [blame] | 278 | protected: |
Robert Phillips | a41c685 | 2019-02-07 10:44:10 -0500 | [diff] [blame] | 279 | GrContext(GrBackendApi, const GrContextOptions&, int32_t contextID = SK_InvalidGenID); |
| 280 | |
| 281 | GrContext* asDirectContext() override { return this; } |
Robert Phillips | 88260b5 | 2018-01-19 12:56:09 -0500 | [diff] [blame] | 282 | |
Robert Phillips | bb60677 | 2019-02-04 17:50:57 -0500 | [diff] [blame] | 283 | bool init(sk_sp<const GrCaps>, sk_sp<GrSkSLFPFactoryCache>) override; |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 284 | |
Robert Phillips | 5a66efb | 2018-03-07 15:13:18 -0500 | [diff] [blame] | 285 | virtual GrAtlasManager* onGetAtlasManager() = 0; |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 286 | |
Robert Phillips | fde6fa0 | 2018-03-02 08:53:14 -0500 | [diff] [blame] | 287 | sk_sp<GrContextThreadSafeProxy> fThreadSafeProxy; |
Robert Phillips | 1056eb8 | 2018-03-01 14:16:41 -0500 | [diff] [blame] | 288 | |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 289 | private: |
Ethan Nicholas | 8e265a7 | 2018-12-12 16:22:40 -0500 | [diff] [blame] | 290 | // fTaskGroup must appear before anything that uses it (e.g. fGpu), so that it is destroyed |
| 291 | // after all of its users. Clients of fTaskGroup will generally want to ensure that they call |
| 292 | // wait() on it as they are being destroyed, to avoid the possibility of pending tasks being |
| 293 | // invoked after objects they depend upon have already been destroyed. |
| 294 | std::unique_ptr<SkTaskGroup> fTaskGroup; |
Brian Salomon | 384fab4 | 2017-12-07 12:33:05 -0500 | [diff] [blame] | 295 | sk_sp<GrGpu> fGpu; |
bsalomon | 41b952c | 2016-03-11 06:46:33 -0800 | [diff] [blame] | 296 | GrResourceCache* fResourceCache; |
Brian Osman | 32342f0 | 2017-03-04 08:12:46 -0500 | [diff] [blame] | 297 | GrResourceProvider* fResourceProvider; |
bsalomon | d309e7a | 2015-04-30 14:18:54 -0700 | [diff] [blame] | 298 | |
Robert Phillips | d684148 | 2019-02-08 10:29:20 -0500 | [diff] [blame^] | 299 | GrStrikeCache* fGlyphCache; |
bungeman | 6bd5284 | 2016-10-27 09:30:08 -0700 | [diff] [blame] | 300 | std::unique_ptr<GrTextBlobCache> fTextBlobCache; |
bsalomon@google.com | dfe75bc | 2011-03-25 12:31:16 +0000 | [diff] [blame] | 301 | |
bsalomon | 41b952c | 2016-03-11 06:46:33 -0800 | [diff] [blame] | 302 | bool fDidTestPMConversions; |
Brian Osman | 28804f3 | 2017-04-20 10:24:36 -0400 | [diff] [blame] | 303 | // true if the PM/UPM conversion succeeded; false otherwise |
| 304 | bool fPMUPMConversionsRoundTrip; |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 305 | |
bungeman | 6bd5284 | 2016-10-27 09:30:08 -0700 | [diff] [blame] | 306 | std::unique_ptr<GrDrawingManager> fDrawingManager; |
robertphillips | 77a2e52 | 2015-10-17 07:43:27 -0700 | [diff] [blame] | 307 | |
Ethan Nicholas | d1b2eec | 2017-11-01 15:45:43 -0400 | [diff] [blame] | 308 | GrContextOptions::PersistentCache* fPersistentCache; |
| 309 | |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 310 | // TODO: have the GrClipStackClip use renderTargetContexts and rm this friending |
robertphillips | 4fd74ae | 2016-08-03 14:26:53 -0700 | [diff] [blame] | 311 | friend class GrContextPriv; |
csmartdalton | c6f411e | 2016-08-05 22:32:12 -0700 | [diff] [blame] | 312 | |
skia.committer@gmail.com | cdcb2ce | 2013-01-29 07:05:52 +0000 | [diff] [blame] | 313 | /** |
Brian Osman | 5ea96bf | 2018-10-02 14:58:05 -0400 | [diff] [blame] | 314 | * These functions create premul <-> unpremul effects, using the specialized round-trip effects |
| 315 | * from GrConfigConversionEffect. |
bsalomon@google.com | adc6536 | 2013-01-28 14:26:09 +0000 | [diff] [blame] | 316 | */ |
Brian Osman | 5ea96bf | 2018-10-02 14:58:05 -0400 | [diff] [blame] | 317 | std::unique_ptr<GrFragmentProcessor> createPMToUPMEffect(std::unique_ptr<GrFragmentProcessor>); |
| 318 | std::unique_ptr<GrFragmentProcessor> createUPMToPMEffect(std::unique_ptr<GrFragmentProcessor>); |
Brian Osman | 409e74f | 2017-04-17 11:48:28 -0400 | [diff] [blame] | 319 | |
| 320 | /** |
Brian Osman | 5ea96bf | 2018-10-02 14:58:05 -0400 | [diff] [blame] | 321 | * Returns true if createPMToUPMEffect and createUPMToPMEffect will succeed. In other words, |
| 322 | * did we find a pair of round-trip preserving conversion effects? |
Brian Osman | 409e74f | 2017-04-17 11:48:28 -0400 | [diff] [blame] | 323 | */ |
| 324 | bool validPMUPMConversionExists(); |
bsalomon@google.com | a04e8e8 | 2012-08-27 12:53:13 +0000 | [diff] [blame] | 325 | |
commit-bot@chromium.org | cae27fe | 2013-07-10 10:14:35 +0000 | [diff] [blame] | 326 | /** |
joshualitt | 0db6dfa | 2015-04-10 07:01:30 -0700 | [diff] [blame] | 327 | * A callback similar to the above for use by the TextBlobCache |
| 328 | * TODO move textblob draw calls below context so we can use the call above. |
| 329 | */ |
| 330 | static void TextBlobCacheOverBudgetCB(void* data); |
| 331 | |
Robert Phillips | 4217ea7 | 2019-01-30 13:08:28 -0500 | [diff] [blame] | 332 | typedef GrRecordingContext INHERITED; |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 333 | }; |
| 334 | |
bsalomon@google.com | 27847de | 2011-02-22 20:59:41 +0000 | [diff] [blame] | 335 | #endif |