9 #ifndef GrResourceKey_DEFINED
10 #define GrResourceKey_DEFINED
12 #include "../private/SkTemplates.h"
15 #include "../private/SkOnce.h"
17 uint32_t GrResourceKeyHash(
const uint32_t* data,
size_t size);
25 uint32_t hash()
const {
27 return fKey[kHash_MetaDataIdx];
32 SkASSERT(this->isValid());
33 return this->internalSize();
37 static const uint32_t kInvalidDomain = 0;
43 GR_STATIC_ASSERT((uint16_t)kInvalidDomain == kInvalidDomain);
44 fKey.reset(kMetaDataCnt);
45 fKey[kHash_MetaDataIdx] = 0;
46 fKey[kDomainAndSize_MetaDataIdx] = kInvalidDomain;
50 return this->hash() == that.hash() &&
51 0 == memcmp(&fKey[kHash_MetaDataIdx + 1],
52 &that.fKey[kHash_MetaDataIdx + 1],
53 this->internalSize() -
sizeof(uint32_t));
57 SkASSERT(that.isValid());
59 size_t bytes = that.size();
60 SkASSERT(SkIsAlign4(bytes));
61 fKey.reset(SkToInt(bytes /
sizeof(uint32_t)));
62 memcpy(fKey.get(), that.fKey.get(), bytes);
68 bool isValid()
const {
return kInvalidDomain != this->domain(); }
70 uint32_t domain()
const {
return fKey[kDomainAndSize_MetaDataIdx] & 0xffff; }
73 size_t dataSize()
const {
return this->size() - 4 * kMetaDataCnt; }
76 const uint32_t*
data()
const {
78 return &fKey[kMetaDataCnt];
85 SkASSERT(data32Count >= 0);
86 SkASSERT(domain != kInvalidDomain);
87 key->fKey.reset(kMetaDataCnt + data32Count);
88 int size = (data32Count + kMetaDataCnt) *
sizeof(uint32_t);
89 SkASSERT(SkToU16(size) == size);
90 SkASSERT(SkToU16(domain) == domain);
91 key->fKey[kDomainAndSize_MetaDataIdx] = domain | (size << 16);
100 GR_STATIC_ASSERT(0 == kHash_MetaDataIdx);
101 uint32_t* hash = &fKey->fKey[kHash_MetaDataIdx];
102 *hash = GrResourceKeyHash(hash + 1, fKey->internalSize() -
sizeof(uint32_t));
107 uint32_t& operator[](
int dataIdx) {
109 SkDEBUGCODE(
size_t dataCount = fKey->internalSize() /
sizeof(uint32_t) - kMetaDataCnt;)
110 SkASSERT(SkToU32(dataIdx) < dataCount);
111 return fKey->fKey[kMetaDataCnt + dataIdx];
122 kDomainAndSize_MetaDataIdx,
124 kLastMetaDataIdx = kDomainAndSize_MetaDataIdx
126 static const uint32_t kMetaDataCnt = kLastMetaDataIdx + 1;
128 size_t internalSize()
const {
129 return fKey[kDomainAndSize_MetaDataIdx] >> 16;
132 void validate()
const {
133 SkASSERT(fKey[kHash_MetaDataIdx] ==
134 GrResourceKeyHash(&fKey[kHash_MetaDataIdx] + 1,
135 this->internalSize() -
sizeof(uint32_t)));
136 SkASSERT(SkIsAlign4(this->internalSize()));
139 friend class TestResource;
142 SkAutoSTMalloc<kMetaDataCnt + 5, uint32_t> fKey;
185 using INHERITED::isValid;
187 ResourceType resourceType()
const {
return this->domain(); }
190 this->INHERITED::operator=(that);
195 return this->INHERITED::operator==(that);
197 bool operator!=(
const GrScratchKey& that)
const {
return !(*
this == that); }
225 typedef uint32_t Domain;
237 using INHERITED::isValid;
240 this->INHERITED::operator=(that);
241 this->setCustomData(sk_ref_sp(that.getCustomData()));
246 return this->INHERITED::operator==(that);
248 bool operator!=(
const GrUniqueKey& that)
const {
return !(*
this == that); }
251 fData = std::move(data);
253 SkData* getCustomData()
const {
265 :
INHERITED::
Builder(key, domain, Data32CntForInnerKey(innerKey) + extraData32Cnt) {
266 SkASSERT(&innerKey != key);
268 uint32_t* innerKeyData = &this->operator[](extraData32Cnt);
269 const uint32_t* srcData = innerKey.
data();
270 (*innerKeyData++) = innerKey.domain();
271 memcpy(innerKeyData, srcData, innerKey.
dataSize());
275 static int Data32CntForInnerKey(
const GrUniqueKey& innerKey) {
277 return SkToInt((innerKey.
dataSize() >> 2) + 1);
292 #define GR_DECLARE_STATIC_UNIQUE_KEY(name) static SkOnce name##_once
295 #define GR_DEFINE_STATIC_UNIQUE_KEY(name) \
296 static SkAlignedSTStorage<1, GrUniqueKey> name##_storage; \
297 name##_once(gr_init_static_unique_key_once, &name##_storage); \
298 static const GrUniqueKey& name = *reinterpret_cast<GrUniqueKey*>(name##_storage.get());
300 static inline void gr_init_static_unique_key_once(SkAlignedSTStorage<1,GrUniqueKey>* keyStorage) {
Definition: GrResourceKey.h:257
GrUniqueKey()
Creates an invalid unique key.
Definition: GrResourceKey.h:230
A key that allows for exclusive use of a resource for a use case (AKA "domain").
Definition: GrResourceKey.h:220
Used to initialize a key.
Definition: GrResourceKey.h:82
Builder(GrUniqueKey *key, const GrUniqueKey &innerKey, Domain domain, int extraData32Cnt)
Used to build a key that wraps another key and adds additional data.
Definition: GrResourceKey.h:263
const uint32_t * data() const
ptr to the key data, excluding meta-data (hash, domain, etc).
Definition: GrResourceKey.h:76
size_t dataSize() const
size of the key data, excluding meta-data (hash, domain, etc).
Definition: GrResourceKey.h:73
SkData holds an immutable data buffer.
Definition: SkData.h:22
static ResourceType GenerateResourceType()
Generate a unique ResourceType.
A key used for scratch resources.
Definition: GrResourceKey.h:166
void reset()
Reset to an invalid key.
Definition: GrResourceKey.h:42
Definition: GrResourceKey.h:306
Base class for all GrGpuResource cache keys.
Definition: GrResourceKey.h:23
uint32_t ResourceType
Uniquely identifies the type of resource that is cached as scratch.
Definition: GrResourceKey.h:172
static Domain GenerateDomain()
Generate a Domain for unique keys.
GrScratchKey()
Creates an invalid scratch key.
Definition: GrResourceKey.h:178
Definition: GrResourceKey.h:199