OLD | NEW |
1 | 1 |
2 /* | 2 /* |
3 * Copyright 2011 Google Inc. | 3 * Copyright 2011 Google Inc. |
4 * | 4 * |
5 * Use of this source code is governed by a BSD-style license that can be | 5 * Use of this source code is governed by a BSD-style license that can be |
6 * found in the LICENSE file. | 6 * found in the LICENSE file. |
7 */ | 7 */ |
8 | 8 |
9 | 9 |
10 | 10 |
11 #ifndef GrResourceCache_DEFINED | 11 #ifndef GrResourceCache_DEFINED |
12 #define GrResourceCache_DEFINED | 12 #define GrResourceCache_DEFINED |
13 | 13 |
14 #include "GrConfig.h" | 14 #include "GrResourceKey.h" |
15 #include "GrTypes.h" | |
16 #include "SkTMultiMap.h" | 15 #include "SkTMultiMap.h" |
17 #include "GrBinHashKey.h" | |
18 #include "SkMessageBus.h" | 16 #include "SkMessageBus.h" |
19 #include "SkTInternalLList.h" | 17 #include "SkTInternalLList.h" |
20 | 18 |
21 class GrGpuResource; | 19 class GrGpuResource; |
22 class GrResourceCache; | 20 class GrResourceCache; |
23 class GrResourceCacheEntry; | 21 class GrResourceCacheEntry; |
24 | 22 |
25 class GrResourceKey { | |
26 public: | |
27 static GrCacheID::Domain ScratchDomain() { | |
28 static const GrCacheID::Domain gDomain = GrCacheID::GenerateDomain(); | |
29 return gDomain; | |
30 } | |
31 | |
32 /** Uniquely identifies the GrGpuResource subclass in the key to avoid colli
sions | |
33 across resource types. */ | |
34 typedef uint8_t ResourceType; | |
35 | |
36 /** Flags set by the GrGpuResource subclass. */ | |
37 typedef uint8_t ResourceFlags; | |
38 | |
39 /** Generate a unique ResourceType */ | |
40 static ResourceType GenerateResourceType(); | |
41 | |
42 /** Creates a key for resource */ | |
43 GrResourceKey(const GrCacheID& id, ResourceType type, ResourceFlags flags) { | |
44 this->init(id.getDomain(), id.getKey(), type, flags); | |
45 }; | |
46 | |
47 GrResourceKey(const GrResourceKey& src) { | |
48 fKey = src.fKey; | |
49 } | |
50 | |
51 GrResourceKey() { | |
52 fKey.reset(); | |
53 } | |
54 | |
55 void reset(const GrCacheID& id, ResourceType type, ResourceFlags flags) { | |
56 this->init(id.getDomain(), id.getKey(), type, flags); | |
57 } | |
58 | |
59 uint32_t getHash() const { | |
60 return fKey.getHash(); | |
61 } | |
62 | |
63 bool isScratch() const { | |
64 return ScratchDomain() == | |
65 *reinterpret_cast<const GrCacheID::Domain*>(fKey.getData() + | |
66 kCacheIDDomainOffset); | |
67 } | |
68 | |
69 ResourceType getResourceType() const { | |
70 return *reinterpret_cast<const ResourceType*>(fKey.getData() + | |
71 kResourceTypeOffset); | |
72 } | |
73 | |
74 ResourceFlags getResourceFlags() const { | |
75 return *reinterpret_cast<const ResourceFlags*>(fKey.getData() + | |
76 kResourceFlagsOffset); | |
77 } | |
78 | |
79 bool operator==(const GrResourceKey& other) const { return fKey == other.fKe
y; } | |
80 | |
81 private: | |
82 enum { | |
83 kCacheIDKeyOffset = 0, | |
84 kCacheIDDomainOffset = kCacheIDKeyOffset + sizeof(GrCacheID::Key), | |
85 kResourceTypeOffset = kCacheIDDomainOffset + sizeof(GrCacheID::Domain), | |
86 kResourceFlagsOffset = kResourceTypeOffset + sizeof(ResourceType), | |
87 kPadOffset = kResourceFlagsOffset + sizeof(ResourceFlags), | |
88 kKeySize = SkAlign4(kPadOffset), | |
89 kPadSize = kKeySize - kPadOffset | |
90 }; | |
91 | |
92 void init(const GrCacheID::Domain domain, | |
93 const GrCacheID::Key& key, | |
94 ResourceType type, | |
95 ResourceFlags flags) { | |
96 union { | |
97 uint8_t fKey8[kKeySize]; | |
98 uint32_t fKey32[kKeySize / 4]; | |
99 } keyData; | |
100 | |
101 uint8_t* k = keyData.fKey8; | |
102 memcpy(k + kCacheIDKeyOffset, key.fData8, sizeof(GrCacheID::Key)); | |
103 memcpy(k + kCacheIDDomainOffset, &domain, sizeof(GrCacheID::Domain)); | |
104 memcpy(k + kResourceTypeOffset, &type, sizeof(ResourceType)); | |
105 memcpy(k + kResourceFlagsOffset, &flags, sizeof(ResourceFlags)); | |
106 memset(k + kPadOffset, 0, kPadSize); | |
107 fKey.setKeyData(keyData.fKey32); | |
108 } | |
109 GrBinHashKey<kKeySize> fKey; | |
110 }; | |
111 | 23 |
112 // The cache listens for these messages to purge junk resources proactively. | 24 // The cache listens for these messages to purge junk resources proactively. |
113 struct GrResourceInvalidatedMessage { | 25 struct GrResourceInvalidatedMessage { |
114 GrResourceKey key; | 26 GrResourceKey key; |
115 }; | 27 }; |
116 | 28 |
117 /////////////////////////////////////////////////////////////////////////////// | 29 /////////////////////////////////////////////////////////////////////////////// |
118 | 30 |
119 class GrResourceCacheEntry { | 31 class GrResourceCacheEntry { |
120 public: | 32 public: |
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
395 GrResourceCache* fCache; | 307 GrResourceCache* fCache; |
396 }; | 308 }; |
397 #else | 309 #else |
398 class GrAutoResourceCacheValidate { | 310 class GrAutoResourceCacheValidate { |
399 public: | 311 public: |
400 GrAutoResourceCacheValidate(GrResourceCache*) {} | 312 GrAutoResourceCacheValidate(GrResourceCache*) {} |
401 }; | 313 }; |
402 #endif | 314 #endif |
403 | 315 |
404 #endif | 316 #endif |
OLD | NEW |