skia2/include/gpu/GrDirectContext.h
Greg Daniel a89b43092e Add syncing of gpu work before releasing resources in GrDirectContext teardowns.
As we start moving backends to tracking resources on command buffers by using
GrGpuResources, we need to make sure we don't release this resources from the
cache during teardown until they have finished on the gpu. Thus this CL adds
a way for the GrDirectContext to tell the GrGpu to finish all outstanding
work.

Bug: skia:11232
Change-Id: I953d89f514ad32f1d2c57279a670b336d7575ffe
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/361457
Commit-Queue: Greg Daniel <egdaniel@google.com>
Reviewed-by: Jim Van Verth <jvanverth@google.com>
Reviewed-by: Brian Salomon <bsalomon@google.com>
2021-01-29 20:35:53 +00:00

856 lines
44 KiB
C++

/*
* 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 GrSmallPathAtlasMgr;
class GrSurfaceDrawContext;
class GrResourceProvider;
class GrStrikeCache;
class GrSurfaceProxy;
class GrSwizzle;
class GrTextureProxy;
struct GrVkBackendContext;
class SkImage;
class SkString;
class SkSurfaceCharacterization;
class SkSurfaceProps;
class SkTaskGroup;
class SkTraceMemoryDump;
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.
*
* 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.
*/
void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
// 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();
// Returns the gpu memory size of the the texture that backs the passed in SkImage. Returns 0 if
// the SkImage is not texture backed. For external format textures this will also return 0 as we
// cannot determine the correct size.
static size_t ComputeImageSize(sk_sp<SkImage> image, GrMipmapped, bool useNextPow2 = false);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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);
/**
* 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) {
return this->createBackendTexture(&srcData, 1, textureOrigin, renderable, isProtected,
finishedProc, finishedContext);
}
// 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) {
return this->createBackendTexture(srcData,
numLevels,
kTopLeft_GrSurfaceOrigin,
renderable,
isProtected,
finishedProc,
finishedContext);
}
GrBackendTexture createBackendTexture(const SkPixmap& srcData,
GrRenderable renderable,
GrProtected isProtected,
GrGpuFinishedProc finishedProc = nullptr,
GrGpuFinishedContext finishedContext = nullptr) {
return this->createBackendTexture(&srcData,
1,
renderable,
isProtected,
finishedProc,
finishedContext);
}
/**
* 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
* GrBackendSurfaceMutableState. 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 GrBackendSurfaceMutableState to see what state can be set via this call.
*
* If the backend API is Vulkan, the caller can set the GrBackendSurfaceMutableState'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 GrBackendSurfaceMutableState&,
GrBackendSurfaceMutableState* previousState = nullptr,
GrGpuFinishedProc finishedProc = nullptr,
GrGpuFinishedContext finishedContext = nullptr);
bool setBackendRenderTargetState(const GrBackendRenderTarget&,
const GrBackendSurfaceMutableState&,
GrBackendSurfaceMutableState* 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
// 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(); }
GrSmallPathAtlasMgr* onGetSmallPathAtlasMgr();
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);
// 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<GrStrikeCache> fStrikeCache;
sk_sp<GrGpu> fGpu;
std::unique_ptr<GrResourceCache> fResourceCache;
std::unique_ptr<GrResourceProvider> fResourceProvider;
bool fDidTestPMConversions;
// true if the PM/UPM conversion succeeded; false otherwise
bool fPMUPMConversionsRoundTrip;
GrContextOptions::PersistentCache* fPersistentCache;
GrContextOptions::ShaderErrorHandler* fShaderErrorHandler;
std::unique_ptr<GrClientMappedBufferManager> fMappedBufferManager;
std::unique_ptr<GrAtlasManager> fAtlasManager;
std::unique_ptr<GrSmallPathAtlasMgr> fSmallPathAtlasMgr;
friend class GrDirectContextPriv;
using INHERITED = GrRecordingContext;
};
#endif