bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 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 GrGLProgramDesc_DEFINED |
| 9 | #define GrGLProgramDesc_DEFINED |
| 10 | |
| 11 | #include "GrGLEffect.h" |
bsalomon@google.com | 798c8c4 | 2013-03-27 19:50:27 +0000 | [diff] [blame] | 12 | #include "GrDrawState.h" |
commit-bot@chromium.org | 0a6fe71 | 2014-04-23 19:26:26 +0000 | [diff] [blame] | 13 | #include "GrGpu.h" |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 14 | |
| 15 | class GrGpuGL; |
| 16 | |
commit-bot@chromium.org | 515dcd3 | 2013-08-28 14:17:03 +0000 | [diff] [blame] | 17 | #ifdef SK_DEBUG |
| 18 | // Optionally compile the experimental GS code. Set to SK_DEBUG so that debug build bots will |
| 19 | // execute the code. |
| 20 | #define GR_GL_EXPERIMENTAL_GS 1 |
| 21 | #else |
| 22 | #define GR_GL_EXPERIMENTAL_GS 0 |
| 23 | #endif |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 24 | |
| 25 | |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 26 | /** This class describes a program to generate. It also serves as a program cache key. Very little |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 27 | of this is GL-specific. The GL-specific parts could be factored out into a subclass. */ |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 28 | class GrGLProgramDesc { |
| 29 | public: |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 30 | GrGLProgramDesc() {} |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 31 | GrGLProgramDesc(const GrGLProgramDesc& desc) { *this = desc; } |
| 32 | |
skia.committer@gmail.com | 2d816ad | 2013-05-23 07:01:22 +0000 | [diff] [blame] | 33 | // Returns this as a uint32_t array to be used as a key in the program cache. |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 34 | const uint32_t* asKey() const { |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 35 | return reinterpret_cast<const uint32_t*>(fKey.begin()); |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 36 | } |
| 37 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 38 | // Gets the number of bytes in asKey(). It will be a 4-byte aligned value. When comparing two |
| 39 | // keys the size of either key can be used with memcmp() since the lengths themselves begin the |
| 40 | // keys and thus the memcmp will exit early if the keys are of different lengths. |
| 41 | uint32_t keyLength() const { return *this->atOffset<uint32_t, kLengthOffset>(); } |
| 42 | |
| 43 | // Gets the a checksum of the key. Can be used as a hash value for a fast lookup in a cache. |
| 44 | uint32_t getChecksum() const { return *this->atOffset<uint32_t, kChecksumOffset>(); } |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 45 | |
| 46 | // For unit testing. |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 47 | bool setRandom(SkRandom*, |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 48 | const GrGpuGL* gpu, |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 49 | const GrRenderTarget* dummyDstRenderTarget, |
| 50 | const GrTexture* dummyDstCopyTexture, |
| 51 | const GrEffectStage* stages[], |
| 52 | int numColorStages, |
| 53 | int numCoverageStages, |
jvanverth@google.com | 054ae99 | 2013-04-01 20:06:51 +0000 | [diff] [blame] | 54 | int currAttribIndex); |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 55 | |
| 56 | /** |
| 57 | * Builds a program descriptor from a GrDrawState. Whether the primitive type is points, the |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 58 | * output of GrDrawState::getBlendOpts, and the caps of the GrGpuGL are also inputs. It also |
bsalomon@google.com | 2c84aa3 | 2013-06-06 20:28:57 +0000 | [diff] [blame] | 59 | * outputs the color and coverage stages referenced by the generated descriptor. This may |
| 60 | * not contain all stages from the draw state and coverage stages from the drawState may |
| 61 | * be treated as color stages in the output. |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 62 | */ |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 63 | static bool Build(const GrDrawState&, |
commit-bot@chromium.org | 0a6fe71 | 2014-04-23 19:26:26 +0000 | [diff] [blame] | 64 | GrGpu::DrawType drawType, |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 65 | GrDrawState::BlendOptFlags, |
| 66 | GrBlendCoeff srcCoeff, |
| 67 | GrBlendCoeff dstCoeff, |
| 68 | const GrGpuGL* gpu, |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 69 | const GrDeviceCoordTexture* dstCopy, |
bsalomon@google.com | 2c84aa3 | 2013-06-06 20:28:57 +0000 | [diff] [blame] | 70 | SkTArray<const GrEffectStage*, true>* outColorStages, |
| 71 | SkTArray<const GrEffectStage*, true>* outCoverageStages, |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 72 | GrGLProgramDesc* outDesc); |
| 73 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 74 | int numColorEffects() const { |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 75 | return this->getHeader().fColorEffectCnt; |
| 76 | } |
| 77 | |
| 78 | int numCoverageEffects() const { |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 79 | return this->getHeader().fCoverageEffectCnt; |
| 80 | } |
| 81 | |
| 82 | int numTotalEffects() const { return this->numColorEffects() + this->numCoverageEffects(); } |
| 83 | |
| 84 | GrGLProgramDesc& operator= (const GrGLProgramDesc& other); |
| 85 | |
| 86 | bool operator== (const GrGLProgramDesc& other) const { |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 87 | // The length is masked as a hint to the compiler that the address will be 4 byte aligned. |
| 88 | return 0 == memcmp(this->asKey(), other.asKey(), this->keyLength() & ~0x3); |
| 89 | } |
| 90 | |
| 91 | bool operator!= (const GrGLProgramDesc& other) const { |
| 92 | return !(*this == other); |
| 93 | } |
| 94 | |
| 95 | static bool Less(const GrGLProgramDesc& a, const GrGLProgramDesc& b) { |
| 96 | return memcmp(a.asKey(), b.asKey(), a.keyLength() & ~0x3) < 0; |
| 97 | } |
| 98 | |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 99 | private: |
| 100 | // Specifies where the initial color comes from before the stages are applied. |
| 101 | enum ColorInput { |
egdaniel | 842b086 | 2014-09-02 10:01:30 -0700 | [diff] [blame] | 102 | kAllOnes_ColorInput, |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 103 | kAttribute_ColorInput, |
| 104 | kUniform_ColorInput, |
| 105 | |
| 106 | kColorInputCnt |
| 107 | }; |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 108 | |
bsalomon@google.com | 5920ac2 | 2013-04-19 13:14:45 +0000 | [diff] [blame] | 109 | enum CoverageOutput { |
| 110 | // modulate color and coverage, write result as the color output. |
| 111 | kModulate_CoverageOutput, |
| 112 | // Writes color*coverage as the primary color output and also writes coverage as the |
| 113 | // secondary output. Only set if dual source blending is supported. |
| 114 | kSecondaryCoverage_CoverageOutput, |
| 115 | // Writes color*coverage as the primary color output and also writes coverage * (1 - colorA) |
| 116 | // as the secondary output. Only set if dual source blending is supported. |
| 117 | kSecondaryCoverageISA_CoverageOutput, |
| 118 | // Writes color*coverage as the primary color output and also writes coverage * |
| 119 | // (1 - colorRGB) as the secondary output. Only set if dual source blending is supported. |
| 120 | kSecondaryCoverageISC_CoverageOutput, |
| 121 | // Combines the coverage, dst, and color as coverage * color + (1 - coverage) * dst. This |
bsalomon@google.com | b515881 | 2013-05-13 18:50:25 +0000 | [diff] [blame] | 122 | // can only be set if fDstReadKey is non-zero. |
bsalomon@google.com | 5920ac2 | 2013-04-19 13:14:45 +0000 | [diff] [blame] | 123 | kCombineWithDst_CoverageOutput, |
| 124 | |
| 125 | kCoverageOutputCnt |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 126 | }; |
| 127 | |
bsalomon@google.com | 5920ac2 | 2013-04-19 13:14:45 +0000 | [diff] [blame] | 128 | static bool CoverageOutputUsesSecondaryOutput(CoverageOutput co) { |
| 129 | switch (co) { |
| 130 | case kSecondaryCoverage_CoverageOutput: // fallthru |
| 131 | case kSecondaryCoverageISA_CoverageOutput: |
| 132 | case kSecondaryCoverageISC_CoverageOutput: |
| 133 | return true; |
| 134 | default: |
| 135 | return false; |
| 136 | } |
| 137 | } |
| 138 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 139 | struct KeyHeader { |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 140 | uint8_t fDstReadKey; // set by GrGLShaderBuilder if there |
bsalomon@google.com | 26e18b5 | 2013-03-29 19:22:36 +0000 | [diff] [blame] | 141 | // are effects that must read the dst. |
| 142 | // Otherwise, 0. |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 143 | uint8_t fFragPosKey; // set by GrGLShaderBuilder if there are |
bsalomon@google.com | b515881 | 2013-05-13 18:50:25 +0000 | [diff] [blame] | 144 | // effects that read the fragment position. |
| 145 | // Otherwise, 0. |
commit-bot@chromium.org | 949eef0 | 2013-10-01 18:43:29 +0000 | [diff] [blame] | 146 | ColorInput fColorInput : 8; |
| 147 | ColorInput fCoverageInput : 8; |
| 148 | CoverageOutput fCoverageOutput : 8; |
jvanverth@google.com | 054ae99 | 2013-04-01 20:06:51 +0000 | [diff] [blame] | 149 | |
kkinnunen | ec56e45 | 2014-08-25 22:21:16 -0700 | [diff] [blame] | 150 | SkBool8 fRequiresVertexShader; |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 151 | SkBool8 fEmitsPointSize; |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 152 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 153 | // To enable experimental geometry shader code (not for use in |
| 154 | // production) |
| 155 | #if GR_GL_EXPERIMENTAL_GS |
| 156 | SkBool8 fExperimentalGS; |
| 157 | #endif |
| 158 | |
| 159 | int8_t fPositionAttributeIndex; |
| 160 | int8_t fLocalCoordAttributeIndex; |
| 161 | int8_t fColorAttributeIndex; |
| 162 | int8_t fCoverageAttributeIndex; |
skia.committer@gmail.com | 2d816ad | 2013-05-23 07:01:22 +0000 | [diff] [blame] | 163 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 164 | int8_t fColorEffectCnt; |
| 165 | int8_t fCoverageEffectCnt; |
| 166 | }; |
| 167 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 168 | // The key, stored in fKey, is composed of five parts: |
| 169 | // 1. uint32_t for total key length. |
| 170 | // 2. uint32_t for a checksum. |
| 171 | // 3. Header struct defined above. |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 172 | // 4. An array of offsets to effect keys and their sizes (see 5). uint16_t for each |
| 173 | // offset and size. |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 174 | // 5. per-effect keys. Each effect's key is a variable length array of uint32_t. |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 175 | enum { |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 176 | // Part 1. |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 177 | kLengthOffset = 0, |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 178 | // Part 2. |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 179 | kChecksumOffset = kLengthOffset + sizeof(uint32_t), |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 180 | // Part 3. |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 181 | kHeaderOffset = kChecksumOffset + sizeof(uint32_t), |
| 182 | kHeaderSize = SkAlign4(sizeof(KeyHeader)), |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 183 | // Part 4. |
| 184 | // This is the offset in the overall key to the array of per-effect offset,length pairs. |
| 185 | kEffectKeyOffsetsAndLengthOffset = kHeaderOffset + kHeaderSize, |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 186 | }; |
| 187 | |
| 188 | template<typename T, size_t OFFSET> T* atOffset() { |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 189 | return reinterpret_cast<T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET); |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 190 | } |
| 191 | |
| 192 | template<typename T, size_t OFFSET> const T* atOffset() const { |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 193 | return reinterpret_cast<const T*>(reinterpret_cast<intptr_t>(fKey.begin()) + OFFSET); |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 194 | } |
| 195 | |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 196 | KeyHeader* header() { return this->atOffset<KeyHeader, kHeaderOffset>(); } |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 197 | |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 198 | // Shared code between setRandom() and Build(). |
| 199 | static bool GetEffectKeyAndUpdateStats(const GrEffectStage& stage, |
| 200 | const GrGLCaps& caps, |
| 201 | bool useExplicitLocalCoords, |
| 202 | GrEffectKeyBuilder* b, |
| 203 | uint16_t* effectKeySize, |
| 204 | bool* setTrueIfReadsDst, |
| 205 | bool* setTrueIfReadsPos, |
kkinnunen | ec56e45 | 2014-08-25 22:21:16 -0700 | [diff] [blame] | 206 | bool* setTrueIfRequiresVertexShader); |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 207 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 208 | void finalize(); |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 209 | |
| 210 | const KeyHeader& getHeader() const { return *this->atOffset<KeyHeader, kHeaderOffset>(); } |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 211 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 212 | /** Used to provide effects' keys to their emitCode() function. */ |
| 213 | class EffectKeyProvider { |
| 214 | public: |
| 215 | enum EffectType { |
| 216 | kColor_EffectType, |
| 217 | kCoverage_EffectType, |
| 218 | }; |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 219 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 220 | EffectKeyProvider(const GrGLProgramDesc* desc, EffectType type) : fDesc(desc) { |
| 221 | // Coverage effect key offsets begin immediately after those of the color effects. |
| 222 | fBaseIndex = kColor_EffectType == type ? 0 : desc->numColorEffects(); |
| 223 | } |
| 224 | |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 225 | GrEffectKey get(int index) const { |
| 226 | const uint16_t* offsetsAndLengths = reinterpret_cast<const uint16_t*>( |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 227 | fDesc->fKey.begin() + kEffectKeyOffsetsAndLengthOffset); |
| 228 | // We store two uint16_ts per effect, one for the offset to the effect's key and one for |
| 229 | // its length. Here we just need the offset. |
bsalomon | 63e99f7 | 2014-07-21 08:03:14 -0700 | [diff] [blame] | 230 | uint16_t offset = offsetsAndLengths[2 * (fBaseIndex + index) + 0]; |
| 231 | uint16_t length = offsetsAndLengths[2 * (fBaseIndex + index) + 1]; |
| 232 | // Currently effects must add to the key in units of uint32_t. |
| 233 | SkASSERT(0 == (length % sizeof(uint32_t))); |
| 234 | return GrEffectKey(reinterpret_cast<const uint32_t*>(fDesc->fKey.begin() + offset), |
| 235 | length / sizeof(uint32_t)); |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 236 | } |
| 237 | private: |
| 238 | const GrGLProgramDesc* fDesc; |
| 239 | int fBaseIndex; |
bsalomon@google.com | 2db3ded | 2013-05-22 14:34:04 +0000 | [diff] [blame] | 240 | }; |
| 241 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 242 | enum { |
| 243 | kMaxPreallocEffects = 8, |
| 244 | kIntsPerEffect = 4, // This is an overestimate of the average effect key size. |
bsalomon | 929f29a | 2014-07-17 07:55:11 -0700 | [diff] [blame] | 245 | kPreAllocSize = kEffectKeyOffsetsAndLengthOffset + |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 246 | kMaxPreallocEffects * sizeof(uint32_t) * kIntsPerEffect, |
| 247 | }; |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 248 | |
bsalomon | 848faf0 | 2014-07-11 10:01:02 -0700 | [diff] [blame] | 249 | SkSTArray<kPreAllocSize, uint8_t, true> fKey; |
| 250 | |
| 251 | // GrGLProgram and GrGLShaderBuilder read the private fields to generate code. TODO: Split out |
| 252 | // part of GrGLShaderBuilder that is used by effects so that this header doesn't need to be |
| 253 | // visible to GrGLEffects. Then make public accessors as necessary and remove friends. |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 254 | friend class GrGLProgram; |
joshualitt | 30ba436 | 2014-08-21 20:18:45 -0700 | [diff] [blame] | 255 | friend class GrGLProgramBuilder; |
| 256 | friend class GrGLFullProgramBuilder; |
| 257 | friend class GrGLFragmentOnlyProgramBuilder; |
| 258 | friend class GrGLVertexShaderBuilder; |
| 259 | friend class GrGLFragmentShaderBuilder; |
| 260 | friend class GrGLGeometryShaderBuilder; |
bsalomon@google.com | 31ec798 | 2013-03-27 18:14:57 +0000 | [diff] [blame] | 261 | }; |
| 262 | |
| 263 | #endif |