blob: 14a4b5eb064ac317729f258b86b1d901f936cfef [file] [log] [blame]
/*
* Copyright 2016 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrTextureProxy_DEFINED
#define GrTextureProxy_DEFINED
#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GpuTypes.h"
#include "include/private/base/SkDebug.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ResourceKey.h"
#include "src/gpu/ganesh/GrSurface.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include <cstddef>
#include <memory>
#include <string_view>
class GrBackendFormat;
class GrDeferredProxyUploader;
class GrProxyProvider;
class GrResourceProvider;
class GrTextureProxyPriv;
enum class SkBackingFit;
struct SkISize;
// This class delays the acquisition of textures until they are actually required
class GrTextureProxy : virtual public GrSurfaceProxy {
public:
GrTextureProxy* asTextureProxy() override { return this; }
const GrTextureProxy* asTextureProxy() const override { return this; }
// Actually instantiate the backing texture, if necessary
bool instantiate(GrResourceProvider*) override;
// If we are instantiated and have a target, return the mip state of that target. Otherwise
// returns the proxy's mip state from creation time. This is useful for lazy proxies which may
// claim to not need mips at creation time, but the instantiation happens to give us a mipped
// target. In that case we should use that for our benefit to avoid possible copies/mip
// generation later.
skgpu::Mipmapped mipmapped() const;
bool mipmapsAreDirty() const {
SkASSERT((skgpu::Mipmapped::kNo == fMipmapped) ==
(GrMipmapStatus::kNotAllocated == fMipmapStatus));
return skgpu::Mipmapped::kYes == fMipmapped && GrMipmapStatus::kValid != fMipmapStatus;
}
void markMipmapsDirty() {
SkASSERT(skgpu::Mipmapped::kYes == fMipmapped);
fMipmapStatus = GrMipmapStatus::kDirty;
}
void markMipmapsClean() {
SkASSERT(skgpu::Mipmapped::kYes == fMipmapped);
fMipmapStatus = GrMipmapStatus::kValid;
}
// Returns the skgpu::Mipmapped value of the proxy from creation time regardless of whether it has
// been instantiated or not.
skgpu::Mipmapped proxyMipmapped() const { return fMipmapped; }
GrTextureType textureType() const;
/** If true then the texture does not support MIP maps and only supports clamp wrap mode. */
bool hasRestrictedSampling() const {
return GrTextureTypeHasRestrictedSampling(this->textureType());
}
// Returns true if the passed in proxies can be used as dynamic state together when flushing
// draws to the gpu. This accepts GrSurfaceProxy since the information needed is defined on
// that type, but this function exists in GrTextureProxy because it's only relevant when the
// proxies are being used as textures.
static bool ProxiesAreCompatibleAsDynamicState(const GrSurfaceProxy* first,
const GrSurfaceProxy* second);
/**
* Return the texture proxy's unique key. It will be invalid if the proxy doesn't have one.
*/
const skgpu::UniqueKey& getUniqueKey() const override {
#ifdef SK_DEBUG
if (this->isInstantiated() && fUniqueKey.isValid() && fSyncTargetKey &&
fCreatingProvider == GrDDLProvider::kNo) {
GrSurface* surface = this->peekSurface();
SkASSERT(surface);
SkASSERT(surface->getUniqueKey().isValid());
// It is possible for a non-keyed proxy to have a uniquely keyed resource assigned to
// it. This just means that a future user of the resource will be filling it with unique
// data. However, if the proxy has a unique key its attached resource should also
// have that key.
SkASSERT(fUniqueKey == surface->getUniqueKey());
}
#endif
return fUniqueKey;
}
/**
* Internal-only helper class used for manipulations of the resource by the cache.
*/
class CacheAccess;
inline CacheAccess cacheAccess();
inline const CacheAccess cacheAccess() const; // NOLINT(readability-const-return-type)
// Provides access to special purpose functions.
GrTextureProxyPriv texPriv();
const GrTextureProxyPriv texPriv() const; // NOLINT(readability-const-return-type)
SkDEBUGCODE(GrDDLProvider creatingProvider() const { return fCreatingProvider; })
protected:
// DDL TODO: rm the GrSurfaceProxy friending
friend class GrSurfaceProxy; // for ctors
friend class GrProxyProvider; // for ctors
friend class GrTextureProxyPriv;
friend class GrSurfaceProxyPriv; // ability to change key sync state after lazy instantiation.
// Deferred version - no data.
GrTextureProxy(const GrBackendFormat&,
SkISize,
skgpu::Mipmapped,
GrMipmapStatus,
SkBackingFit,
skgpu::Budgeted,
skgpu::Protected,
GrInternalSurfaceFlags,
UseAllocator,
GrDDLProvider creatingProvider,
std::string_view label);
// Lazy-callback version
// There are two main use cases for lazily-instantiated proxies:
// basic knowledge - width, height, config, origin are known
// minimal knowledge - only config is known.
//
// The basic knowledge version is used for DDL where we know the type of proxy we are going to
// use, but we don't have access to the GPU yet to instantiate it.
//
// The minimal knowledge version is used for when we are generating an atlas but we do not know
// the final size until we have finished adding to it.
GrTextureProxy(LazyInstantiateCallback&&,
const GrBackendFormat&,
SkISize,
skgpu::Mipmapped,
GrMipmapStatus,
SkBackingFit,
skgpu::Budgeted,
skgpu::Protected,
GrInternalSurfaceFlags,
UseAllocator,
GrDDLProvider creatingProvider,
std::string_view label);
// Wrapped version
GrTextureProxy(sk_sp<GrSurface>,
UseAllocator,
GrDDLProvider creatingProvider);
~GrTextureProxy() override;
sk_sp<GrSurface> createSurface(GrResourceProvider*) const override;
// By default uniqueKeys are propagated from a textureProxy to its backing GrTexture.
// Setting syncTargetKey to false disables this behavior and only keeps the unique key
// on the proxy.
void setTargetKeySync(bool sync) { fSyncTargetKey = sync; }
private:
// WARNING: Be careful when adding or removing fields here. ASAN is likely to trigger warnings
// when instantiating GrTextureRenderTargetProxy. The std::function in GrSurfaceProxy makes
// each class in the diamond require 16 byte alignment. Clang appears to layout the fields for
// each class to achieve the necessary alignment. However, ASAN checks the alignment of 'this'
// in the constructors, and always looks for the full 16 byte alignment, even if the fields in
// that particular class don't require it. Changing the size of this object can move the start
// address of other types, leading to this problem.
skgpu::Mipmapped fMipmapped;
// This tracks the mipmap status at the proxy level and is thus somewhat distinct from the
// backing GrTexture's mipmap status. In particular, this status is used to determine when
// mipmap levels need to be explicitly regenerated during the execution of a DAG of opsTasks.
GrMipmapStatus fMipmapStatus;
// TEMPORARY: We are in the process of moving GrMipmapStatus from the texture to the proxy.
// We track the fInitialMipmapStatus here so we can assert that the proxy did indeed expect
// the correct mipmap status immediately after instantiation.
//
// NOTE: fMipmapStatus may no longer be equal to fInitialMipmapStatus by the time the texture
// is instantiated, since it tracks mipmaps in the time frame in which the DAG is being built.
SkDEBUGCODE(const GrMipmapStatus fInitialMipmapStatus;)
bool fSyncTargetKey = true; // Should target's unique key be sync'ed with ours.
// For GrTextureProxies created in a DDL recording thread it is possible for the uniqueKey
// to be cleared on the backing GrTexture while the uniqueKey remains on the proxy.
// A fCreatingProvider of DDLProvider::kYes loosens up asserts that the key of an instantiated
// uniquely-keyed textureProxy is also always set on the backing GrTexture.
GrDDLProvider fCreatingProvider = GrDDLProvider::kNo;
skgpu::UniqueKey fUniqueKey;
GrProxyProvider* fProxyProvider; // only set when fUniqueKey is valid
LazySurfaceDesc callbackDesc() const override;
// Only used for proxies whose contents are being prepared on a worker thread. This object
// stores the texture data, allowing the proxy to remain uninstantiated until flush. At that
// point, the proxy is instantiated, and this data is used to perform an ASAP upload.
std::unique_ptr<GrDeferredProxyUploader> fDeferredUploader;
size_t onUninstantiatedGpuMemorySize() const override;
// Methods made available via GrTextureProxy::CacheAccess
void setUniqueKey(GrProxyProvider*, const skgpu::UniqueKey&);
void clearUniqueKey();
SkDEBUGCODE(void onValidateSurface(const GrSurface*) override;)
using INHERITED = GrSurfaceProxy;
};
#endif