| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2012 Google Inc. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 #ifndef GrBackendEffectFactory_DEFINED | |
| 9 #define GrBackendEffectFactory_DEFINED | |
| 10 | |
| 11 #include "GrTypes.h" | |
| 12 #include "SkTemplates.h" | |
| 13 #include "SkThread.h" | |
| 14 #include "SkTypes.h" | |
| 15 #include "SkTArray.h" | |
| 16 | |
| 17 class GrGLEffect; | |
| 18 class GrGLCaps; | |
| 19 class GrEffect; | |
| 20 | |
| 21 /** | |
| 22 * Used by effects to build their keys. It incorporates each per-effect key into
a larger shader key. | |
| 23 */ | |
| 24 class GrEffectKeyBuilder { | |
| 25 public: | |
| 26 GrEffectKeyBuilder(SkTArray<unsigned char, true>* data) : fData(data), fCoun
t(0) { | |
| 27 SkASSERT(0 == fData->count() % sizeof(uint32_t)); | |
| 28 } | |
| 29 | |
| 30 void add32(uint32_t v) { | |
| 31 ++fCount; | |
| 32 fData->push_back_n(4, reinterpret_cast<uint8_t*>(&v)); | |
| 33 } | |
| 34 | |
| 35 /** Inserts count uint32_ts into the key. The returned pointer is only valid
until the next | |
| 36 add*() call. */ | |
| 37 uint32_t* SK_WARN_UNUSED_RESULT add32n(int count) { | |
| 38 SkASSERT(count > 0); | |
| 39 fCount += count; | |
| 40 return reinterpret_cast<uint32_t*>(fData->push_back_n(4 * count)); | |
| 41 } | |
| 42 | |
| 43 size_t size() const { return sizeof(uint32_t) * fCount; } | |
| 44 | |
| 45 private: | |
| 46 SkTArray<uint8_t, true>* fData; // unowned ptr to the larger key. | |
| 47 int fCount; // number of uint32_ts added to fData by the
effect. | |
| 48 }; | |
| 49 | |
| 50 /** | |
| 51 * This class is used to pass the key that was created for a GrGLEffect back to
it | |
| 52 * when it emits code. It may allow the emit step to skip calculations that were | |
| 53 * performed when computing the key. | |
| 54 */ | |
| 55 class GrEffectKey { | |
| 56 public: | |
| 57 GrEffectKey(const uint32_t* key, int count) : fKey(key), fCount(count) { | |
| 58 SkASSERT(0 == reinterpret_cast<intptr_t>(key) % sizeof(uint32_t)); | |
| 59 } | |
| 60 | |
| 61 /** Gets the uint32_t values that the effect inserted into the key. */ | |
| 62 uint32_t get32(int index) const { | |
| 63 SkASSERT(index >=0 && index < fCount); | |
| 64 return fKey[index]; | |
| 65 } | |
| 66 | |
| 67 /** Gets the number of uint32_t values that the effect inserted into the key
. */ | |
| 68 int count32() const { return fCount; } | |
| 69 | |
| 70 private: | |
| 71 const uint32_t* fKey; // unowned ptr into the larger key. | |
| 72 int fCount; // number of uint32_ts inserted by the effec
t into its key. | |
| 73 }; | |
| 74 | |
| 75 /** | |
| 76 * Given a GrEffect of a particular type, creates the corresponding graphics-bac
kend-specific | |
| 77 * effect object. It also tracks equivalence of shaders generated via a key. The
factory for an | |
| 78 * effect is accessed via GrEffect::getFactory(). Each factory instance is assig
ned an ID at | |
| 79 * construction. The ID of GrEffect::getFactory() is used as a type identifier.
Thus, a GrEffect | |
| 80 * subclass must always return the same object from getFactory() and that factor
y object must be | |
| 81 * unique to the GrEffect subclass (and unique from any further derived subclass
es). | |
| 82 * | |
| 83 * Rather than subclassing this class themselves, it is recommended that GrEffec
t authors use | |
| 84 * the templated subclass GrTBackendEffectFactory by writing their getFactory()
method as: | |
| 85 * | |
| 86 * const GrBackendEffectFactory& MyEffect::getFactory() const { | |
| 87 * return GrTBackendEffectFactory<MyEffect>::getInstance(); | |
| 88 * } | |
| 89 * | |
| 90 * Using GrTBackendEffectFactory places a few constraints on the effect. See tha
t class's comments. | |
| 91 */ | |
| 92 class GrBackendEffectFactory : SkNoncopyable { | |
| 93 public: | |
| 94 /** | |
| 95 * Generates an effect's key. The key is based on the aspects of the GrEffec
t object's | |
| 96 * configuration that affect GLSL code generation. Two GrEffect instances th
at would cause | |
| 97 * this->createGLInstance()->emitCode() to produce different code must produ
ce different keys. | |
| 98 */ | |
| 99 virtual void getGLEffectKey(const GrEffect&, const GrGLCaps&, GrEffectKeyBui
lder*) const = 0; | |
| 100 | |
| 101 /** | |
| 102 * Creates a GrGLEffect instance that is used both to generate code for the
GrEffect in a GLSL | |
| 103 * program and to manage updating uniforms for the program when it is used. | |
| 104 */ | |
| 105 virtual GrGLEffect* createGLInstance(const GrEffect&) const = 0; | |
| 106 | |
| 107 /** | |
| 108 * Produces a human-reable name for the effect. | |
| 109 */ | |
| 110 virtual const char* name() const = 0; | |
| 111 | |
| 112 /** | |
| 113 * A unique value for every instance of this factory. It is automatically in
corporated into the | |
| 114 * effect's key. This allows keys generated by getGLEffectKey() to only be u
nique within a | |
| 115 * GrEffect subclass and not necessarily across subclasses. | |
| 116 */ | |
| 117 uint32_t effectClassID() const { return fEffectClassID; } | |
| 118 | |
| 119 protected: | |
| 120 GrBackendEffectFactory() : fEffectClassID(GenID()) {} | |
| 121 virtual ~GrBackendEffectFactory() {} | |
| 122 | |
| 123 private: | |
| 124 enum { | |
| 125 kIllegalEffectClassID = 0, | |
| 126 }; | |
| 127 | |
| 128 static uint32_t GenID() { | |
| 129 // fCurrEffectClassID has been initialized to kIllegalEffectClassID. The | |
| 130 // atomic inc returns the old value not the incremented value. So we add | |
| 131 // 1 to the returned value. | |
| 132 uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&fCurrEffectClassID))
+ 1; | |
| 133 if (!id) { | |
| 134 SkFAIL("This should never wrap as it should only be called once for
each GrEffect " | |
| 135 "subclass."); | |
| 136 } | |
| 137 return id; | |
| 138 } | |
| 139 | |
| 140 const uint32_t fEffectClassID; | |
| 141 static int32_t fCurrEffectClassID; | |
| 142 }; | |
| 143 | |
| 144 #endif | |
| OLD | NEW |
|---|
Chromium Code Reviews
