tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 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 | #include "gl/GrGLShaderBuilder.h" |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 9 | #include "gl/GrGLProgram.h" |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 10 | #include "gl/GrGLUniformHandle.h" |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 11 | #include "GrTexture.h" |
tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 12 | |
tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 13 | // number of each input/output type in a single allocation block |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 14 | static const int kVarsPerBlock = 8; |
tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 15 | |
| 16 | // except FS outputs where we expect 2 at most. |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 17 | static const int kMaxFSOutputs = 2; |
tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 18 | |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 19 | // ES2 FS only guarantees mediump and lowp support |
| 20 | static const GrGLShaderVar::Precision kDefaultFragmentPrecision = GrGLShaderVar::kMedium_Precision; |
| 21 | |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 22 | typedef GrGLUniformManager::UniformHandle UniformHandle; |
| 23 | /////////////////////////////////////////////////////////////////////////////// |
| 24 | |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 25 | static SkString build_sampler_string(GrGLShaderBuilder::SamplerMode samplerMode) { |
| 26 | SkString sampler("texture2D"); |
| 27 | switch (samplerMode) { |
| 28 | case GrGLShaderBuilder::kDefault_SamplerMode: |
| 29 | break; |
| 30 | case GrGLShaderBuilder::kProj_SamplerMode: |
| 31 | sampler.append("Proj"); |
| 32 | break; |
| 33 | case GrGLShaderBuilder::kExplicitDivide_SamplerMode: |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 34 | break; |
| 35 | } |
| 36 | |
| 37 | return sampler; |
| 38 | } |
| 39 | |
| 40 | static bool texture_requires_alpha_to_red_swizzle(const GrGLCaps& caps, |
| 41 | const GrTextureAccess& access) { |
| 42 | return GrPixelConfigIsAlphaOnly(access.getTexture()->config()) && caps.textureRedSupport() && |
| 43 | access.referencesAlpha(); |
| 44 | } |
| 45 | |
| 46 | static SkString build_swizzle_string(const GrTextureAccess& textureAccess, |
| 47 | const GrGLCaps& caps) { |
| 48 | const GrTextureAccess::Swizzle& swizzle = textureAccess.getSwizzle(); |
| 49 | if (0 == swizzle[0]) { |
| 50 | return SkString(""); |
| 51 | } |
| 52 | |
| 53 | SkString swizzleOut("."); |
| 54 | bool alphaIsRed = texture_requires_alpha_to_red_swizzle(caps, textureAccess); |
| 55 | for (int offset = 0; offset < 4 && swizzle[offset]; ++offset) { |
| 56 | if (alphaIsRed && 'a' == swizzle[offset]) { |
| 57 | swizzleOut.appendf("r"); |
| 58 | } else { |
| 59 | swizzleOut.appendf("%c", swizzle[offset]); |
| 60 | } |
| 61 | } |
| 62 | |
| 63 | return swizzleOut; |
| 64 | } |
| 65 | |
| 66 | /////////////////////////////////////////////////////////////////////////////// |
| 67 | |
tomhudson@google.com | 9c639a4 | 2012-05-14 19:58:06 +0000 | [diff] [blame] | 68 | // Architectural assumption: always 2-d input coords. |
| 69 | // Likely to become non-constant and non-static, perhaps even |
| 70 | // varying by stage, if we use 1D textures for gradients! |
| 71 | //const int GrGLShaderBuilder::fCoordDims = 2; |
| 72 | |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 73 | GrGLShaderBuilder::GrGLShaderBuilder(const GrGLContextInfo& ctx, GrGLUniformManager& uniformManager) |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 74 | : fUniforms(kVarsPerBlock) |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 75 | , fVSAttrs(kVarsPerBlock) |
| 76 | , fVSOutputs(kVarsPerBlock) |
| 77 | , fGSInputs(kVarsPerBlock) |
| 78 | , fGSOutputs(kVarsPerBlock) |
| 79 | , fFSInputs(kVarsPerBlock) |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 80 | , fFSOutputs(kMaxFSOutputs) |
tomhudson@google.com | 040c41a | 2012-05-18 14:57:40 +0000 | [diff] [blame] | 81 | , fUsesGS(false) |
tomhudson@google.com | 9c639a4 | 2012-05-14 19:58:06 +0000 | [diff] [blame] | 82 | , fVaryingDims(0) |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 83 | , fComplexCoord(false) |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 84 | , fContext(ctx) |
bsalomon@google.com | 777c3aa | 2012-07-25 20:58:20 +0000 | [diff] [blame] | 85 | , fUniformManager(uniformManager) |
| 86 | , fCurrentStage(kNonStageIdx) { |
tomhudson@google.com | f9ad886 | 2012-05-11 20:38:48 +0000 | [diff] [blame] | 87 | } |
| 88 | |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 89 | void GrGLShaderBuilder::computeSwizzle(uint32_t configFlags) { |
| 90 | static const uint32_t kMulByAlphaMask = |
| 91 | (GrGLProgram::StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag | |
| 92 | GrGLProgram::StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag); |
| 93 | |
| 94 | fSwizzle = ""; |
| 95 | if (configFlags & GrGLProgram::StageDesc::kSwapRAndB_InConfigFlag) { |
| 96 | GrAssert(!(configFlags & |
| 97 | GrGLProgram::StageDesc::kSmearAlpha_InConfigFlag)); |
| 98 | GrAssert(!(configFlags & |
| 99 | GrGLProgram::StageDesc::kSmearRed_InConfigFlag)); |
| 100 | fSwizzle = ".bgra"; |
| 101 | } else if (configFlags & GrGLProgram::StageDesc::kSmearAlpha_InConfigFlag) { |
| 102 | GrAssert(!(configFlags & kMulByAlphaMask)); |
| 103 | GrAssert(!(configFlags & |
| 104 | GrGLProgram::StageDesc::kSmearRed_InConfigFlag)); |
| 105 | fSwizzle = ".aaaa"; |
| 106 | } else if (configFlags & GrGLProgram::StageDesc::kSmearRed_InConfigFlag) { |
| 107 | GrAssert(!(configFlags & kMulByAlphaMask)); |
| 108 | GrAssert(!(configFlags & |
| 109 | GrGLProgram::StageDesc::kSmearAlpha_InConfigFlag)); |
| 110 | fSwizzle = ".rrrr"; |
| 111 | } |
| 112 | } |
| 113 | |
| 114 | void GrGLShaderBuilder::computeModulate(const char* fsInColor) { |
| 115 | if (NULL != fsInColor) { |
| 116 | fModulate.printf(" * %s", fsInColor); |
robertphillips@google.com | e9b3f7d | 2012-05-30 12:26:39 +0000 | [diff] [blame] | 117 | } else { |
| 118 | fModulate.reset(); |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 119 | } |
| 120 | } |
| 121 | |
tomhudson@google.com | de78823 | 2012-08-02 20:13:12 +0000 | [diff] [blame] | 122 | void GrGLShaderBuilder::setupTextureAccess(int stageNum) { |
bsalomon@google.com | f0a104e | 2012-07-10 17:51:07 +0000 | [diff] [blame] | 123 | SkString retval; |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 124 | |
tomhudson@google.com | de78823 | 2012-08-02 20:13:12 +0000 | [diff] [blame] | 125 | SamplerMode mode = kDefault_SamplerMode; |
| 126 | // FIXME: we aren't currently using Proj. |
| 127 | if (fVaryingDims != fCoordDims) { |
| 128 | mode = kExplicitDivide_SamplerMode; |
| 129 | } |
| 130 | |
| 131 | switch (mode) { |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 132 | case kDefault_SamplerMode: |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 133 | GrAssert(fVaryingDims == fCoordDims); |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 134 | // Do nothing |
| 135 | break; |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 136 | case kProj_SamplerMode: |
tomhudson@google.com | de78823 | 2012-08-02 20:13:12 +0000 | [diff] [blame] | 137 | // Do nothing |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 138 | break; |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 139 | case kExplicitDivide_SamplerMode: |
| 140 | retval = "inCoord"; |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 141 | retval.appendS32(stageNum); |
| 142 | fFSCode.appendf("\t%s %s = %s%s / %s%s;\n", |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 143 | GrGLShaderVar::TypeString |
| 144 | (GrSLFloatVectorType(fCoordDims)), |
| 145 | retval.c_str(), |
| 146 | fSampleCoords.c_str(), |
| 147 | GrGLSLVectorNonhomogCoords(fVaryingDims), |
| 148 | fSampleCoords.c_str(), |
| 149 | GrGLSLVectorHomogCoord(fVaryingDims)); |
| 150 | fSampleCoords = retval; |
| 151 | break; |
| 152 | } |
tomhudson@google.com | de78823 | 2012-08-02 20:13:12 +0000 | [diff] [blame] | 153 | fTexFunc = build_sampler_string(mode); |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 154 | fComplexCoord = false; |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | void GrGLShaderBuilder::emitTextureLookup(const char* samplerName, |
| 158 | const char* coordName) { |
| 159 | if (NULL == coordName) { |
| 160 | coordName = fSampleCoords.c_str(); |
| 161 | } |
tomhudson@google.com | 5440f06 | 2012-06-01 15:55:50 +0000 | [diff] [blame] | 162 | fFSCode.appendf("%s(%s, %s)", fTexFunc.c_str(), samplerName, coordName); |
tomhudson@google.com | 5259814 | 2012-05-24 17:44:30 +0000 | [diff] [blame] | 163 | } |
| 164 | |
| 165 | void GrGLShaderBuilder::emitDefaultFetch(const char* outColor, |
| 166 | const char* samplerName) { |
| 167 | fFSCode.appendf("\t%s = ", outColor); |
| 168 | this->emitTextureLookup(samplerName); |
| 169 | fFSCode.appendf("%s%s;\n", fSwizzle.c_str(), fModulate.c_str()); |
| 170 | } |
| 171 | |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 172 | void GrGLShaderBuilder::emitCustomTextureLookup(SamplerMode samplerMode, |
| 173 | const GrTextureAccess& textureAccess, |
| 174 | const char* samplerName, |
| 175 | const char* coordName) { |
| 176 | GrAssert(samplerName && coordName); |
| 177 | SkString sampler = build_sampler_string(samplerMode); |
| 178 | SkString swizzle = build_swizzle_string(textureAccess, fContext.caps()); |
| 179 | |
| 180 | fFSCode.appendf("%s( %s, %s)%s;\n", sampler.c_str(), samplerName, |
| 181 | coordName, swizzle.c_str()); |
| 182 | } |
| 183 | |
| 184 | GrCustomStage::StageKey GrGLShaderBuilder::KeyForTextureAccess(const GrTextureAccess& access, |
| 185 | const GrGLCaps& caps) { |
| 186 | GrCustomStage::StageKey key = 0; |
bsalomon@google.com | d472620 | 2012-08-03 14:34:46 +0000 | [diff] [blame^] | 187 | |
twiz@google.com | a5e65ec | 2012-08-02 15:15:16 +0000 | [diff] [blame] | 188 | // Assume that swizzle support implies that we never have to modify a shader to adjust |
| 189 | // for texture format/swizzle settings. |
| 190 | if (caps.textureSwizzleSupport()) { |
| 191 | return key; |
| 192 | } |
| 193 | |
| 194 | if (texture_requires_alpha_to_red_swizzle(caps, access)) { |
| 195 | key = 1; |
| 196 | } |
| 197 | |
| 198 | return key; |
| 199 | } |
| 200 | |
bsalomon@google.com | 777c3aa | 2012-07-25 20:58:20 +0000 | [diff] [blame] | 201 | GrGLUniformManager::UniformHandle GrGLShaderBuilder::addUniformArray(uint32_t visibility, |
| 202 | GrSLType type, |
| 203 | const char* name, |
| 204 | int count, |
| 205 | const char** outName) { |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 206 | GrAssert(name && strlen(name)); |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 207 | static const uint32_t kVisibilityMask = kVertex_ShaderType | kFragment_ShaderType; |
| 208 | GrAssert(0 == (~kVisibilityMask & visibility)); |
| 209 | GrAssert(0 != visibility); |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 210 | |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 211 | BuilderUniform& uni = fUniforms.push_back(); |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 212 | UniformHandle h = index_to_handle(fUniforms.count() - 1); |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 213 | GR_DEBUGCODE(UniformHandle h2 =) |
| 214 | fUniformManager.appendUniform(type, count); |
| 215 | // We expect the uniform manager to initially have no uniforms and that all uniforms are added |
| 216 | // by this function. Therefore, the handles should match. |
| 217 | GrAssert(h2 == h); |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 218 | uni.fVariable.setType(type); |
| 219 | uni.fVariable.setTypeModifier(GrGLShaderVar::kUniform_TypeModifier); |
bsalomon@google.com | 777c3aa | 2012-07-25 20:58:20 +0000 | [diff] [blame] | 220 | SkString* uniName = uni.fVariable.accessName(); |
| 221 | if (kNonStageIdx == fCurrentStage) { |
| 222 | uniName->printf("u%s", name); |
| 223 | } else { |
| 224 | uniName->printf("u%s%d", name, fCurrentStage); |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 225 | } |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 226 | uni.fVariable.setArrayCount(count); |
| 227 | uni.fVisibility = visibility; |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 228 | |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 229 | // If it is visible in both the VS and FS, the precision must match. |
| 230 | // We declare a default FS precision, but not a default VS. So set the var |
| 231 | // to use the default FS precision. |
bsalomon@google.com | eb715c8 | 2012-07-11 15:03:31 +0000 | [diff] [blame] | 232 | if ((kVertex_ShaderType | kFragment_ShaderType) == visibility) { |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 233 | // the fragment and vertex precisions must match |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 234 | uni.fVariable.setPrecision(kDefaultFragmentPrecision); |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 235 | } |
| 236 | |
bsalomon@google.com | 777c3aa | 2012-07-25 20:58:20 +0000 | [diff] [blame] | 237 | if (NULL != outName) { |
| 238 | *outName = uni.fVariable.c_str(); |
| 239 | } |
| 240 | |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 241 | return h; |
| 242 | } |
| 243 | |
| 244 | const GrGLShaderVar& GrGLShaderBuilder::getUniformVariable(UniformHandle u) const { |
| 245 | return fUniforms[handle_to_index(u)].fVariable; |
tomhudson@google.com | 242ed6f | 2012-05-30 17:38:57 +0000 | [diff] [blame] | 246 | } |
tomhudson@google.com | 23cb229 | 2012-05-30 18:26:03 +0000 | [diff] [blame] | 247 | |
| 248 | void GrGLShaderBuilder::addVarying(GrSLType type, |
| 249 | const char* name, |
| 250 | const char** vsOutName, |
| 251 | const char** fsInName) { |
| 252 | fVSOutputs.push_back(); |
| 253 | fVSOutputs.back().setType(type); |
| 254 | fVSOutputs.back().setTypeModifier(GrGLShaderVar::kOut_TypeModifier); |
bsalomon@google.com | 777c3aa | 2012-07-25 20:58:20 +0000 | [diff] [blame] | 255 | if (kNonStageIdx == fCurrentStage) { |
| 256 | fVSOutputs.back().accessName()->printf("v%s", name); |
| 257 | } else { |
| 258 | fVSOutputs.back().accessName()->printf("v%s%d", name, fCurrentStage); |
| 259 | } |
tomhudson@google.com | 23cb229 | 2012-05-30 18:26:03 +0000 | [diff] [blame] | 260 | if (vsOutName) { |
| 261 | *vsOutName = fVSOutputs.back().getName().c_str(); |
| 262 | } |
| 263 | // input to FS comes either from VS or GS |
bsalomon@google.com | f0a104e | 2012-07-10 17:51:07 +0000 | [diff] [blame] | 264 | const SkString* fsName; |
tomhudson@google.com | 23cb229 | 2012-05-30 18:26:03 +0000 | [diff] [blame] | 265 | if (fUsesGS) { |
| 266 | // if we have a GS take each varying in as an array |
| 267 | // and output as non-array. |
| 268 | fGSInputs.push_back(); |
| 269 | fGSInputs.back().setType(type); |
| 270 | fGSInputs.back().setTypeModifier(GrGLShaderVar::kIn_TypeModifier); |
| 271 | fGSInputs.back().setUnsizedArray(); |
| 272 | *fGSInputs.back().accessName() = fVSOutputs.back().getName(); |
| 273 | fGSOutputs.push_back(); |
| 274 | fGSOutputs.back().setType(type); |
| 275 | fGSOutputs.back().setTypeModifier(GrGLShaderVar::kOut_TypeModifier); |
bsalomon@google.com | d472620 | 2012-08-03 14:34:46 +0000 | [diff] [blame^] | 276 | if (kNonStageIdx == fCurrentStage) { |
| 277 | fGSOutputs.back().accessName()->printf("g%s", name); |
| 278 | } else { |
| 279 | fGSOutputs.back().accessName()->printf("g%s%d", name, fCurrentStage); |
| 280 | } |
tomhudson@google.com | 23cb229 | 2012-05-30 18:26:03 +0000 | [diff] [blame] | 281 | fsName = fGSOutputs.back().accessName(); |
| 282 | } else { |
| 283 | fsName = fVSOutputs.back().accessName(); |
| 284 | } |
| 285 | fFSInputs.push_back(); |
| 286 | fFSInputs.back().setType(type); |
| 287 | fFSInputs.back().setTypeModifier(GrGLShaderVar::kIn_TypeModifier); |
| 288 | fFSInputs.back().setName(*fsName); |
| 289 | if (fsInName) { |
| 290 | *fsInName = fsName->c_str(); |
| 291 | } |
| 292 | } |
| 293 | |
tomhudson@google.com | 23cb229 | 2012-05-30 18:26:03 +0000 | [diff] [blame] | 294 | |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 295 | namespace { |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 296 | |
| 297 | inline void append_default_precision_qualifier(GrGLShaderVar::Precision p, |
| 298 | GrGLBinding binding, |
| 299 | SkString* str) { |
| 300 | // Desktop GLSL has added precision qualifiers but they don't do anything. |
| 301 | if (kES2_GrGLBinding == binding) { |
| 302 | switch (p) { |
| 303 | case GrGLShaderVar::kHigh_Precision: |
| 304 | str->append("precision highp float;\n"); |
| 305 | break; |
| 306 | case GrGLShaderVar::kMedium_Precision: |
| 307 | str->append("precision mediump float;\n"); |
| 308 | break; |
| 309 | case GrGLShaderVar::kLow_Precision: |
| 310 | str->append("precision lowp float;\n"); |
| 311 | break; |
| 312 | case GrGLShaderVar::kDefault_Precision: |
| 313 | GrCrash("Default precision now allowed."); |
| 314 | default: |
| 315 | GrCrash("Unknown precision value."); |
| 316 | } |
| 317 | } |
| 318 | } |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 319 | } |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 320 | |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 321 | void GrGLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const { |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 322 | for (int i = 0; i < vars.count(); ++i) { |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 323 | vars[i].appendDecl(fContext, out); |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 324 | } |
| 325 | } |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 326 | |
| 327 | void GrGLShaderBuilder::appendUniformDecls(ShaderType stype, SkString* out) const { |
| 328 | for (int i = 0; i < fUniforms.count(); ++i) { |
| 329 | if (fUniforms[i].fVisibility & stype) { |
| 330 | fUniforms[i].fVariable.appendDecl(fContext, out); |
| 331 | } |
| 332 | } |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 333 | } |
| 334 | |
| 335 | void GrGLShaderBuilder::getShader(ShaderType type, SkString* shaderStr) const { |
| 336 | switch (type) { |
| 337 | case kVertex_ShaderType: |
| 338 | *shaderStr = fHeader; |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 339 | this->appendUniformDecls(kVertex_ShaderType, shaderStr); |
| 340 | this->appendDecls(fVSAttrs, shaderStr); |
| 341 | this->appendDecls(fVSOutputs, shaderStr); |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 342 | shaderStr->append(fVSCode); |
| 343 | break; |
| 344 | case kGeometry_ShaderType: |
| 345 | if (fUsesGS) { |
| 346 | *shaderStr = fHeader; |
| 347 | shaderStr->append(fGSHeader); |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 348 | this->appendDecls(fGSInputs, shaderStr); |
| 349 | this->appendDecls(fGSOutputs, shaderStr); |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 350 | shaderStr->append(fGSCode); |
| 351 | } else { |
| 352 | shaderStr->reset(); |
| 353 | } |
| 354 | break; |
| 355 | case kFragment_ShaderType: |
| 356 | *shaderStr = fHeader; |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 357 | append_default_precision_qualifier(kDefaultFragmentPrecision, |
| 358 | fContext.binding(), |
| 359 | shaderStr); |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 360 | this->appendUniformDecls(kFragment_ShaderType, shaderStr); |
| 361 | this->appendDecls(fFSInputs, shaderStr); |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 362 | // We shouldn't have declared outputs on 1.10 |
| 363 | GrAssert(k110_GrGLSLGeneration != fContext.glslGeneration() || fFSOutputs.empty()); |
bsalomon@google.com | 032b221 | 2012-07-16 13:36:18 +0000 | [diff] [blame] | 364 | this->appendDecls(fFSOutputs, shaderStr); |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 365 | shaderStr->append(fFSFunctions); |
| 366 | shaderStr->append(fFSCode); |
| 367 | break; |
| 368 | } |
bsalomon@google.com | ad5e937 | 2012-07-11 18:11:27 +0000 | [diff] [blame] | 369 | } |
bsalomon@google.com | d7727ce | 2012-07-12 16:40:03 +0000 | [diff] [blame] | 370 | |
bsalomon@google.com | dbbc4e2 | 2012-07-25 17:48:39 +0000 | [diff] [blame] | 371 | void GrGLShaderBuilder::finished(GrGLuint programID) { |
| 372 | fUniformManager.getUniformLocations(programID, fUniforms); |
| 373 | } |