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