| /* |
| * Copyright 2020 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #ifndef GrDirectContext_DEFINED |
| #define GrDirectContext_DEFINED |
| |
| #include "include/gpu/GrRecordingContext.h" |
| |
| #include "include/gpu/GrBackendSurface.h" |
| |
| // We shouldn't need this but currently Android is relying on this being include transitively. |
| #include "include/core/SkUnPreMultiply.h" |
| |
| class GrAtlasManager; |
| class GrBackendSemaphore; |
| class GrClientMappedBufferManager; |
| class GrDirectContextPriv; |
| class GrContextThreadSafeProxy; |
| struct GrD3DBackendContext; |
| class GrFragmentProcessor; |
| class GrGpu; |
| struct GrGLInterface; |
| struct GrMtlBackendContext; |
| struct GrMockOptions; |
| class GrPath; |
| class GrResourceCache; |
| class GrResourceProvider; |
| class GrSurfaceProxy; |
| class GrTextureProxy; |
| struct GrVkBackendContext; |
| |
| class SkImage; |
| class SkString; |
| class SkSurfaceCharacterization; |
| class SkSurfaceProps; |
| class SkTaskGroup; |
| class SkTraceMemoryDump; |
| |
| namespace skgpu { |
| class Swizzle; |
| #if !defined(SK_ENABLE_OPTIMIZE_SIZE) |
| namespace v1 { class SmallPathAtlasMgr; } |
| #endif |
| } |
| |
| namespace sktext::gpu { |
| class StrikeCache; |
| } |
| |
| class SK_API GrDirectContext : public GrRecordingContext { |
| public: |
| #ifdef SK_GL |
| /** |
| * Creates a GrDirectContext for a backend context. If no GrGLInterface is provided then the |
| * result of GrGLMakeNativeInterface() is used if it succeeds. |
| */ |
| static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>); |
| static sk_sp<GrDirectContext> MakeGL(const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeGL(); |
| #endif |
| |
| #ifdef SK_VULKAN |
| /** |
| * The Vulkan context (VkQueue, VkDevice, VkInstance) must be kept alive until the returned |
| * GrDirectContext is destroyed. This also means that any objects created with this |
| * GrDirectContext (e.g. SkSurfaces, SkImages, etc.) must also be released as they may hold |
| * refs on the GrDirectContext. Once all these objects and the GrDirectContext are released, |
| * then it is safe to delete the vulkan objects. |
| */ |
| static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&); |
| #endif |
| |
| #ifdef SK_METAL |
| /** |
| * Makes a GrDirectContext which uses Metal as the backend. The GrMtlBackendContext contains a |
| * MTLDevice and MTLCommandQueue which should be used by the backend. These objects must |
| * have their own ref which will be released when the GrMtlBackendContext is destroyed. |
| * Ganesh will take its own ref on the objects which will be released when the GrDirectContext |
| * is destroyed. |
| */ |
| static sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&); |
| /** |
| * Deprecated. |
| * |
| * Makes a GrDirectContext which uses Metal as the backend. The device parameter is an |
| * MTLDevice and queue is an MTLCommandQueue which should be used by the backend. These objects |
| * must have a ref on them that can be transferred to Ganesh, which will release the ref |
| * when the GrDirectContext is destroyed. |
| */ |
| static sk_sp<GrDirectContext> MakeMetal(void* device, void* queue, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeMetal(void* device, void* queue); |
| #endif |
| |
| #ifdef SK_DIRECT3D |
| /** |
| * Makes a GrDirectContext which uses Direct3D as the backend. The Direct3D context |
| * must be kept alive until the returned GrDirectContext is first destroyed or abandoned. |
| */ |
| static sk_sp<GrDirectContext> MakeDirect3D(const GrD3DBackendContext&, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeDirect3D(const GrD3DBackendContext&); |
| #endif |
| |
| #ifdef SK_DAWN |
| static sk_sp<GrDirectContext> MakeDawn(const wgpu::Device&, |
| const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeDawn(const wgpu::Device&); |
| #endif |
| |
| static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*, const GrContextOptions&); |
| static sk_sp<GrDirectContext> MakeMock(const GrMockOptions*); |
| |
| ~GrDirectContext() override; |
| |
| /** |
| * The context normally assumes that no outsider is setting state |
| * within the underlying 3D API's context/device/whatever. This call informs |
| * the context that the state was modified and it should resend. Shouldn't |
| * be called frequently for good performance. |
| * The flag bits, state, is dependent on which backend is used by the |
| * context, either GL or D3D (possible in future). |
| */ |
| void resetContext(uint32_t state = kAll_GrBackendState); |
| |
| /** |
| * If the backend is GrBackendApi::kOpenGL, then all texture unit/target combinations for which |
| * the context has modified the bound texture will have texture id 0 bound. This does not |
| * flush the context. Calling resetContext() does not change the set that will be bound |
| * to texture id 0 on the next call to resetGLTextureBindings(). After this is called |
| * all unit/target combinations are considered to have unmodified bindings until the context |
| * subsequently modifies them (meaning if this is called twice in a row with no intervening |
| * context usage then the second call is a no-op.) |
| */ |
| void resetGLTextureBindings(); |
| |
| /** |
| * Abandons all GPU resources and assumes the underlying backend 3D API context is no longer |
| * usable. Call this if you have lost the associated GPU context, and thus internal texture, |
| * buffer, etc. references/IDs are now invalid. Calling this ensures that the destructors of the |
| * context and any of its created resource objects will not make backend 3D API calls. Content |
| * rendered but not previously flushed may be lost. After this function is called all subsequent |
| * calls on the context will fail or be no-ops. |
| * |
| * The typical use case for this function is that the underlying 3D context was lost and further |
| * API calls may crash. |
| * |
| * This call is not valid to be made inside ReleaseProcs passed into SkSurface or SkImages. The |
| * call will simply fail (and assert in debug) if it is called while inside a ReleaseProc. |
| * |
| * For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to |
| * create the context must be kept alive even after abandoning the context. Those objects must |
| * live for the lifetime of the context object itself. The reason for this is so that |
| * we can continue to delete any outstanding GrBackendTextures/RenderTargets which must be |
| * cleaned up even in a device lost state. |
| */ |
| void abandonContext() override; |
| |
| /** |
| * Returns true if the context was abandoned or if the if the backend specific context has |
| * gotten into an unrecoverarble, lost state (e.g. in Vulkan backend if we've gotten a |
| * VK_ERROR_DEVICE_LOST). If the backend context is lost, this call will also abandon this |
| * context. |
| */ |
| bool abandoned() override; |
| |
| // TODO: Remove this from public after migrating Chrome. |
| sk_sp<GrContextThreadSafeProxy> threadSafeProxy(); |
| |
| /** |
| * Checks if the underlying 3D API reported an out-of-memory error. If this returns true it is |
| * reset and will return false until another out-of-memory error is reported by the 3D API. If |
| * the context is abandoned then this will report false. |
| * |
| * Currently this is implemented for: |
| * |
| * OpenGL [ES] - Note that client calls to glGetError() may swallow GL_OUT_OF_MEMORY errors and |
| * therefore hide the error from Skia. Also, it is not advised to use this in combination with |
| * enabling GrContextOptions::fSkipGLErrorChecks. That option may prevent the context from ever |
| * checking the GL context for OOM. |
| * |
| * Vulkan - Reports true if VK_ERROR_OUT_OF_HOST_MEMORY or VK_ERROR_OUT_OF_DEVICE_MEMORY has |
| * occurred. |
| */ |
| bool oomed(); |
| |
| /** |
| * This is similar to abandonContext() however the underlying 3D context is not yet lost and |
| * the context will cleanup all allocated resources before returning. After returning it will |
| * assume that the underlying context may no longer be valid. |
| * |
| * The typical use case for this function is that the client is going to destroy the 3D context |
| * but can't guarantee that context will be destroyed first (perhaps because it may be ref'ed |
| * elsewhere by either the client or Skia objects). |
| * |
| * For Vulkan, even if the device becomes lost, the VkQueue, VkDevice, or VkInstance used to |
| * create the context must be alive before calling releaseResourcesAndAbandonContext. |
| */ |
| void releaseResourcesAndAbandonContext(); |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Resource Cache |
| |
| /** DEPRECATED |
| * Return the current GPU resource cache limits. |
| * |
| * @param maxResources If non-null, will be set to -1. |
| * @param maxResourceBytes If non-null, returns maximum number of bytes of |
| * video memory that can be held in the cache. |
| */ |
| void getResourceCacheLimits(int* maxResources, size_t* maxResourceBytes) const; |
| |
| /** |
| * Return the current GPU resource cache limit in bytes. |
| */ |
| size_t getResourceCacheLimit() const; |
| |
| /** |
| * Gets the current GPU resource cache usage. |
| * |
| * @param resourceCount If non-null, returns the number of resources that are held in the |
| * cache. |
| * @param maxResourceBytes If non-null, returns the total number of bytes of video memory held |
| * in the cache. |
| */ |
| void getResourceCacheUsage(int* resourceCount, size_t* resourceBytes) const; |
| |
| /** |
| * Gets the number of bytes in the cache consumed by purgeable (e.g. unlocked) resources. |
| */ |
| size_t getResourceCachePurgeableBytes() const; |
| |
| /** DEPRECATED |
| * Specify the GPU resource cache limits. If the current cache exceeds the maxResourceBytes |
| * limit, it will be purged (LRU) to keep the cache within the limit. |
| * |
| * @param maxResources Unused. |
| * @param maxResourceBytes The maximum number of bytes of video memory |
| * that can be held in the cache. |
| */ |
| void setResourceCacheLimits(int maxResources, size_t maxResourceBytes); |
| |
| /** |
| * Specify the GPU resource cache limit. If the cache currently exceeds this limit, |
| * it will be purged (LRU) to keep the cache within the limit. |
| * |
| * @param maxResourceBytes The maximum number of bytes of video memory |
| * that can be held in the cache. |
| */ |
| void setResourceCacheLimit(size_t maxResourceBytes); |
| |
| /** |
| * Frees GPU created by the context. Can be called to reduce GPU memory |
| * pressure. |
| */ |
| void freeGpuResources(); |
| |
| /** |
| * Purge GPU resources that haven't been used in the past 'msNotUsed' milliseconds or are |
| * otherwise marked for deletion, regardless of whether the context is under budget. |
| * |
| * If 'scratchResourcesOnly' is true all unlocked scratch resources older than 'msNotUsed' will |
| * be purged but the unlocked resources with persistent data will remain. If |
| * 'scratchResourcesOnly' is false then all unlocked resources older than 'msNotUsed' will be |
| * purged. |
| * |
| * @param msNotUsed Only unlocked resources not used in these last milliseconds |
| * will be cleaned up. |
| * @param scratchResourcesOnly If true only unlocked scratch resources will be purged. |
| */ |
| void performDeferredCleanup(std::chrono::milliseconds msNotUsed, |
| bool scratchResourcesOnly=false); |
| |
| // Temporary compatibility API for Android. |
| void purgeResourcesNotUsedInMs(std::chrono::milliseconds msNotUsed) { |
| this->performDeferredCleanup(msNotUsed); |
| } |
| |
| /** |
| * Purge unlocked resources from the cache until the the provided byte count has been reached |
| * or we have purged all unlocked resources. The default policy is to purge in LRU order, but |
| * can be overridden to prefer purging scratch resources (in LRU order) prior to purging other |
| * resource types. |
| * |
| * @param maxBytesToPurge the desired number of bytes to be purged. |
| * @param preferScratchResources If true scratch resources will be purged prior to other |
| * resource types. |
| */ |
| void purgeUnlockedResources(size_t bytesToPurge, bool preferScratchResources); |
| |
| /** |
| * This entry point is intended for instances where an app has been backgrounded or |
| * suspended. |
| * If 'scratchResourcesOnly' is true all unlocked scratch resources will be purged but the |
| * unlocked resources with persistent data will remain. If 'scratchResourcesOnly' is false |
| * then all unlocked resources will be purged. |
| * In either case, after the unlocked resources are purged a separate pass will be made to |
| * ensure that resource usage is under budget (i.e., even if 'scratchResourcesOnly' is true |
| * some resources with persistent data may be purged to be under budget). |
| * |
| * @param scratchResourcesOnly If true only unlocked scratch resources will be purged prior |
| * enforcing the budget requirements. |
| */ |
| void purgeUnlockedResources(bool scratchResourcesOnly); |
| |
| /** |
| * Gets the maximum supported texture size. |
| */ |
| using GrRecordingContext::maxTextureSize; |
| |
| /** |
| * Gets the maximum supported render target size. |
| */ |
| using GrRecordingContext::maxRenderTargetSize; |
| |
| /** |
| * Can a SkImage be created with the given color type. |
| */ |
| using GrRecordingContext::colorTypeSupportedAsImage; |
| |
| /** |
| * Can a SkSurface be created with the given color type. To check whether MSAA is supported |
| * use maxSurfaceSampleCountForColorType(). |
| */ |
| using GrRecordingContext::colorTypeSupportedAsSurface; |
| |
| /** |
| * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA |
| * rendering is supported for the color type. 0 is returned if rendering to this color type |
| * is not supported at all. |
| */ |
| using GrRecordingContext::maxSurfaceSampleCountForColorType; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // Misc. |
| |
| /** |
| * Inserts a list of GPU semaphores that the current GPU-backed API must wait on before |
| * executing any more commands on the GPU. If this call returns false, then the GPU back-end |
| * will not wait on any passed in semaphores, and the client will still own the semaphores, |
| * regardless of the value of deleteSemaphoresAfterWait. |
| * |
| * If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case |
| * it is the client's responsibility to not destroy or attempt to reuse the semaphores until it |
| * knows that Skia has finished waiting on them. This can be done by using finishedProcs on |
| * flush calls. |
| */ |
| bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores, |
| bool deleteSemaphoresAfterWait = true); |
| |
| /** |
| * Call to ensure all drawing to the context has been flushed and submitted to the underlying 3D |
| * API. This is equivalent to calling GrContext::flush with a default GrFlushInfo followed by |
| * GrContext::submit(syncCpu). |
| */ |
| void flushAndSubmit(bool syncCpu = false) { |
| this->flush(GrFlushInfo()); |
| this->submit(syncCpu); |
| } |
| |
| /** |
| * Call to ensure all drawing to the context has been flushed to underlying 3D API specific |
| * objects. A call to `submit` is always required to ensure work is actually sent to |
| * the gpu. Some specific API details: |
| * GL: Commands are actually sent to the driver, but glFlush is never called. Thus some |
| * sync objects from the flush will not be valid until a submission occurs. |
| * |
| * Vulkan/Metal/D3D/Dawn: Commands are recorded to the backend APIs corresponding command |
| * buffer or encoder objects. However, these objects are not sent to the gpu until a |
| * submission occurs. |
| * |
| * If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be |
| * submitted to the gpu during the next submit call (it is possible Skia failed to create a |
| * subset of the semaphores). The client should not wait on these semaphores until after submit |
| * has been called, and must keep them alive until then. If this call returns |
| * GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on |
| * the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with |
| * the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the |
| * client is still responsible for deleting any initialized semaphores. |
| * Regardleess of semaphore submission the context will still be flushed. It should be |
| * emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not |
| * happen. It simply means there were no semaphores submitted to the GPU. A caller should only |
| * take this as a failure if they passed in semaphores to be submitted. |
| */ |
| GrSemaphoresSubmitted flush(const GrFlushInfo& info); |
| |
| void flush() { this->flush({}); } |
| |
| /** |
| * Submit outstanding work to the gpu from all previously un-submitted flushes. The return |
| * value of the submit will indicate whether or not the submission to the GPU was successful. |
| * |
| * If the call returns true, all previously passed in semaphores in flush calls will have been |
| * submitted to the GPU and they can safely be waited on. The caller should wait on those |
| * semaphores or perform some other global synchronization before deleting the semaphores. |
| * |
| * If it returns false, then those same semaphores will not have been submitted and we will not |
| * try to submit them again. The caller is free to delete the semaphores at any time. |
| * |
| * If the syncCpu flag is true this function will return once the gpu has finished with all |
| * submitted work. |
| */ |
| bool submit(bool syncCpu = false); |
| |
| /** |
| * Checks whether any asynchronous work is complete and if so calls related callbacks. |
| */ |
| void checkAsyncWorkCompletion(); |
| |
| /** Enumerates all cached GPU resources and dumps their memory to traceMemoryDump. */ |
| // Chrome is using this! |
| void dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const; |
| |
| bool supportsDistanceFieldText() const; |
| |
| void storeVkPipelineCacheData(); |
| |
| /** |
| * Retrieve the default GrBackendFormat for a given SkColorType and renderability. |
| * It is guaranteed that this backend format will be the one used by the following |
| * SkColorType and SkSurfaceCharacterization-based createBackendTexture methods. |
| * |
| * The caller should check that the returned format is valid. |
| */ |
| using GrRecordingContext::defaultBackendFormat; |
| |
| /** |
| * The explicitly allocated backend texture API allows clients to use Skia to create backend |
| * objects outside of Skia proper (i.e., Skia's caching system will not know about them.) |
| * |
| * It is the client's responsibility to delete all these objects (using deleteBackendTexture) |
| * before deleting the context used to create them. If the backend is Vulkan, the textures must |
| * be deleted before abandoning the context as well. Additionally, clients should only delete |
| * these objects on the thread for which that context is active. |
| * |
| * The client is responsible for ensuring synchronization between different uses |
| * of the backend object (i.e., wrapping it in a surface, rendering to it, deleting the |
| * surface, rewrapping it in a image and drawing the image will require explicit |
| * synchronization on the client's part). |
| */ |
| |
| /** |
| * If possible, create an uninitialized backend texture. The client should ensure that the |
| * returned backend texture is valid. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_UNDEFINED. |
| */ |
| GrBackendTexture createBackendTexture(int width, |
| int height, |
| const GrBackendFormat&, |
| GrMipmapped, |
| GrRenderable, |
| GrProtected = GrProtected::kNo, |
| std::string_view label = {}); |
| |
| /** |
| * If possible, create an uninitialized backend texture. The client should ensure that the |
| * returned backend texture is valid. |
| * If successful, the created backend texture will be compatible with the provided |
| * SkColorType. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_UNDEFINED. |
| */ |
| GrBackendTexture createBackendTexture(int width, int height, |
| SkColorType, |
| GrMipmapped, |
| GrRenderable, |
| GrProtected = GrProtected::kNo, |
| std::string_view label = {}); |
| |
| /** |
| * If possible, create a backend texture initialized to a particular color. The client should |
| * ensure that the returned backend texture is valid. The client can pass in a finishedProc |
| * to be notified when the data has been uploaded by the gpu and the texture can be deleted. The |
| * client is required to call `submit` to send the upload work to the gpu. The |
| * finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| GrBackendTexture createBackendTexture(int width, int height, |
| const GrBackendFormat&, |
| const SkColor4f& color, |
| GrMipmapped, |
| GrRenderable, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}); |
| |
| /** |
| * If possible, create a backend texture initialized to a particular color. The client should |
| * ensure that the returned backend texture is valid. The client can pass in a finishedProc |
| * to be notified when the data has been uploaded by the gpu and the texture can be deleted. The |
| * client is required to call `submit` to send the upload work to the gpu. The |
| * finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * If successful, the created backend texture will be compatible with the provided |
| * SkColorType. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| GrBackendTexture createBackendTexture(int width, int height, |
| SkColorType, |
| const SkColor4f& color, |
| GrMipmapped, |
| GrRenderable, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}); |
| |
| /** |
| * If possible, create a backend texture initialized with the provided pixmap data. The client |
| * should ensure that the returned backend texture is valid. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * If successful, the created backend texture will be compatible with the provided |
| * pixmap(s). Compatible, in this case, means that the backend format will be the result |
| * of calling defaultBackendFormat on the base pixmap's colortype. The src data can be deleted |
| * when this call returns. |
| * If numLevels is 1 a non-mipmapped texture will result. If a mipmapped texture is desired |
| * the data for all the mipmap levels must be provided. In the mipmapped case all the |
| * colortypes of the provided pixmaps must be the same. Additionally, all the miplevels |
| * must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). The |
| * GrSurfaceOrigin controls whether the pixmap data is vertically flipped in the texture. |
| * Note: the pixmap's alphatypes and colorspaces are ignored. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| GrBackendTexture createBackendTexture(const SkPixmap srcData[], |
| int numLevels, |
| GrSurfaceOrigin, |
| GrRenderable, |
| GrProtected, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}); |
| |
| /** |
| * Convenience version createBackendTexture() that takes just a base level pixmap. |
| */ |
| GrBackendTexture createBackendTexture(const SkPixmap& srcData, |
| GrSurfaceOrigin textureOrigin, |
| GrRenderable renderable, |
| GrProtected isProtected, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}) { |
| return this->createBackendTexture(&srcData, 1, textureOrigin, renderable, isProtected, |
| finishedProc, finishedContext, label); |
| } |
| |
| // Deprecated versions that do not take origin and assume top-left. |
| GrBackendTexture createBackendTexture(const SkPixmap srcData[], |
| int numLevels, |
| GrRenderable renderable, |
| GrProtected isProtected, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}) { |
| return this->createBackendTexture(srcData, |
| numLevels, |
| kTopLeft_GrSurfaceOrigin, |
| renderable, |
| isProtected, |
| finishedProc, |
| finishedContext, |
| label); |
| } |
| GrBackendTexture createBackendTexture(const SkPixmap& srcData, |
| GrRenderable renderable, |
| GrProtected isProtected, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr, |
| std::string_view label = {}) { |
| return this->createBackendTexture(&srcData, |
| 1, |
| renderable, |
| isProtected, |
| finishedProc, |
| finishedContext, |
| label); |
| } |
| |
| /** |
| * If possible, updates a backend texture to be filled to a particular color. The client should |
| * check the return value to see if the update was successful. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to update the GrBackendTexture. |
| * For the Vulkan backend after a successful update the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| bool updateBackendTexture(const GrBackendTexture&, |
| const SkColor4f& color, |
| GrGpuFinishedProc finishedProc, |
| GrGpuFinishedContext finishedContext); |
| |
| /** |
| * If possible, updates a backend texture to be filled to a particular color. The data in |
| * GrBackendTexture and passed in color is interpreted with respect to the passed in |
| * SkColorType. The client should check the return value to see if the update was successful. |
| * The client can pass in a finishedProc to be notified when the data has been uploaded by the |
| * gpu and the texture can be deleted. The client is required to call `submit` to send |
| * the upload work to the gpu. The finishedProc will always get called even if we failed to |
| * update the GrBackendTexture. |
| * For the Vulkan backend after a successful update the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| bool updateBackendTexture(const GrBackendTexture&, |
| SkColorType skColorType, |
| const SkColor4f& color, |
| GrGpuFinishedProc finishedProc, |
| GrGpuFinishedContext finishedContext); |
| |
| /** |
| * If possible, updates a backend texture filled with the provided pixmap data. The client |
| * should check the return value to see if the update was successful. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * The backend texture must be compatible with the provided pixmap(s). Compatible, in this case, |
| * means that the backend format is compatible with the base pixmap's colortype. The src data |
| * can be deleted when this call returns. |
| * If the backend texture is mip mapped, the data for all the mipmap levels must be provided. |
| * In the mipmapped case all the colortypes of the provided pixmaps must be the same. |
| * Additionally, all the miplevels must be sized correctly (please see |
| * SkMipmap::ComputeLevelSize and ComputeLevelCount). The GrSurfaceOrigin controls whether the |
| * pixmap data is vertically flipped in the texture. |
| * Note: the pixmap's alphatypes and colorspaces are ignored. |
| * For the Vulkan backend after a successful update the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| bool updateBackendTexture(const GrBackendTexture&, |
| const SkPixmap srcData[], |
| int numLevels, |
| GrSurfaceOrigin = kTopLeft_GrSurfaceOrigin, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| /** |
| * Convenience version of updateBackendTexture that takes just a base level pixmap. |
| */ |
| bool updateBackendTexture(const GrBackendTexture& texture, |
| const SkPixmap& srcData, |
| GrSurfaceOrigin textureOrigin = kTopLeft_GrSurfaceOrigin, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr) { |
| return this->updateBackendTexture(texture, |
| &srcData, |
| 1, |
| textureOrigin, |
| finishedProc, |
| finishedContext); |
| } |
| |
| // Deprecated version that does not take origin and assumes top-left. |
| bool updateBackendTexture(const GrBackendTexture& texture, |
| const SkPixmap srcData[], |
| int numLevels, |
| GrGpuFinishedProc finishedProc, |
| GrGpuFinishedContext finishedContext) { |
| return this->updateBackendTexture(texture, |
| srcData, |
| numLevels, |
| kTopLeft_GrSurfaceOrigin, |
| finishedProc, |
| finishedContext); |
| } |
| |
| /** |
| * Retrieve the GrBackendFormat for a given SkImage::CompressionType. This is |
| * guaranteed to match the backend format used by the following |
| * createCompressedBackendTexture methods that take a CompressionType. |
| * |
| * The caller should check that the returned format is valid. |
| */ |
| using GrRecordingContext::compressedBackendFormat; |
| |
| /** |
| *If possible, create a compressed backend texture initialized to a particular color. The |
| * client should ensure that the returned backend texture is valid. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| GrBackendTexture createCompressedBackendTexture(int width, int height, |
| const GrBackendFormat&, |
| const SkColor4f& color, |
| GrMipmapped, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| GrBackendTexture createCompressedBackendTexture(int width, int height, |
| SkImage::CompressionType, |
| const SkColor4f& color, |
| GrMipmapped, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| /** |
| * If possible, create a backend texture initialized with the provided raw data. The client |
| * should ensure that the returned backend texture is valid. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture |
| * If numLevels is 1 a non-mipmapped texture will result. If a mipmapped texture is desired |
| * the data for all the mipmap levels must be provided. Additionally, all the miplevels |
| * must be sized correctly (please see SkMipmap::ComputeLevelSize and ComputeLevelCount). |
| * For the Vulkan backend the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| GrBackendTexture createCompressedBackendTexture(int width, int height, |
| const GrBackendFormat&, |
| const void* data, size_t dataSize, |
| GrMipmapped, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| GrBackendTexture createCompressedBackendTexture(int width, int height, |
| SkImage::CompressionType, |
| const void* data, size_t dataSize, |
| GrMipmapped, |
| GrProtected = GrProtected::kNo, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| /** |
| * If possible, updates a backend texture filled with the provided color. If the texture is |
| * mipmapped, all levels of the mip chain will be updated to have the supplied color. The client |
| * should check the return value to see if the update was successful. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * For the Vulkan backend after a successful update the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| bool updateCompressedBackendTexture(const GrBackendTexture&, |
| const SkColor4f& color, |
| GrGpuFinishedProc finishedProc, |
| GrGpuFinishedContext finishedContext); |
| |
| /** |
| * If possible, updates a backend texture filled with the provided raw data. The client |
| * should check the return value to see if the update was successful. The client can pass in a |
| * finishedProc to be notified when the data has been uploaded by the gpu and the texture can be |
| * deleted. The client is required to call `submit` to send the upload work to the gpu. |
| * The finishedProc will always get called even if we failed to create the GrBackendTexture. |
| * If a mipmapped texture is passed in, the data for all the mipmap levels must be provided. |
| * Additionally, all the miplevels must be sized correctly (please see |
| * SkMipMap::ComputeLevelSize and ComputeLevelCount). |
| * For the Vulkan backend after a successful update the layout of the created VkImage will be: |
| * VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL |
| */ |
| bool updateCompressedBackendTexture(const GrBackendTexture&, |
| const void* data, |
| size_t dataSize, |
| GrGpuFinishedProc finishedProc, |
| GrGpuFinishedContext finishedContext); |
| |
| /** |
| * Updates the state of the GrBackendTexture/RenderTarget to have the passed in |
| * skgpu::MutableTextureState. All objects that wrap the backend surface (i.e. SkSurfaces and |
| * SkImages) will also be aware of this state change. This call does not submit the state change |
| * to the gpu, but requires the client to call `submit` to send it to the GPU. The work |
| * for this call is ordered linearly with all other calls that require GrContext::submit to be |
| * called (e.g updateBackendTexture and flush). If finishedProc is not null then it will be |
| * called with finishedContext after the state transition is known to have occurred on the GPU. |
| * |
| * See skgpu::MutableTextureState to see what state can be set via this call. |
| * |
| * If the backend API is Vulkan, the caller can set the skgpu::MutableTextureState's |
| * VkImageLayout to VK_IMAGE_LAYOUT_UNDEFINED or queueFamilyIndex to VK_QUEUE_FAMILY_IGNORED to |
| * tell Skia to not change those respective states. |
| * |
| * If previousState is not null and this returns true, then Skia will have filled in |
| * previousState to have the values of the state before this call. |
| */ |
| bool setBackendTextureState(const GrBackendTexture&, |
| const skgpu::MutableTextureState&, |
| skgpu::MutableTextureState* previousState = nullptr, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| bool setBackendRenderTargetState(const GrBackendRenderTarget&, |
| const skgpu::MutableTextureState&, |
| skgpu::MutableTextureState* previousState = nullptr, |
| GrGpuFinishedProc finishedProc = nullptr, |
| GrGpuFinishedContext finishedContext = nullptr); |
| |
| void deleteBackendTexture(GrBackendTexture); |
| |
| // This interface allows clients to pre-compile shaders and populate the runtime program cache. |
| // The key and data blobs should be the ones passed to the PersistentCache, in SkSL format. |
| // |
| // Steps to use this API: |
| // |
| // 1) Create a GrDirectContext as normal, but set fPersistentCache on GrContextOptions to |
| // something that will save the cached shader blobs. Set fShaderCacheStrategy to kSkSL. This |
| // will ensure that the blobs are SkSL, and are suitable for pre-compilation. |
| // 2) Run your application, and save all of the key/data pairs that are fed to the cache. |
| // |
| // 3) Switch over to shipping your application. Include the key/data pairs from above. |
| // 4) At startup (or any convenient time), call precompileShader for each key/data pair. |
| // This will compile the SkSL to create a GL program, and populate the runtime cache. |
| // |
| // This is only guaranteed to work if the context/device used in step #2 are created in the |
| // same way as the one used in step #4, and the same GrContextOptions are specified. |
| // Using cached shader blobs on a different device or driver are undefined. |
| bool precompileShader(const SkData& key, const SkData& data); |
| |
| #ifdef SK_ENABLE_DUMP_GPU |
| /** Returns a string with detailed information about the context & GPU, in JSON format. */ |
| SkString dump() const; |
| #endif |
| |
| class DirectContextID { |
| public: |
| static GrDirectContext::DirectContextID Next(); |
| |
| DirectContextID() : fID(SK_InvalidUniqueID) {} |
| |
| bool operator==(const DirectContextID& that) const { return fID == that.fID; } |
| bool operator!=(const DirectContextID& that) const { return !(*this == that); } |
| |
| void makeInvalid() { fID = SK_InvalidUniqueID; } |
| bool isValid() const { return fID != SK_InvalidUniqueID; } |
| |
| private: |
| constexpr DirectContextID(uint32_t id) : fID(id) {} |
| uint32_t fID; |
| }; |
| |
| DirectContextID directContextID() const { return fDirectContextID; } |
| |
| // Provides access to functions that aren't part of the public API. |
| GrDirectContextPriv priv(); |
| const GrDirectContextPriv priv() const; // NOLINT(readability-const-return-type) |
| |
| protected: |
| GrDirectContext(GrBackendApi backend, const GrContextOptions& options); |
| |
| bool init() override; |
| |
| GrAtlasManager* onGetAtlasManager() { return fAtlasManager.get(); } |
| #if !defined(SK_ENABLE_OPTIMIZE_SIZE) |
| skgpu::v1::SmallPathAtlasMgr* onGetSmallPathAtlasMgr(); |
| #endif |
| |
| GrDirectContext* asDirectContext() override { return this; } |
| |
| private: |
| // This call will make sure out work on the GPU is finished and will execute any outstanding |
| // asynchronous work (e.g. calling finished procs, freeing resources, etc.) related to the |
| // outstanding work on the gpu. The main use currently for this function is when tearing down or |
| // abandoning the context. |
| // |
| // When we finish up work on the GPU it could trigger callbacks to the client. In the case we |
| // are abandoning the context we don't want the client to be able to use the GrDirectContext to |
| // issue more commands during the callback. Thus before calling this function we set the |
| // GrDirectContext's state to be abandoned. However, we need to be able to get by the abaonded |
| // check in the call to know that it is safe to execute this. The shouldExecuteWhileAbandoned |
| // bool is used for this signal. |
| void syncAllOutstandingGpuWork(bool shouldExecuteWhileAbandoned); |
| |
| const DirectContextID fDirectContextID; |
| // fTaskGroup must appear before anything that uses it (e.g. fGpu), so that it is destroyed |
| // after all of its users. Clients of fTaskGroup will generally want to ensure that they call |
| // wait() on it as they are being destroyed, to avoid the possibility of pending tasks being |
| // invoked after objects they depend upon have already been destroyed. |
| std::unique_ptr<SkTaskGroup> fTaskGroup; |
| std::unique_ptr<sktext::gpu::StrikeCache> fStrikeCache; |
| sk_sp<GrGpu> fGpu; |
| std::unique_ptr<GrResourceCache> fResourceCache; |
| std::unique_ptr<GrResourceProvider> fResourceProvider; |
| |
| // This is incremented before we start calling ReleaseProcs from GrSurfaces and decremented |
| // after. A ReleaseProc may trigger code causing another resource to get freed so we to track |
| // the count to know if we in a ReleaseProc at any level. When this is set to a value greated |
| // than zero we will not allow abandonContext calls to be made on the context. |
| int fInsideReleaseProcCnt = 0; |
| |
| bool fDidTestPMConversions; |
| // true if the PM/UPM conversion succeeded; false otherwise |
| bool fPMUPMConversionsRoundTrip; |
| |
| GrContextOptions::PersistentCache* fPersistentCache; |
| |
| std::unique_ptr<GrClientMappedBufferManager> fMappedBufferManager; |
| std::unique_ptr<GrAtlasManager> fAtlasManager; |
| |
| #if !defined(SK_ENABLE_OPTIMIZE_SIZE) |
| std::unique_ptr<skgpu::v1::SmallPathAtlasMgr> fSmallPathAtlasMgr; |
| #endif |
| |
| friend class GrDirectContextPriv; |
| |
| using INHERITED = GrRecordingContext; |
| }; |
| |
| |
| #endif |