1/* 2 * Copyright 2014 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 "GrShaderVar.h" 9#include "GrShaderCaps.h" 10#include "GrSwizzle.h" 11#include "glsl/GrGLSLShaderBuilder.h" 12#include "glsl/GrGLSLColorSpaceXformHelper.h" 13#include "glsl/GrGLSLProgramBuilder.h" 14 15GrGLSLShaderBuilder::GrGLSLShaderBuilder(GrGLSLProgramBuilder* program) 16 : fProgramBuilder(program) 17 , fInputs(GrGLSLProgramBuilder::kVarsPerBlock) 18 , fOutputs(GrGLSLProgramBuilder::kVarsPerBlock) 19 , fFeaturesAddedMask(0) 20 , fCodeIndex(kCode) 21 , fFinalized(false) { 22 // We push back some dummy pointers which will later become our header 23 for (int i = 0; i <= kCode; i++) { 24 fShaderStrings.push_back(); 25 fCompilerStrings.push_back(nullptr); 26 fCompilerStringLengths.push_back(0); 27 } 28 29 this->main() = "void main() {"; 30} 31 32void GrGLSLShaderBuilder::declAppend(const GrShaderVar& var) { 33 SkString tempDecl; 34 var.appendDecl(fProgramBuilder->shaderCaps(), &tempDecl); 35 this->codeAppendf("%s;", tempDecl.c_str()); 36} 37 38void GrGLSLShaderBuilder::declareGlobal(const GrShaderVar& v) { 39 v.appendDecl(this->getProgramBuilder()->shaderCaps(), &this->definitions()); 40 this->definitions().append(";"); 41} 42 43void GrGLSLShaderBuilder::emitFunction(GrSLType returnType, 44 const char* name, 45 int argCnt, 46 const GrShaderVar* args, 47 const char* body, 48 SkString* outName) { 49 this->functions().append(GrGLSLTypeString(fProgramBuilder->shaderCaps(), returnType)); 50 fProgramBuilder->nameVariable(outName, '\0', name); 51 this->functions().appendf(" %s", outName->c_str()); 52 this->functions().append("("); 53 for (int i = 0; i < argCnt; ++i) { 54 args[i].appendDecl(fProgramBuilder->shaderCaps(), &this->functions()); 55 if (i < argCnt - 1) { 56 this->functions().append(", "); 57 } 58 } 59 this->functions().append(") {\n"); 60 this->functions().append(body); 61 this->functions().append("}\n\n"); 62} 63 64static inline void append_texture_swizzle(SkString* out, GrSwizzle swizzle) { 65 if (swizzle != GrSwizzle::RGBA()) { 66 out->appendf(".%s", swizzle.c_str()); 67 } 68} 69 70void GrGLSLShaderBuilder::appendTextureLookup(SkString* out, 71 SamplerHandle samplerHandle, 72 const char* coordName, 73 GrSLType varyingType) const { 74 const GrShaderVar& sampler = fProgramBuilder->samplerVariable(samplerHandle); 75 out->appendf("texture(%s, %s)", sampler.c_str(), coordName); 76 append_texture_swizzle(out, fProgramBuilder->samplerSwizzle(samplerHandle)); 77} 78 79void GrGLSLShaderBuilder::appendTextureLookup(SamplerHandle samplerHandle, 80 const char* coordName, 81 GrSLType varyingType, 82 GrGLSLColorSpaceXformHelper* colorXformHelper) { 83 if (colorXformHelper && colorXformHelper->isValid()) { 84 // With a color gamut transform, we need to wrap the lookup in another function call 85 SkString lookup; 86 this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType); 87 this->appendColorGamutXform(lookup.c_str(), colorXformHelper); 88 } else { 89 this->appendTextureLookup(&this->code(), samplerHandle, coordName, varyingType); 90 } 91} 92 93void GrGLSLShaderBuilder::appendTextureLookupAndModulate( 94 const char* modulation, 95 SamplerHandle samplerHandle, 96 const char* coordName, 97 GrSLType varyingType, 98 GrGLSLColorSpaceXformHelper* colorXformHelper) { 99 SkString lookup; 100 this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType); 101 if (colorXformHelper && colorXformHelper->isValid()) { 102 SkString xform; 103 this->appendColorGamutXform(&xform, lookup.c_str(), colorXformHelper); 104 if (modulation) { 105 this->codeAppendf("%s * %s", modulation, xform.c_str()); 106 } else { 107 this->codeAppendf("%s", xform.c_str()); 108 } 109 } else { 110 if (modulation) { 111 this->codeAppendf("%s * %s", modulation, lookup.c_str()); 112 } else { 113 this->codeAppendf("%s", lookup.c_str()); 114 } 115 } 116} 117 118void GrGLSLShaderBuilder::appendColorGamutXform(SkString* out, 119 const char* srcColor, 120 GrGLSLColorSpaceXformHelper* colorXformHelper) { 121 GrGLSLUniformHandler* uniformHandler = fProgramBuilder->uniformHandler(); 122 123 // We define up to three helper functions, to keep things clearer. One does inverse sRGB, 124 // one does an arbitrary transfer function, and the last does gamut xform. Any combination of 125 // these may be present, although some configurations are much more likely. 126 127 SkString inverseSrgbFuncName; 128 if (colorXformHelper->applyInverseSRGB()) { 129 static const GrShaderVar gInverseSRGBArgs[] = { GrShaderVar("x", kHalf_GrSLType) }; 130 SkString body; 131 body.append("return (x <= 0.0031308) ? (x * 12.92) : (1.055 * pow(x, 0.4166667) - 0.055);"); 132 this->emitFunction(kHalf_GrSLType, "inverse_srgb", SK_ARRAY_COUNT(gInverseSRGBArgs), 133 gInverseSRGBArgs, body.c_str(), &inverseSrgbFuncName); 134 135 } 136 137 SkString transferFnFuncName; 138 if (colorXformHelper->applyTransferFn()) { 139 static const GrShaderVar gTransferFnArgs[] = { GrShaderVar("x", kHalf_GrSLType) }; 140 const char* coeffs = uniformHandler->getUniformCStr(colorXformHelper->transferFnUniform()); 141 SkString body; 142 // Temporaries to make evaluation line readable 143 body.appendf("half G = %s[0];", coeffs); 144 body.appendf("half A = %s[1];", coeffs); 145 body.appendf("half B = %s[2];", coeffs); 146 body.appendf("half C = %s[3];", coeffs); 147 body.appendf("half D = %s[4];", coeffs); 148 body.appendf("half E = %s[5];", coeffs); 149 body.appendf("half F = %s[6];", coeffs); 150 body.append("half s = sign(x);"); 151 body.append("x = abs(x);"); 152 body.appendf("return s * ((x < D) ? (C * x) + F : pow(A * x + B, G) + E);"); 153 this->emitFunction(kHalf_GrSLType, "transfer_fn", SK_ARRAY_COUNT(gTransferFnArgs), 154 gTransferFnArgs, body.c_str(), &transferFnFuncName); 155 } 156 157 SkString gamutXformFuncName; 158 if (colorXformHelper->applyGamutXform()) { 159 // Our color is (r, g, b, a), but we want to multiply (r, g, b, 1) by our matrix, then 160 // re-insert the original alpha. 161 static const GrShaderVar gGamutXformArgs[] = { GrShaderVar("color", kHalf4_GrSLType) }; 162 const char* xform = uniformHandler->getUniformCStr(colorXformHelper->gamutXformUniform()); 163 SkString body; 164 body.appendf("color.rgb = clamp((%s * half4(color.rgb, 1.0)).rgb, 0.0, color.a);", xform); 165 body.append("return color;"); 166 this->emitFunction(kHalf4_GrSLType, "gamut_xform", SK_ARRAY_COUNT(gGamutXformArgs), 167 gGamutXformArgs, body.c_str(), &gamutXformFuncName); 168 } 169 170 // Now define a wrapper function that applies all the intermediate steps 171 { 172 static const GrShaderVar gColorXformArgs[] = { GrShaderVar("color", kHalf4_GrSLType) }; 173 SkString body; 174 if (colorXformHelper->applyInverseSRGB()) { 175 body.appendf("color.r = %s(color.r);", inverseSrgbFuncName.c_str()); 176 body.appendf("color.g = %s(color.g);", inverseSrgbFuncName.c_str()); 177 body.appendf("color.b = %s(color.b);", inverseSrgbFuncName.c_str()); 178 } 179 if (colorXformHelper->applyTransferFn()) { 180 body.appendf("color.r = %s(color.r);", transferFnFuncName.c_str()); 181 body.appendf("color.g = %s(color.g);", transferFnFuncName.c_str()); 182 body.appendf("color.b = %s(color.b);", transferFnFuncName.c_str()); 183 } 184 if (colorXformHelper->applyGamutXform()) { 185 body.appendf("color = %s(color);", gamutXformFuncName.c_str()); 186 } 187 body.append("return color;"); 188 SkString colorXformFuncName; 189 this->emitFunction(kHalf4_GrSLType, "color_xform", SK_ARRAY_COUNT(gColorXformArgs), 190 gColorXformArgs, body.c_str(), &colorXformFuncName); 191 out->appendf("%s(%s)", colorXformFuncName.c_str(), srcColor); 192 } 193} 194 195void GrGLSLShaderBuilder::appendColorGamutXform(const char* srcColor, 196 GrGLSLColorSpaceXformHelper* colorXformHelper) { 197 SkString xform; 198 this->appendColorGamutXform(&xform, srcColor, colorXformHelper); 199 this->codeAppend(xform.c_str()); 200} 201 202void GrGLSLShaderBuilder::appendTexelFetch(SkString* out, 203 TexelBufferHandle texelBufferHandle, 204 const char* coordExpr) const { 205 const GrShaderVar& texelBuffer = fProgramBuilder->texelBufferVariable(texelBufferHandle); 206 SkASSERT(fProgramBuilder->shaderCaps()->texelFetchSupport()); 207 208 out->appendf("texelFetch(%s, %s)", texelBuffer.c_str(), coordExpr); 209} 210 211void GrGLSLShaderBuilder::appendTexelFetch(TexelBufferHandle texelBufferHandle, 212 const char* coordExpr) { 213 this->appendTexelFetch(&this->code(), texelBufferHandle, coordExpr); 214} 215 216bool GrGLSLShaderBuilder::addFeature(uint32_t featureBit, const char* extensionName) { 217 if (featureBit & fFeaturesAddedMask) { 218 return false; 219 } 220 this->extensions().appendf("#extension %s: require\n", extensionName); 221 fFeaturesAddedMask |= featureBit; 222 return true; 223} 224 225void GrGLSLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const { 226 for (int i = 0; i < vars.count(); ++i) { 227 vars[i].appendDecl(fProgramBuilder->shaderCaps(), out); 228 out->append(";\n"); 229 } 230} 231 232void GrGLSLShaderBuilder::addLayoutQualifier(const char* param, InterfaceQualifier interface) { 233 SkASSERT(fProgramBuilder->shaderCaps()->generation() >= k330_GrGLSLGeneration || 234 fProgramBuilder->shaderCaps()->mustEnableAdvBlendEqs()); 235 fLayoutParams[interface].push_back() = param; 236} 237 238void GrGLSLShaderBuilder::compileAndAppendLayoutQualifiers() { 239 static const char* interfaceQualifierNames[] = { 240 "in", 241 "out" 242 }; 243 244 for (int interface = 0; interface <= kLastInterfaceQualifier; ++interface) { 245 const SkTArray<SkString>& params = fLayoutParams[interface]; 246 if (params.empty()) { 247 continue; 248 } 249 this->layoutQualifiers().appendf("layout(%s", params[0].c_str()); 250 for (int i = 1; i < params.count(); ++i) { 251 this->layoutQualifiers().appendf(", %s", params[i].c_str()); 252 } 253 this->layoutQualifiers().appendf(") %s;\n", interfaceQualifierNames[interface]); 254 } 255 256 GR_STATIC_ASSERT(0 == GrGLSLShaderBuilder::kIn_InterfaceQualifier); 257 GR_STATIC_ASSERT(1 == GrGLSLShaderBuilder::kOut_InterfaceQualifier); 258 GR_STATIC_ASSERT(SK_ARRAY_COUNT(interfaceQualifierNames) == kLastInterfaceQualifier + 1); 259} 260 261void GrGLSLShaderBuilder::finalize(uint32_t visibility) { 262 SkASSERT(!fFinalized); 263 this->versionDecl() = fProgramBuilder->shaderCaps()->versionDeclString(); 264 this->compileAndAppendLayoutQualifiers(); 265 SkASSERT(visibility); 266 fProgramBuilder->appendUniformDecls((GrShaderFlags) visibility, &this->uniforms()); 267 this->appendDecls(fInputs, &this->inputs()); 268 this->appendDecls(fOutputs, &this->outputs()); 269 this->onFinalize(); 270 // append the 'footer' to code 271 this->code().append("}"); 272 273 for (int i = 0; i <= fCodeIndex; i++) { 274 fCompilerStrings[i] = fShaderStrings[i].c_str(); 275 fCompilerStringLengths[i] = (int)fShaderStrings[i].size(); 276 } 277 278 fFinalized = true; 279} 280