src/gpu/GrFragmentProcessor.cpp - skia - Git at Google

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

 #include "GrFragmentProcessor.h"
 #include "GrCoordTransform.h"
 #include "GrInvariantOutput.h"
 #include "GrPipeline.h"
 #include "GrProcOptInfo.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLFragmentShaderBuilder.h"
 #include "glsl/GrGLSLProgramDataManager.h"
 #include "glsl/GrGLSLUniformHandler.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"

 GrFragmentProcessor::~GrFragmentProcessor() {
     // If we got here then our ref count must have reached zero, so we will have converted refs
     // to pending executions for all children.
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         fChildProcessors[i]->completedExecution();
     }
 }

 bool GrFragmentProcessor::isEqual(const GrFragmentProcessor& that) const {
     if (this->classID() != that.classID() ||
         !this->hasSameSamplersAndAccesses(that)) {
         return false;
     }
     if (!this->hasSameTransforms(that)) {
         return false;
     }
     if (!this->onIsEqual(that)) {
         return false;
     }
     if (this->numChildProcessors() != that.numChildProcessors()) {
         return false;
     }
     for (int i = 0; i < this->numChildProcessors(); ++i) {
         if (!this->childProcessor(i).isEqual(that.childProcessor(i))) {
             return false;
         }
     }
     return true;
 }

 GrGLSLFragmentProcessor* GrFragmentProcessor::createGLSLInstance() const {
     GrGLSLFragmentProcessor* glFragProc = this->onCreateGLSLInstance();
     glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLSLInstance();
     }
     return glFragProc;
 }

 void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
     fCoordTransforms.push_back(transform);
     fUsesLocalCoords = true;
     SkDEBUGCODE(transform->setInProcessor();)
 }

 int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
     this->combineRequiredFeatures(*child);

     if (child->usesLocalCoords()) {
         fUsesLocalCoords = true;
     }
     if (child->usesDistanceVectorField()) {
         fUsesDistanceVectorField = true;
     }

     int index = fChildProcessors.count();
     fChildProcessors.push_back(child.release());

     return index;
 }

 void GrFragmentProcessor::notifyRefCntIsZero() const {
     // See comment above GrProgramElement for a detailed explanation of why we do this.
     for (int i = 0; i < fChildProcessors.count(); ++i) {
         fChildProcessors[i]->addPendingExecution();
         fChildProcessors[i]->unref();
     }
 }

 bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
     if (this->numCoordTransforms() != that.numCoordTransforms()) {
         return false;
     }
     int count = this->numCoordTransforms();
     for (int i = 0; i < count; ++i) {
         if (this->coordTransform(i) != that.coordTransform(i)) {
             return false;
         }
     }
     return true;
 }

 sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
     sk_sp<GrFragmentProcessor> fp) {
     if (!fp) {
         return nullptr;
     }
     return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp), SkBlendMode::kDstIn);
 }

 sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProcessor> fp) {

     class PremulInputFragmentProcessor : public GrFragmentProcessor {
     public:
         PremulInputFragmentProcessor() {
             this->initClassID<PremulInputFragmentProcessor>();
         }

         const char* name() const override { return "PremultiplyInput"; }

     private:
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 void emitCode(EmitArgs& args) override {
                     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

                     fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
                     fragBuilder->codeAppendf("%s.rgb *= %s.a;",
                                              args.fOutputColor, args.fInputColor);
                 }
             };
             return new GLFP;
         }

         void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             inout->premulFourChannelColor();
         }
     };
     if (!fp) {
         return nullptr;
     }
     sk_sp<GrFragmentProcessor> fpPipeline[] = { sk_make_sp<PremulInputFragmentProcessor>(), fp};
     return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
 }

 sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
     sk_sp<GrFragmentProcessor> fp) {

     class PremulFragmentProcessor : public GrFragmentProcessor {
     public:
         PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor) {
             this->initClassID<PremulFragmentProcessor>();
             this->registerChildProcessor(processor);
         }

         const char* name() const override { return "Premultiply"; }

     private:
         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 void emitCode(EmitArgs& args) override {
                     GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
                     this->emitChild(0, nullptr, args);
                     fragBuilder->codeAppendf("%s.rgb *= %s.rgb;", args.fOutputColor,
                                                                 args.fInputColor);
                     fragBuilder->codeAppendf("%s *= %s.a;", args.fOutputColor, args.fInputColor);
                 }
             };
             return new GLFP;
         }

         void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             // TODO: Add a helper to GrInvariantOutput that handles multiplying by color with flags?
             if (!(inout->validFlags() & kA_GrColorComponentFlag)) {
                 inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
                 return;
             }

             GrInvariantOutput childOutput(GrColor_WHITE, kRGBA_GrColorComponentFlags);
             this->childProcessor(0).computeInvariantOutput(&childOutput);

             if (0 == GrColorUnpackA(inout->color()) || 0 == GrColorUnpackA(childOutput.color())) {
                 inout->mulByKnownFourComponents(0x0);
                 return;
             }
             GrColorComponentFlags commonFlags = childOutput.validFlags() & inout->validFlags();
             GrColor c0 = GrPremulColor(inout->color());
             GrColor c1 = childOutput.color();
             GrColor color = 0x0;
             if (commonFlags & kR_GrColorComponentFlag) {
                 color |= SkMulDiv255Round(GrColorUnpackR(c0), GrColorUnpackR(c1)) <<
                     GrColor_SHIFT_R;
             }
             if (commonFlags & kG_GrColorComponentFlag) {
                 color |= SkMulDiv255Round(GrColorUnpackG(c0), GrColorUnpackG(c1)) <<
                     GrColor_SHIFT_G;
             }
             if (commonFlags & kB_GrColorComponentFlag) {
                 color |= SkMulDiv255Round(GrColorUnpackB(c0), GrColorUnpackB(c1)) <<
                     GrColor_SHIFT_B;
             }
             inout->setToOther(commonFlags, color, GrInvariantOutput::kWill_ReadInput);
         }
     };
     if (!fp) {
         return nullptr;
     }
     return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(fp)));
 }

 //////////////////////////////////////////////////////////////////////////////

 sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
                                                               GrColor4f color) {
     class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
     public:
         ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
             : fColor(color) {
             this->initClassID<ReplaceInputFragmentProcessor>();
             this->registerChildProcessor(std::move(child));
         }

         const char* name() const override { return "Replace Color"; }

         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 GLFP() : fHaveSetColor(false) {}
                 void emitCode(EmitArgs& args) override {
                     const char* colorName;
                     fColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
                                                                  kVec4f_GrSLType,
                                                                  kDefault_GrSLPrecision,
                                                                  "Color", &colorName);
                     this->emitChild(0, colorName, args);
                 }

             private:
                 void onSetData(const GrGLSLProgramDataManager& pdman,
                                const GrProcessor& fp) override {
                     GrColor4f color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
                     if (!fHaveSetColor || color != fPreviousColor) {
                         pdman.set4fv(fColorUni, 1, color.fRGBA);
                         fPreviousColor = color;
                         fHaveSetColor = true;
                     }
                 }

                 GrGLSLProgramDataManager::UniformHandle fColorUni;
                 bool      fHaveSetColor;
                 GrColor4f fPreviousColor;
             };

             return new GLFP;
         }

     private:
         void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override
         {}

         bool onIsEqual(const GrFragmentProcessor& that) const override {
             return fColor == that.cast<ReplaceInputFragmentProcessor>().fColor;
         }

         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor(),
                               GrInvariantOutput::kWillNot_ReadInput);
             this->childProcessor(0).computeInvariantOutput(inout);
         }

         GrColor4f fColor;
     };

     GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags);
     fp->computeInvariantOutput(&childOut);
     if (childOut.willUseInputColor()) {
         return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
     } else {
         return fp;
     }
 }

 sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
                                                             int cnt) {
     class SeriesFragmentProcessor : public GrFragmentProcessor {
     public:
         SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt){
             SkASSERT(cnt > 1);
             this->initClassID<SeriesFragmentProcessor>();
             for (int i = 0; i < cnt; ++i) {
                 this->registerChildProcessor(std::move(children[i]));
             }
         }

         const char* name() const override { return "Series"; }

         GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
             class GLFP : public GrGLSLFragmentProcessor {
             public:
                 void emitCode(EmitArgs& args) override {
                     // First guy's input might be nil.
                     SkString temp("out0");
                     this->emitChild(0, args.fInputColor, &temp, args);
                     SkString input = temp;
                     for (int i = 1; i < this->numChildProcessors() - 1; ++i) {
                         temp.printf("out%d", i);
                         this->emitChild(i, input.c_str(), &temp, args);
                         input = temp;
                     }
                     // Last guy writes to our output variable.
                     this->emitChild(this->numChildProcessors() - 1, input.c_str(), args);
                 }
             };
             return new GLFP;
         }

     private:
         void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

         bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

         void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
             for (int i = 0; i < this->numChildProcessors(); ++i) {
                 this->childProcessor(i).computeInvariantOutput(inout);
             }
         }
     };

     if (!cnt) {
         return nullptr;
     }

     // Run the through the series, do the invariant output processing, and look for eliminations.
     GrProcOptInfo info(0x0, kNone_GrColorComponentFlags);
     info.analyzeProcessors(sk_sp_address_as_pointer_address(series), cnt);
     if (kRGBA_GrColorComponentFlags == info.validFlags()) {
         // TODO: We need to preserve 4f and color spaces during invariant processing. This color
         // has definitely lost precision, and could easily be in the wrong gamut (or have been
         // built from colors in multiple spaces).
         return GrConstColorProcessor::Make(GrColor4f::FromGrColor(info.color()),
                                            GrConstColorProcessor::kIgnore_InputMode);
     }

     SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries;

     int firstIdx = info.firstEffectiveProcessorIndex();
     cnt -= firstIdx;
     if (firstIdx > 0 && info.inputColorIsUsed()) {
         // See comment above - need to preserve 4f and color spaces during invariant processing.
         sk_sp<GrFragmentProcessor> colorFP(GrConstColorProcessor::Make(
             GrColor4f::FromGrColor(info.inputColorToFirstEffectiveProccesor()),
             GrConstColorProcessor::kIgnore_InputMode));
         cnt += 1;
         replacementSeries.reserve(cnt);
         replacementSeries.emplace_back(std::move(colorFP));
         for (int i = 0; i < cnt - 1; ++i) {
             replacementSeries.emplace_back(std::move(series[firstIdx + i]));
         }
         series = replacementSeries.begin();
     } else {
         series += firstIdx;
         cnt -= firstIdx;
     }

     if (1 == cnt) {
         return series[0];
     }
     return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
 }

 //////////////////////////////////////////////////////////////////////////////

 GrFragmentProcessor::Iter::Iter(const GrPipeline& pipeline) {
     for (int i = pipeline.numFragmentProcessors() - 1; i >= 0; --i) {
         fFPStack.push_back(&pipeline.getFragmentProcessor(i));
     }
 }

 const GrFragmentProcessor* GrFragmentProcessor::Iter::next() {
     if (fFPStack.empty()) {
         return nullptr;
     }
     const GrFragmentProcessor* back = fFPStack.back();
     fFPStack.pop_back();
     for (int i = back->numChildProcessors() - 1; i >= 0; --i) {
         fFPStack.push_back(&back->childProcessor(i));
     }
     return back;
 }
	/*
	* Copyright 2015 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "GrFragmentProcessor.h"
	#include "GrCoordTransform.h"
	#include "GrInvariantOutput.h"
	#include "GrPipeline.h"
	#include "GrProcOptInfo.h"
	#include "glsl/GrGLSLFragmentProcessor.h"
	#include "glsl/GrGLSLFragmentShaderBuilder.h"
	#include "glsl/GrGLSLProgramDataManager.h"
	#include "glsl/GrGLSLUniformHandler.h"
	#include "effects/GrConstColorProcessor.h"
	#include "effects/GrXfermodeFragmentProcessor.h"

	GrFragmentProcessor::~GrFragmentProcessor() {
	// If we got here then our ref count must have reached zero, so we will have converted refs
	// to pending executions for all children.
	for (int i = 0; i < fChildProcessors.count(); ++i) {
	fChildProcessors[i]->completedExecution();
	}
	}

	bool GrFragmentProcessor::isEqual(const GrFragmentProcessor& that) const {
	if (this->classID() != that.classID() \|\|
	!this->hasSameSamplersAndAccesses(that)) {
	return false;
	}
	if (!this->hasSameTransforms(that)) {
	return false;
	}
	if (!this->onIsEqual(that)) {
	return false;
	}
	if (this->numChildProcessors() != that.numChildProcessors()) {
	return false;
	}
	for (int i = 0; i < this->numChildProcessors(); ++i) {
	if (!this->childProcessor(i).isEqual(that.childProcessor(i))) {
	return false;
	}
	}
	return true;
	}

	GrGLSLFragmentProcessor* GrFragmentProcessor::createGLSLInstance() const {
	GrGLSLFragmentProcessor* glFragProc = this->onCreateGLSLInstance();
	glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
	for (int i = 0; i < fChildProcessors.count(); ++i) {
	glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLSLInstance();
	}
	return glFragProc;
	}

	void GrFragmentProcessor::addCoordTransform(const GrCoordTransform* transform) {
	fCoordTransforms.push_back(transform);
	fUsesLocalCoords = true;
	SkDEBUGCODE(transform->setInProcessor();)
	}

	int GrFragmentProcessor::registerChildProcessor(sk_sp<GrFragmentProcessor> child) {
	this->combineRequiredFeatures(*child);

	if (child->usesLocalCoords()) {
	fUsesLocalCoords = true;
	}
	if (child->usesDistanceVectorField()) {
	fUsesDistanceVectorField = true;
	}

	int index = fChildProcessors.count();
	fChildProcessors.push_back(child.release());

	return index;
	}

	void GrFragmentProcessor::notifyRefCntIsZero() const {
	// See comment above GrProgramElement for a detailed explanation of why we do this.
	for (int i = 0; i < fChildProcessors.count(); ++i) {
	fChildProcessors[i]->addPendingExecution();
	fChildProcessors[i]->unref();
	}
	}

	bool GrFragmentProcessor::hasSameTransforms(const GrFragmentProcessor& that) const {
	if (this->numCoordTransforms() != that.numCoordTransforms()) {
	return false;
	}
	int count = this->numCoordTransforms();
	for (int i = 0; i < count; ++i) {
	if (this->coordTransform(i) != that.coordTransform(i)) {
	return false;
	}
	}
	return true;
	}

	sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputAlpha(
	sk_sp<GrFragmentProcessor> fp) {
	if (!fp) {
	return nullptr;
	}
	return GrXfermodeFragmentProcessor::MakeFromDstProcessor(std::move(fp), SkBlendMode::kDstIn);
	}

	sk_sp<GrFragmentProcessor> GrFragmentProcessor::PremulInput(sk_sp<GrFragmentProcessor> fp) {

	class PremulInputFragmentProcessor : public GrFragmentProcessor {
	public:
	PremulInputFragmentProcessor() {
	this->initClassID<PremulInputFragmentProcessor>();
	}

	const char* name() const override { return "PremultiplyInput"; }

	private:
	GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
	class GLFP : public GrGLSLFragmentProcessor {
	public:
	void emitCode(EmitArgs& args) override {
	GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;

	fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, args.fInputColor);
	fragBuilder->codeAppendf("%s.rgb *= %s.a;",
	args.fOutputColor, args.fInputColor);
	}
	};
	return new GLFP;
	}

	void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

	bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

	void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
	inout->premulFourChannelColor();
	}
	};
	if (!fp) {
	return nullptr;
	}
	sk_sp<GrFragmentProcessor> fpPipeline[] = { sk_make_sp<PremulInputFragmentProcessor>(), fp};
	return GrFragmentProcessor::RunInSeries(fpPipeline, 2);
	}

	sk_sp<GrFragmentProcessor> GrFragmentProcessor::MulOutputByInputUnpremulColor(
	sk_sp<GrFragmentProcessor> fp) {

	class PremulFragmentProcessor : public GrFragmentProcessor {
	public:
	PremulFragmentProcessor(sk_sp<GrFragmentProcessor> processor) {
	this->initClassID<PremulFragmentProcessor>();
	this->registerChildProcessor(processor);
	}

	const char* name() const override { return "Premultiply"; }

	private:
	GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
	class GLFP : public GrGLSLFragmentProcessor {
	public:
	void emitCode(EmitArgs& args) override {
	GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
	this->emitChild(0, nullptr, args);
	fragBuilder->codeAppendf("%s.rgb *= %s.rgb;", args.fOutputColor,
	args.fInputColor);
	fragBuilder->codeAppendf("%s *= %s.a;", args.fOutputColor, args.fInputColor);
	}
	};
	return new GLFP;
	}

	void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

	bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

	void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
	// TODO: Add a helper to GrInvariantOutput that handles multiplying by color with flags?
	if (!(inout->validFlags() & kA_GrColorComponentFlag)) {
	inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
	return;
	}

	GrInvariantOutput childOutput(GrColor_WHITE, kRGBA_GrColorComponentFlags);
	this->childProcessor(0).computeInvariantOutput(&childOutput);

	if (0 == GrColorUnpackA(inout->color()) \|\| 0 == GrColorUnpackA(childOutput.color())) {
	inout->mulByKnownFourComponents(0x0);
	return;
	}
	GrColorComponentFlags commonFlags = childOutput.validFlags() & inout->validFlags();
	GrColor c0 = GrPremulColor(inout->color());
	GrColor c1 = childOutput.color();
	GrColor color = 0x0;
	if (commonFlags & kR_GrColorComponentFlag) {
	color \|= SkMulDiv255Round(GrColorUnpackR(c0), GrColorUnpackR(c1)) <<
	GrColor_SHIFT_R;
	}
	if (commonFlags & kG_GrColorComponentFlag) {
	color \|= SkMulDiv255Round(GrColorUnpackG(c0), GrColorUnpackG(c1)) <<
	GrColor_SHIFT_G;
	}
	if (commonFlags & kB_GrColorComponentFlag) {
	color \|= SkMulDiv255Round(GrColorUnpackB(c0), GrColorUnpackB(c1)) <<
	GrColor_SHIFT_B;
	}
	inout->setToOther(commonFlags, color, GrInvariantOutput::kWill_ReadInput);
	}
	};
	if (!fp) {
	return nullptr;
	}
	return sk_sp<GrFragmentProcessor>(new PremulFragmentProcessor(std::move(fp)));
	}

	//////////////////////////////////////////////////////////////////////////////

	sk_sp<GrFragmentProcessor> GrFragmentProcessor::OverrideInput(sk_sp<GrFragmentProcessor> fp,
	GrColor4f color) {
	class ReplaceInputFragmentProcessor : public GrFragmentProcessor {
	public:
	ReplaceInputFragmentProcessor(sk_sp<GrFragmentProcessor> child, GrColor4f color)
	: fColor(color) {
	this->initClassID<ReplaceInputFragmentProcessor>();
	this->registerChildProcessor(std::move(child));
	}

	const char* name() const override { return "Replace Color"; }

	GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
	class GLFP : public GrGLSLFragmentProcessor {
	public:
	GLFP() : fHaveSetColor(false) {}
	void emitCode(EmitArgs& args) override {
	const char* colorName;
	fColorUni = args.fUniformHandler->addUniform(kFragment_GrShaderFlag,
	kVec4f_GrSLType,
	kDefault_GrSLPrecision,
	"Color", &colorName);
	this->emitChild(0, colorName, args);
	}

	private:
	void onSetData(const GrGLSLProgramDataManager& pdman,
	const GrProcessor& fp) override {
	GrColor4f color = fp.cast<ReplaceInputFragmentProcessor>().fColor;
	if (!fHaveSetColor \|\| color != fPreviousColor) {
	pdman.set4fv(fColorUni, 1, color.fRGBA);
	fPreviousColor = color;
	fHaveSetColor = true;
	}
	}

	GrGLSLProgramDataManager::UniformHandle fColorUni;
	bool fHaveSetColor;
	GrColor4f fPreviousColor;
	};

	return new GLFP;
	}

	private:
	void onGetGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override
	{}

	bool onIsEqual(const GrFragmentProcessor& that) const override {
	return fColor == that.cast<ReplaceInputFragmentProcessor>().fColor;
	}

	void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
	inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor(),
	GrInvariantOutput::kWillNot_ReadInput);
	this->childProcessor(0).computeInvariantOutput(inout);
	}

	GrColor4f fColor;
	};

	GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags);
	fp->computeInvariantOutput(&childOut);
	if (childOut.willUseInputColor()) {
	return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
	} else {
	return fp;
	}
	}

	sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
	int cnt) {
	class SeriesFragmentProcessor : public GrFragmentProcessor {
	public:
	SeriesFragmentProcessor(sk_sp<GrFragmentProcessor>* children, int cnt){
	SkASSERT(cnt > 1);
	this->initClassID<SeriesFragmentProcessor>();
	for (int i = 0; i < cnt; ++i) {
	this->registerChildProcessor(std::move(children[i]));
	}
	}

	const char* name() const override { return "Series"; }

	GrGLSLFragmentProcessor* onCreateGLSLInstance() const override {
	class GLFP : public GrGLSLFragmentProcessor {
	public:
	void emitCode(EmitArgs& args) override {
	// First guy's input might be nil.
	SkString temp("out0");
	this->emitChild(0, args.fInputColor, &temp, args);
	SkString input = temp;
	for (int i = 1; i < this->numChildProcessors() - 1; ++i) {
	temp.printf("out%d", i);
	this->emitChild(i, input.c_str(), &temp, args);
	input = temp;
	}
	// Last guy writes to our output variable.
	this->emitChild(this->numChildProcessors() - 1, input.c_str(), args);
	}
	};
	return new GLFP;
	}

	private:
	void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}

	bool onIsEqual(const GrFragmentProcessor&) const override { return true; }

	void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
	for (int i = 0; i < this->numChildProcessors(); ++i) {
	this->childProcessor(i).computeInvariantOutput(inout);
	}
	}
	};

	if (!cnt) {
	return nullptr;
	}

	// Run the through the series, do the invariant output processing, and look for eliminations.
	GrProcOptInfo info(0x0, kNone_GrColorComponentFlags);
	info.analyzeProcessors(sk_sp_address_as_pointer_address(series), cnt);
	if (kRGBA_GrColorComponentFlags == info.validFlags()) {
	// TODO: We need to preserve 4f and color spaces during invariant processing. This color
	// has definitely lost precision, and could easily be in the wrong gamut (or have been
	// built from colors in multiple spaces).
	return GrConstColorProcessor::Make(GrColor4f::FromGrColor(info.color()),
	GrConstColorProcessor::kIgnore_InputMode);
	}

	SkTArray<sk_sp<GrFragmentProcessor>> replacementSeries;

	int firstIdx = info.firstEffectiveProcessorIndex();
	cnt -= firstIdx;
	if (firstIdx > 0 && info.inputColorIsUsed()) {
	// See comment above - need to preserve 4f and color spaces during invariant processing.
	sk_sp<GrFragmentProcessor> colorFP(GrConstColorProcessor::Make(
	GrColor4f::FromGrColor(info.inputColorToFirstEffectiveProccesor()),
	GrConstColorProcessor::kIgnore_InputMode));
	cnt += 1;
	replacementSeries.reserve(cnt);
	replacementSeries.emplace_back(std::move(colorFP));
	for (int i = 0; i < cnt - 1; ++i) {
	replacementSeries.emplace_back(std::move(series[firstIdx + i]));
	}
	series = replacementSeries.begin();
	} else {
	series += firstIdx;
	cnt -= firstIdx;
	}

	if (1 == cnt) {
	return series[0];
	}
	return sk_sp<GrFragmentProcessor>(new SeriesFragmentProcessor(series, cnt));
	}

	//////////////////////////////////////////////////////////////////////////////

	GrFragmentProcessor::Iter::Iter(const GrPipeline& pipeline) {
	for (int i = pipeline.numFragmentProcessors() - 1; i >= 0; --i) {
	fFPStack.push_back(&pipeline.getFragmentProcessor(i));
	}
	}

	const GrFragmentProcessor* GrFragmentProcessor::Iter::next() {
	if (fFPStack.empty()) {
	return nullptr;
	}
	const GrFragmentProcessor* back = fFPStack.back();
	fFPStack.pop_back();
	for (int i = back->numChildProcessors() - 1; i >= 0; --i) {
	fFPStack.push_back(&back->childProcessor(i));
	}
	return back;
	}