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 "src/gpu/glsl/GrGLSLShaderBuilder.h"
9 
10 #include "src/gpu/GrShaderCaps.h"
11 #include "src/gpu/GrShaderVar.h"
12 #include "src/gpu/GrSwizzle.h"
13 #include "src/gpu/glsl/GrGLSLColorSpaceXformHelper.h"
14 #include "src/gpu/glsl/GrGLSLProgramBuilder.h"
15 
GrGLSLShaderBuilder(GrGLSLProgramBuilder * program)16 GrGLSLShaderBuilder::GrGLSLShaderBuilder(GrGLSLProgramBuilder* program)
17     : fProgramBuilder(program)
18     , fInputs(GrGLSLProgramBuilder::kVarsPerBlock)
19     , fOutputs(GrGLSLProgramBuilder::kVarsPerBlock)
20     , fFeaturesAddedMask(0)
21     , fCodeIndex(kCode)
22     , fFinalized(false) {
23     // We push back some dummy pointers which will later become our header
24     for (int i = 0; i <= kCode; i++) {
25         fShaderStrings.push_back();
26     }
27 
28     this->main() = "void main() {";
29 }
30 
declAppend(const GrShaderVar & var)31 void GrGLSLShaderBuilder::declAppend(const GrShaderVar& var) {
32     SkString tempDecl;
33     var.appendDecl(fProgramBuilder->shaderCaps(), &tempDecl);
34     this->codeAppendf("%s;", tempDecl.c_str());
35 }
36 
declareGlobal(const GrShaderVar & v)37 void GrGLSLShaderBuilder::declareGlobal(const GrShaderVar& v) {
38     v.appendDecl(this->getProgramBuilder()->shaderCaps(), &this->definitions());
39     this->definitions().append(";");
40 }
41 
emitFunction(GrSLType returnType,const char * name,int argCnt,const GrShaderVar * args,const char * body,SkString * outName)42 void GrGLSLShaderBuilder::emitFunction(GrSLType returnType,
43                                        const char* name,
44                                        int argCnt,
45                                        const GrShaderVar* args,
46                                        const char* body,
47                                        SkString* outName) {
48     this->functions().append(GrGLSLTypeString(returnType));
49     fProgramBuilder->nameVariable(outName, '\0', name);
50     this->functions().appendf(" %s", outName->c_str());
51     this->functions().append("(");
52     for (int i = 0; i < argCnt; ++i) {
53         args[i].appendDecl(fProgramBuilder->shaderCaps(), &this->functions());
54         if (i < argCnt - 1) {
55             this->functions().append(", ");
56         }
57     }
58     this->functions().append(") {\n");
59     this->functions().append(body);
60     this->functions().append("}\n\n");
61 }
62 
append_texture_swizzle(SkString * out,GrSwizzle swizzle)63 static inline void append_texture_swizzle(SkString* out, GrSwizzle swizzle) {
64     if (swizzle != GrSwizzle::RGBA()) {
65         out->appendf(".%s", swizzle.c_str());
66     }
67 }
68 
appendTextureLookup(SkString * out,SamplerHandle samplerHandle,const char * coordName,GrSLType varyingType) const69 void GrGLSLShaderBuilder::appendTextureLookup(SkString* out,
70                                               SamplerHandle samplerHandle,
71                                               const char* coordName,
72                                               GrSLType varyingType) const {
73     const char* sampler = fProgramBuilder->samplerVariable(samplerHandle);
74     out->appendf("sample(%s, %s)", sampler, coordName);
75     append_texture_swizzle(out, fProgramBuilder->samplerSwizzle(samplerHandle));
76 }
77 
appendTextureLookup(SamplerHandle samplerHandle,const char * coordName,GrSLType varyingType,GrGLSLColorSpaceXformHelper * colorXformHelper)78 void GrGLSLShaderBuilder::appendTextureLookup(SamplerHandle samplerHandle,
79                                               const char* coordName,
80                                               GrSLType varyingType,
81                                               GrGLSLColorSpaceXformHelper* colorXformHelper) {
82     SkString lookup;
83     this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType);
84     this->appendColorGamutXform(lookup.c_str(), colorXformHelper);
85 }
86 
appendTextureLookupAndModulate(const char * modulation,SamplerHandle samplerHandle,const char * coordName,GrSLType varyingType,GrGLSLColorSpaceXformHelper * colorXformHelper)87 void GrGLSLShaderBuilder::appendTextureLookupAndModulate(
88                                                     const char* modulation,
89                                                     SamplerHandle samplerHandle,
90                                                     const char* coordName,
91                                                     GrSLType varyingType,
92                                                     GrGLSLColorSpaceXformHelper* colorXformHelper) {
93     SkString lookup;
94     this->appendTextureLookup(&lookup, samplerHandle, coordName, varyingType);
95     this->appendColorGamutXform(lookup.c_str(), colorXformHelper);
96     if (modulation) {
97         this->codeAppendf(" * %s", modulation);
98     }
99 }
100 
appendColorGamutXform(SkString * out,const char * srcColor,GrGLSLColorSpaceXformHelper * colorXformHelper)101 void GrGLSLShaderBuilder::appendColorGamutXform(SkString* out,
102                                                 const char* srcColor,
103                                                 GrGLSLColorSpaceXformHelper* colorXformHelper) {
104     if (!colorXformHelper || colorXformHelper->isNoop()) {
105         *out = srcColor;
106         return;
107     }
108 
109     GrGLSLUniformHandler* uniformHandler = fProgramBuilder->uniformHandler();
110 
111     // We define up to three helper functions, to keep things clearer. One for the source transfer
112     // function, one for the (inverse) destination transfer function, and one for the gamut xform.
113     // Any combination of these may be present, although some configurations are much more likely.
114 
115     auto emitTFFunc = [=](const char* name, GrGLSLProgramDataManager::UniformHandle uniform,
116                           TFKind kind) {
117         const GrShaderVar gTFArgs[] = { GrShaderVar("x", kHalf_GrSLType) };
118         const char* coeffs = uniformHandler->getUniformCStr(uniform);
119         SkString body;
120         // Temporaries to make evaluation line readable. We always use the sRGBish names, so the
121         // PQ and HLG math is confusing.
122         body.appendf("half G = %s[0];", coeffs);
123         body.appendf("half A = %s[1];", coeffs);
124         body.appendf("half B = %s[2];", coeffs);
125         body.appendf("half C = %s[3];", coeffs);
126         body.appendf("half D = %s[4];", coeffs);
127         body.appendf("half E = %s[5];", coeffs);
128         body.appendf("half F = %s[6];", coeffs);
129         body.append("half s = sign(x);");
130         body.append("x = abs(x);");
131         switch (kind) {
132             case TFKind::sRGBish_TF:
133                 body.append("x = (x < D) ? (C * x) + F : pow(A * x + B, G) + E;");
134                 break;
135             case TFKind::PQish_TF:
136                 body.append("x = pow(max(A + B * pow(x, C), 0) / (D + E * pow(x, C)), F);");
137                 break;
138             case TFKind::HLGish_TF:
139                 body.append("x = (x*A <= 1) ? pow(x*A, B) : exp((x-E)*C) + D;");
140                 break;
141             case TFKind::HLGinvish_TF:
142                 body.append("x = (x <= 1) ? A * pow(x, B) : C * log(x - D) + E;");
143                 break;
144             default:
145                 SkASSERT(false);
146                 break;
147         }
148         body.append("return s * x;");
149         SkString funcName;
150         this->emitFunction(kHalf_GrSLType, name, SK_ARRAY_COUNT(gTFArgs), gTFArgs, body.c_str(),
151                            &funcName);
152         return funcName;
153     };
154 
155     SkString srcTFFuncName;
156     if (colorXformHelper->applySrcTF()) {
157         srcTFFuncName = emitTFFunc("src_tf", colorXformHelper->srcTFUniform(),
158                                    colorXformHelper->srcTFKind());
159     }
160 
161     SkString dstTFFuncName;
162     if (colorXformHelper->applyDstTF()) {
163         dstTFFuncName = emitTFFunc("dst_tf", colorXformHelper->dstTFUniform(),
164                                    colorXformHelper->dstTFKind());
165     }
166 
167     SkString gamutXformFuncName;
168     if (colorXformHelper->applyGamutXform()) {
169         const GrShaderVar gGamutXformArgs[] = { GrShaderVar("color", kHalf4_GrSLType) };
170         const char* xform = uniformHandler->getUniformCStr(colorXformHelper->gamutXformUniform());
171         SkString body;
172         body.appendf("color.rgb = (%s * color.rgb);", xform);
173         body.append("return color;");
174         this->emitFunction(kHalf4_GrSLType, "gamut_xform", SK_ARRAY_COUNT(gGamutXformArgs),
175                            gGamutXformArgs, body.c_str(), &gamutXformFuncName);
176     }
177 
178     // Now define a wrapper function that applies all the intermediate steps
179     {
180         const GrShaderVar gColorXformArgs[] = { GrShaderVar("color", kHalf4_GrSLType) };
181         SkString body;
182         if (colorXformHelper->applyUnpremul()) {
183             body.append("half nonZeroAlpha = max(color.a, 0.0001);");
184             body.append("color = half4(color.rgb / nonZeroAlpha, nonZeroAlpha);");
185         }
186         if (colorXformHelper->applySrcTF()) {
187             body.appendf("color.r = %s(color.r);", srcTFFuncName.c_str());
188             body.appendf("color.g = %s(color.g);", srcTFFuncName.c_str());
189             body.appendf("color.b = %s(color.b);", srcTFFuncName.c_str());
190         }
191         if (colorXformHelper->applyGamutXform()) {
192             body.appendf("color = %s(color);", gamutXformFuncName.c_str());
193         }
194         if (colorXformHelper->applyDstTF()) {
195             body.appendf("color.r = %s(color.r);", dstTFFuncName.c_str());
196             body.appendf("color.g = %s(color.g);", dstTFFuncName.c_str());
197             body.appendf("color.b = %s(color.b);", dstTFFuncName.c_str());
198         }
199         if (colorXformHelper->applyPremul()) {
200             body.append("color.rgb *= color.a;");
201         }
202         body.append("return color;");
203         SkString colorXformFuncName;
204         this->emitFunction(kHalf4_GrSLType, "color_xform", SK_ARRAY_COUNT(gColorXformArgs),
205                            gColorXformArgs, body.c_str(), &colorXformFuncName);
206         out->appendf("%s(%s)", colorXformFuncName.c_str(), srcColor);
207     }
208 }
209 
appendColorGamutXform(const char * srcColor,GrGLSLColorSpaceXformHelper * colorXformHelper)210 void GrGLSLShaderBuilder::appendColorGamutXform(const char* srcColor,
211                                                 GrGLSLColorSpaceXformHelper* colorXformHelper) {
212     SkString xform;
213     this->appendColorGamutXform(&xform, srcColor, colorXformHelper);
214     this->codeAppend(xform.c_str());
215 }
216 
addFeature(uint32_t featureBit,const char * extensionName)217 bool GrGLSLShaderBuilder::addFeature(uint32_t featureBit, const char* extensionName) {
218     if (featureBit & fFeaturesAddedMask) {
219         return false;
220     }
221     this->extensions().appendf("#extension %s: require\n", extensionName);
222     fFeaturesAddedMask |= featureBit;
223     return true;
224 }
225 
appendDecls(const VarArray & vars,SkString * out) const226 void GrGLSLShaderBuilder::appendDecls(const VarArray& vars, SkString* out) const {
227     for (int i = 0; i < vars.count(); ++i) {
228         vars[i].appendDecl(fProgramBuilder->shaderCaps(), out);
229         out->append(";\n");
230     }
231 }
232 
addLayoutQualifier(const char * param,InterfaceQualifier interface)233 void GrGLSLShaderBuilder::addLayoutQualifier(const char* param, InterfaceQualifier interface) {
234     SkASSERT(fProgramBuilder->shaderCaps()->generation() >= k330_GrGLSLGeneration ||
235              fProgramBuilder->shaderCaps()->mustEnableAdvBlendEqs());
236     fLayoutParams[interface].push_back() = param;
237 }
238 
compileAndAppendLayoutQualifiers()239 void GrGLSLShaderBuilder::compileAndAppendLayoutQualifiers() {
240     static const char* interfaceQualifierNames[] = {
241         "in",
242         "out"
243     };
244 
245     for (int interface = 0; interface <= kLastInterfaceQualifier; ++interface) {
246         const SkTArray<SkString>& params = fLayoutParams[interface];
247         if (params.empty()) {
248             continue;
249         }
250         this->layoutQualifiers().appendf("layout(%s", params[0].c_str());
251         for (int i = 1; i < params.count(); ++i) {
252             this->layoutQualifiers().appendf(", %s", params[i].c_str());
253         }
254         this->layoutQualifiers().appendf(") %s;\n", interfaceQualifierNames[interface]);
255     }
256 
257     GR_STATIC_ASSERT(0 == GrGLSLShaderBuilder::kIn_InterfaceQualifier);
258     GR_STATIC_ASSERT(1 == GrGLSLShaderBuilder::kOut_InterfaceQualifier);
259     GR_STATIC_ASSERT(SK_ARRAY_COUNT(interfaceQualifierNames) == kLastInterfaceQualifier + 1);
260 }
261 
finalize(uint32_t visibility)262 void GrGLSLShaderBuilder::finalize(uint32_t visibility) {
263     SkASSERT(!fFinalized);
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         fCompilerString.append(fShaderStrings[i].c_str(), fShaderStrings[i].size());
275     }
276 
277     fFinalized = true;
278 }
279