blob: d6da45ad4c1ca223eb40a423f10b3f8a42081c52 [file] [log] [blame]
* Copyright 2021 Google LLC
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#ifndef skgpu_graphite_Context_DEFINED
#define skgpu_graphite_Context_DEFINED
#include "include/core/SkImage.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkShader.h"
#include "include/gpu/graphite/ContextOptions.h"
#include "include/gpu/graphite/GraphiteTypes.h"
#include "include/gpu/graphite/Recorder.h"
#include "include/private/base/SingleOwner.h"
#include <memory>
class SkRuntimeEffect;
namespace skgpu::graphite {
class BackendTexture;
class Buffer;
class ClientMappedBufferManager;
class Context;
class ContextPriv;
class GlobalCache;
class PaintOptions;
class PlotUploadTracker;
class QueueManager;
class Recording;
class ResourceProvider;
class SharedContext;
class TextureProxy;
class SK_API Context final {
Context(const Context&) = delete;
Context(Context&&) = delete;
Context& operator=(const Context&) = delete;
Context& operator=(Context&&) = delete;
BackendApi backend() const;
std::unique_ptr<Recorder> makeRecorder(const RecorderOptions& = {});
bool insertRecording(const InsertRecordingInfo&);
bool submit(SyncToCpu = SyncToCpu::kNo);
void asyncReadPixels(const SkImage* image,
const SkColorInfo& dstColorInfo,
const SkIRect& srcRect,
SkImage::ReadPixelsCallback callback,
SkImage::ReadPixelsContext context);
void asyncReadPixels(const SkSurface* surface,
const SkColorInfo& dstColorInfo,
const SkIRect& srcRect,
SkImage::ReadPixelsCallback callback,
SkImage::ReadPixelsContext context);
* Checks whether any asynchronous work is complete and if so calls related callbacks.
void checkAsyncWorkCompletion();
* Called to delete the passed in BackendTexture. This should only be called if the
* BackendTexture was created by calling Recorder::createBackendTexture on a Recorder created
* from this Context. If the BackendTexture is not valid or does not match the BackendApi of the
* Context then nothing happens.
* Otherwise this will delete/release the backend object that is wrapped in the BackendTexture.
* The BackendTexture will be reset to an invalid state and should not be used again.
void deleteBackendTexture(BackendTexture&);
// Provides access to functions that aren't part of the public API.
ContextPriv priv();
const ContextPriv priv() const; // NOLINT(readability-const-return-type)
class ContextID {
static Context::ContextID Next();
ContextID() : fID(SK_InvalidUniqueID) {}
bool operator==(const ContextID& that) const { return fID == that.fID; }
bool operator!=(const ContextID& that) const { return !(*this == that); }
void makeInvalid() { fID = SK_InvalidUniqueID; }
bool isValid() const { return fID != SK_InvalidUniqueID; }
constexpr ContextID(uint32_t id) : fID(id) {}
uint32_t fID;
ContextID contextID() const { return fContextID; }
Context(sk_sp<SharedContext>, std::unique_ptr<QueueManager>, const ContextOptions&);
friend class ContextPriv;
friend class ContextCtorAccessor;
SingleOwner* singleOwner() const { return &fSingleOwner; }
// Must be called in Make() to handle one-time GPU setup operations that can possibly fail and
// require Context::Make() to return a nullptr.
bool finishInitialization();
void asyncReadPixels(const TextureProxy* textureProxy,
const SkImageInfo& srcImageInfo,
const SkColorInfo& dstColorInfo,
const SkIRect& srcRect,
SkImage::ReadPixelsCallback callback,
SkImage::ReadPixelsContext context);
// Inserts a texture to buffer transfer task, used by asyncReadPixels methods
struct PixelTransferResult {
using ConversionFn = void(void* dst, const void* mappedBuffer);
// If null then the transfer could not be performed. Otherwise this buffer will contain
// the pixel data when the transfer is complete.
sk_sp<Buffer> fTransferBuffer;
// If this is null then the transfer buffer will contain the data in the requested
// color type. Otherwise, when the transfer is done this must be called to convert
// from the transfer buffer's color type to the requested color type.
std::function<ConversionFn> fPixelConverter;
PixelTransferResult transferPixels(const TextureProxy*,
const SkImageInfo& srcImageInfo,
const SkColorInfo& dstColorInfo,
const SkIRect& srcRect);
sk_sp<SharedContext> fSharedContext;
std::unique_ptr<ResourceProvider> fResourceProvider;
std::unique_ptr<QueueManager> fQueueManager;
std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
std::unique_ptr<PlotUploadTracker> fPlotUploadTracker;
// In debug builds we guard against improper thread handling. This guard is passed to the
// ResourceCache for the Context.
mutable SingleOwner fSingleOwner;
// In test builds a Recorder may track the Context that was used to create it.
bool fStoreContextRefInRecorder = false;
// If this tracking is on, to allow the client to safely delete this Context or its Recorders
// in any order we must also track the Recorders created here.
std::vector<Recorder*> fTrackedRecorders;
// Needed for MessageBox handling
const ContextID fContextID;
} // namespace skgpu::graphite
#endif // skgpu_graphite_Context_DEFINED