1/*
2* Copyright 2015 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 "GrFragmentProcessor.h"
9#include "GrCoordTransform.h"
10#include "GrPipeline.h"
11#include "GrPipelineAnalysis.h"
12#include "effects/GrConstColorProcessor.h"
13#include "effects/GrXfermodeFragmentProcessor.h"
14#include "glsl/GrGLSLFragmentProcessor.h"
15#include "glsl/GrGLSLFragmentShaderBuilder.h"
16#include "glsl/GrGLSLProgramDataManager.h"
17#include "glsl/GrGLSLUniformHandler.h"
18
19GrFragmentProcessor::~GrFragmentProcessor() {
20    // If we got here then our ref count must have reached zero, so we will have converted refs
21    // to pending executions for all children.
22    for (int i = 0; i < fChildProcessors.count(); ++i) {
23        fChildProcessors[i]->completedExecution();
24    }
25}
26
27bool GrFragmentProcessor::isEqual(const GrFragmentProcessor& that) const {
28    if (this->classID() != that.classID() ||
29        !this->hasSameSamplersAndAccesses(that)) {
30        return false;
31    }
32    if (!this->hasSameTransforms(that)) {
33        return false;
34    }
35    if (!this->onIsEqual(that)) {
36        return false;
37    }
38    if (this->numChildProcessors() != that.numChildProcessors()) {
39        return false;
40    }
41    for (int i = 0; i < this->numChildProcessors(); ++i) {
42        if (!this->childProcessor(i).isEqual(that.childProcessor(i))) {
43            return false;
44        }
45    }
46    return true;
47}
48
49GrGLSLFragmentProcessor* GrFragmentProcessor::createGLSLInstance() const {
50    GrGLSLFragmentProcessor* glFragProc = this->onCreateGLSLInstance();
51    glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
52    for (int i = 0; i < fChildProcessors.count(); ++i) {
53        glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLSLInstance();
54    }
55    return glFragProc;
56}
57
58void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
59    fCoordTransforms.push_back(transform);
60    fFlags |= kUsesLocalCoords_Flag;
61    SkDEBUGCODE(transform->setInProcessor();)
62}
63
64int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
65    this->combineRequiredFeatures(*child);
66
67    if (child->usesLocalCoords()) {
68        fFlags |= kUsesLocalCoords_Flag;
69    }
70    if (child->usesDistanceVectorField()) {
71        fFlags |= kUsesDistanceVectorField_Flag;
72    }
73
74    int index = fChildProcessors.count();
75    fChildProcessors.push_back(child.release());
76
77    return index;
78}
79
80void GrFragmentProcessor::notifyRefCntIsZero() const {
81    // See comment above GrProgramElement for a detailed explanation of why we do this.
82    for (int i = 0; i < fChildProcessors.count(); ++i) {
83        fChildProcessors[i]->addPendingExecution();
84        fChildProcessors[i]->unref();
85    }
86}
87
88bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
89    if (this->numCoordTransforms() != that.numCoordTransforms()) {
90        return false;
91    }
92    int count = this->numCoordTransforms();
93    for (int i = 0; i < count; ++i) {
94        if (!this->coordTransform(i).hasSameEffectAs(that.coordTransform(i))) {
95            return false;
96        }
97    }
98    return true;
99}
100
101sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
102    sk_sp<GrFragmentProcessor> fp) {
103    if (!fp) {
104        return nullptr;
105    }
106    return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp), SkBlendMode::kDstIn);
107}
108
109namespace {
110
111class PremulInputFragmentProcessor : public GrFragmentProcessor {
112public:
113    PremulInputFragmentProcessor()
114            : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
115                        kConstantOutputForConstantInput_OptimizationFlag) {
116        this->initClassID<PremulInputFragmentProcessor>();
117    }
118
119    const char* name() const override { return "PremultiplyInput"; }
120
121private:
122    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
123        class GLFP : public GrGLSLFragmentProcessor {
124        public:
125            void emitCode(EmitArgs& args) override {
126                GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
127
128                fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
129                fragBuilder->codeAppendf("%s.rgb *= %s.a;",
130                                            args.fOutputColor, args.fInputColor);
131            }
132        };
133        return new GLFP;
134    }
135
136    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
137
138    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
139
140    GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
141        return input.premul();
142    }
143
144    typedef GrFragmentProcessor INHERITED;
145};
146
147class UnpremulInputFragmentProcessor : public GrFragmentProcessor {
148public:
149    UnpremulInputFragmentProcessor()
150            : INHERITED(kPreservesOpaqueInput_OptimizationFlag |
151                        kConstantOutputForConstantInput_OptimizationFlag) {
152        this->initClassID<UnpremulInputFragmentProcessor>();
153    }
154
155    const char* name() const override { return "UnpremultiplyInput"; }
156
157private:
158    GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
159        class GLFP : public GrGLSLFragmentProcessor {
160        public:
161            void emitCode(EmitArgs& args) override {
162                GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
163
164                fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
165                fragBuilder->codeAppendf("float invAlpha = %s.a <= 0.0 ? 0.0 : 1.0 / %s.a;",
166                                         args.fInputColor, args.fInputColor);
167                fragBuilder->codeAppendf("%s.rgb *= invAlpha;", args.fOutputColor);
168            }
169        };
170        return new GLFP;
171    }
172
173    void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
174
175    bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
176
177    GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
178        return input.unpremul();
179    }
180
181    typedef GrFragmentProcessor INHERITED;
182};
183
184}
185
186sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProcessor> fp) {
187    if (!fp) {
188        return nullptr;
189    }
190    sk_sp<GrFragmentProcessor> fpPipeline[] = { sk_make_sp<PremulInputFragmentProcessor>(), fp};
191    return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
192}
193
194sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulOutput(sk_sp<GrFragmentProcessor> fp) {
195    if (!fp) {
196        return nullptr;
197    }
198    sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, sk_make_sp<PremulInputFragmentProcessor>() };
199    return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
200}
201
202sk_sp<GrFragmentProcessor> GrFragmentProcessor::UnpremulOutput(sk_sp<GrFragmentProcessor> fp) {
203    if (!fp) {
204        return nullptr;
205    }
206    sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, sk_make_sp<UnpremulInputFragmentProcessor>() };
207    return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
208}
209
210sk_sp<GrFragmentProcessor> GrFragmentProcessor::SwizzleOutput(sk_sp<GrFragmentProcessor> fp,
211                                                              const GrSwizzle& swizzle) {
212    class SwizzleFragmentProcessor : public GrFragmentProcessor {
213    public:
214        SwizzleFragmentProcessor(const GrSwizzle& swizzle)
215                : INHERITED(kAll_OptimizationFlags)
216                , fSwizzle(swizzle) {
217            this->initClassID<SwizzleFragmentProcessor>();
218        }
219
220        const char* name() const override { return "Swizzle"; }
221        const GrSwizzle& swizzle() const { return fSwizzle; }
222
223    private:
224        GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
225            class GLFP : public GrGLSLFragmentProcessor {
226            public:
227                void emitCode(EmitArgs& args) override {
228                    const SwizzleFragmentProcessor& sfp = args.fFp.cast<SwizzleFragmentProcessor>();
229                    const GrSwizzle& swizzle = sfp.swizzle();
230                    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
231
232                    fragBuilder->codeAppendf("%s = %s.%s;",
233                                             args.fOutputColor, args.fInputColor, swizzle.c_str());
234                }
235            };
236            return new GLFP;
237        }
238
239        void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
240            b->add32(fSwizzle.asKey());
241        }
242
243        bool onIsEqual(const GrFragmentProcessor& other) const override {
244            const SwizzleFragmentProcessor& sfp = other.cast<SwizzleFragmentProcessor>();
245            return fSwizzle == sfp.fSwizzle;
246        }
247
248        GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
249            return fSwizzle.applyTo(input);
250        }
251
252        GrSwizzle fSwizzle;
253
254        typedef GrFragmentProcessor INHERITED;
255    };
256
257    if (!fp) {
258        return nullptr;
259    }
260    if (GrSwizzle::RGBA() == swizzle) {
261        return fp;
262    }
263    sk_sp<GrFragmentProcessor> fpPipeline[] = { fp, sk_make_sp<SwizzleFragmentProcessor>(swizzle) };
264    return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
265}
266
267sk_sp<GrFragmentProcessor> GrFragmentProcessor::MakeInputPremulAndMulByOutput(
268        sk_sp<GrFragmentProcessor> fp) {
269
270    class PremulFragmentProcessor : public GrFragmentProcessor {
271    public:
272        PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor)
273                : INHERITED(OptFlags(processor.get())) {
274            this->initClassID<PremulFragmentProcessor>();
275            this->registerChildProcessor(processor);
276        }
277
278        const char* name() const override { return "Premultiply"; }
279
280    private:
281        GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
282            class GLFP : public GrGLSLFragmentProcessor {
283            public:
284                void emitCode(EmitArgs& args) override {
285                    GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
286                    this->emitChild(0, nullptr, args);
287                    fragBuilder->codeAppendf("%s.rgb *= %s.rgb;", args.fOutputColor,
288                                                                args.fInputColor);
289                    fragBuilder->codeAppendf("%s *= %s.a;", args.fOutputColor, args.fInputColor);
290                }
291            };
292            return new GLFP;
293        }
294
295        void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
296
297        bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
298
299        static OptimizationFlags OptFlags(const GrFragmentProcessor* inner) {
300            OptimizationFlags flags = kNone_OptimizationFlags;
301            if (inner->preservesOpaqueInput()) {
302                flags |= kPreservesOpaqueInput_OptimizationFlag;
303            }
304            if (inner->hasConstantOutputForConstantInput()) {
305                flags |= kConstantOutputForConstantInput_OptimizationFlag;
306            }
307            return flags;
308        }
309
310        GrColor4f constantOutputForConstantInput(GrColor4f input) const override {
311            GrColor4f childColor = ConstantOutputForConstantInput(this->childProcessor(0),
312                                                                  GrColor4f::OpaqueWhite());
313            return GrColor4f(input.fRGBA[3] * input.fRGBA[0] * childColor.fRGBA[0],
314                             input.fRGBA[3] * input.fRGBA[1] * childColor.fRGBA[1],
315                             input.fRGBA[3] * input.fRGBA[2] * childColor.fRGBA[2],
316                             input.fRGBA[3] * childColor.fRGBA[3]);
317        }
318
319        typedef GrFragmentProcessor INHERITED;
320    };
321    if (!fp) {
322        return nullptr;
323    }
324    return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(fp)));
325}
326
327//////////////////////////////////////////////////////////////////////////////
328
329sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
330                                                              GrColor4f color) {
331    class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
332    public:
333        ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
334                : INHERITED(OptFlags(child.get(), color)), fColor(color) {
335            this->initClassID<ReplaceInputFragmentProcessor>();
336            this->registerChildProcessor(std::move(child));
337        }
338
339        const char* name() const override { return "Replace Color"; }
340
341        GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
342            class GLFP : public GrGLSLFragmentProcessor {
343            public:
344                GLFP() : fHaveSetColor(false) {}
345                void emitCode(EmitArgs& args) override {
346                    const char* colorName;
347                    fColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
348                                                                 kVec4f_GrSLType,
349                                                                 kDefault_GrSLPrecision,
350                                                                 "Color", &colorName);
351                    this->emitChild(0, colorName, args);
352                }
353
354            private:
355                void onSetData(const GrGLSLProgramDataManager& pdman,
356                               const GrProcessor& fp) override {
357                    GrColor4f color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
358                    if (!fHaveSetColor || color != fPreviousColor) {
359                        pdman.set4fv(fColorUni, 1, color.fRGBA);
360                        fPreviousColor = color;
361                        fHaveSetColor = true;
362                    }
363                }
364
365                GrGLSLProgramDataManager::UniformHandle fColorUni;
366                bool      fHaveSetColor;
367                GrColor4f fPreviousColor;
368            };
369
370            return new GLFP;
371        }
372
373    private:
374        static OptimizationFlags OptFlags(const GrFragmentProcessor* child, GrColor4f color) {
375            OptimizationFlags childFlags = child->optimizationFlags();
376            OptimizationFlags flags = kNone_OptimizationFlags;
377            if (childFlags & kConstantOutputForConstantInput_OptimizationFlag) {
378                flags |= kConstantOutputForConstantInput_OptimizationFlag;
379            }
380            if ((childFlags & kPreservesOpaqueInput_OptimizationFlag) && color.isOpaque()) {
381                flags |= kPreservesOpaqueInput_OptimizationFlag;
382            }
383            return flags;
384        }
385
386        void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override
387        {}
388
389        bool onIsEqual(const GrFragmentProcessor& that) const override {
390            return fColor == that.cast<ReplaceInputFragmentProcessor>().fColor;
391        }
392
393        GrColor4f constantOutputForConstantInput(GrColor4f) const override {
394            return ConstantOutputForConstantInput(this->childProcessor(0), fColor);
395        }
396
397        GrColor4f fColor;
398
399        typedef GrFragmentProcessor INHERITED;
400    };
401
402    return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
403}
404
405sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
406                                                            int cnt) {
407    class SeriesFragmentProcessor : public GrFragmentProcessor {
408    public:
409        SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt)
410                : INHERITED(OptFlags(children, cnt)) {
411            SkASSERT(cnt > 1);
412            this->initClassID<SeriesFragmentProcessor>();
413            for (int i = 0; i < cnt; ++i) {
414                this->registerChildProcessor(std::move(children[i]));
415            }
416        }
417
418        const char* name() const override { return "Series"; }
419
420        GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
421            class GLFP : public GrGLSLFragmentProcessor {
422            public:
423                void emitCode(EmitArgs& args) override {
424                    // First guy's input might be nil.
425                    SkString temp("out0");
426                    this->emitChild(0, args.fInputColor, &temp, args);
427                    SkString input = temp;
428                    for (int i = 1; i < this->numChildProcessors() - 1; ++i) {
429                        temp.printf("out%d", i);
430                        this->emitChild(i, input.c_str(), &temp, args);
431                        input = temp;
432                    }
433                    // Last guy writes to our output variable.
434                    this->emitChild(this->numChildProcessors() - 1, input.c_str(), args);
435                }
436            };
437            return new GLFP;
438        }
439    private:
440        static OptimizationFlags OptFlags(sk_sp<GrFragmentProcessor>* children, int cnt) {
441            OptimizationFlags flags = kAll_OptimizationFlags;
442            for (int i = 0; i < cnt && flags != kNone_OptimizationFlags; ++i) {
443                flags &= children[i]->optimizationFlags();
444            }
445            return flags;
446        }
447        void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
448
449        bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
450
451        GrColor4f constantOutputForConstantInput(GrColor4f color) const override {
452            int childCnt = this->numChildProcessors();
453            for (int i = 0; i < childCnt; ++i) {
454                color = ConstantOutputForConstantInput(this->childProcessor(i), color);
455            }
456            return color;
457        }
458
459        typedef GrFragmentProcessor INHERITED;
460    };
461
462    if (!cnt) {
463        return nullptr;
464    }
465    if (1 == cnt) {
466        return series[0];
467    }
468    // Run the through the series, do the invariant output processing, and look for eliminations.
469    GrColorFragmentProcessorAnalysis info;
470    info.analyzeProcessors(sk_sp_address_as_pointer_address(series), cnt);
471    SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries;
472    GrColor4f knownColor;
473    int leadingFPsToEliminate = info.initialProcessorsToEliminate(&knownColor);
474    if (leadingFPsToEliminate) {
475        sk_sp<GrFragmentProcessor> colorFP(
476                GrConstColorProcessor::Make(knownColor, GrConstColorProcessor::kIgnore_InputMode));
477        if (leadingFPsToEliminate == cnt) {
478            return colorFP;
479        }
480        cnt = cnt - leadingFPsToEliminate + 1;
481        replacementSeries.reserve(cnt);
482        replacementSeries.emplace_back(std::move(colorFP));
483        for (int i = 0; i < cnt - 1; ++i) {
484            replacementSeries.emplace_back(std::move(series[leadingFPsToEliminate + i]));
485        }
486        series = replacementSeries.begin();
487    }
488    return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
489}
490
491//////////////////////////////////////////////////////////////////////////////
492
493GrFragmentProcessor::Iter::Iter(const GrPipeline& pipeline) {
494    for (int i = pipeline.numFragmentProcessors() - 1; i >= 0; --i) {
495        fFPStack.push_back(&pipeline.getFragmentProcessor(i));
496    }
497}
498
499const GrFragmentProcessor* GrFragmentProcessor::Iter::next() {
500    if (fFPStack.empty()) {
501        return nullptr;
502    }
503    const GrFragmentProcessor* back = fFPStack.back();
504    fFPStack.pop_back();
505    for (int i = back->numChildProcessors() - 1; i >= 0; --i) {
506        fFPStack.push_back(&back->childProcessor(i));
507    }
508    return back;
509}
510
511