src/gpu/GrDefaultGeoProcFactory.cpp - platform/external/skqp - Gitiles

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

 #include "GrDefaultGeoProcFactory.h"

 #include "GrInvariantOutput.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"

 /*
  * The default Geometry Processor simply takes position and multiplies it by the uniform view
  * matrix. It also leaves coverage untouched.  Behind the scenes, we may add per vertex color or
  * local coords.
  */
 typedef GrDefaultGeoProcFactory Flag;

 class DefaultGeoProc : public GrGeometryProcessor {
 public:
     static GrGeometryProcessor* Create(uint32_t gpTypeFlags,
                                        GrColor color,
                                        const SkMatrix& viewMatrix,
                                        const SkMatrix& localMatrix,
                                        bool opaqueVertexColors,
                                        uint8_t coverage) {
         return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags,
                                            color,
                                            viewMatrix,
                                            localMatrix,
                                            opaqueVertexColors,
                                            coverage));
     }

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

     const Attribute* inPosition() const { return fInPosition; }
     const Attribute* inColor() const { return fInColor; }
     const Attribute* inLocalCoords() const { return fInLocalCoords; }
     const Attribute* inCoverage() const { return fInCoverage; }
     uint8_t coverage() const { return fCoverage; }

     void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
         BatchTracker* local = bt->cast<BatchTracker>();
         local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
                                                    SkToBool(fInColor));

         bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored;
         bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage();
         if (covIsSolidWhite) {
             local->fInputCoverageType = kAllOnes_GrGPInput;
         } else if (!hasVertexCoverage) {
             local->fInputCoverageType = kUniform_GrGPInput;
             local->fCoverage = this->coverage();
         } else if (hasVertexCoverage) {
             SkASSERT(fInCoverage);
             local->fInputCoverageType = kAttribute_GrGPInput;
         } else {
             local->fInputCoverageType = kIgnored_GrGPInput;
         }

         local->fUsesLocalCoords = init.fUsesLocalCoords;
     }

     bool onCanMakeEqual(const GrBatchTracker& m,
                         const GrGeometryProcessor& that,
                         const GrBatchTracker& t) const override {
         const BatchTracker& mine = m.cast<BatchTracker>();
         const BatchTracker& theirs = t.cast<BatchTracker>();
         return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
                                        that, theirs.fUsesLocalCoords) &&
                CanCombineOutput(mine.fInputColorType, mine.fColor,
                                 theirs.fInputColorType, theirs.fColor) &&
                CanCombineOutput(mine.fInputCoverageType, mine.fCoverage,
                                 theirs.fInputCoverageType, theirs.fCoverage);
     }

     class GLProcessor : public GrGLGeometryProcessor {
     public:
         GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&)
             : fColor(GrColor_ILLEGAL), fCoverage(0xff) {}

         void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
             const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
             GrGLGPBuilder* pb = args.fPB;
             GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
             GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
             const BatchTracker& local = args.fBT.cast<BatchTracker>();

             // emit attributes
             vsBuilder->emitAttributes(gp);

             // Setup pass through color
             this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, gp.inColor(),
                                         &fColorUniform);
             // Setup position
             this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix());

             if (gp.inLocalCoords()) {
                 // emit transforms with explicit local coords
                 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inLocalCoords()->fName,
                                      gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
             } else {
                 // emit transforms with position
                 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->fName,
                                      gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
             }

             // Setup coverage as pass through
             if (kUniform_GrGPInput == local.fInputCoverageType) {
                 const char* fragCoverage;
                 fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                                   kFloat_GrSLType,
                                                   kDefault_GrSLPrecision,
                                                   "Coverage",
                                                   &fragCoverage);
                 fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage);
             } else if (kAttribute_GrGPInput == local.fInputCoverageType) {
                 SkASSERT(gp.inCoverage());
                 fs->codeAppendf("float alpha = 1.0;");
                 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha");
                 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
             } else if (kAllOnes_GrGPInput == local.fInputCoverageType) {
                 fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
             }
         }

         static inline void GenKey(const GrGeometryProcessor& gp,
                                   const GrBatchTracker& bt,
                                   const GrGLCaps&,
                                   GrProcessorKeyBuilder* b) {
             const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
             const BatchTracker& local = bt.cast<BatchTracker>();
             uint32_t key = def.fFlags;
             key |= local.fInputColorType << 8 | local.fInputCoverageType << 16;
             key |= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24 : 0x0;
             key |= ComputePosKey(gp.viewMatrix()) << 25;
             b->add32(key);
         }

         virtual void setData(const GrGLProgramDataManager& pdman,
                              const GrPrimitiveProcessor& gp,
                              const GrBatchTracker& bt) override {
             this->setUniformViewMatrix(pdman, gp.viewMatrix());

             const BatchTracker& local = bt.cast<BatchTracker>();
             if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
                 GrGLfloat c[4];
                 GrColorToRGBAFloat(local.fColor, c);
                 pdman.set4fv(fColorUniform, 1, c);
                 fColor = local.fColor;
             }
             if (kUniform_GrGPInput == local.fInputCoverageType && local.fCoverage != fCoverage) {
                 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCoverage));
                 fCoverage = local.fCoverage;
             }
         }

     private:
         GrColor fColor;
         uint8_t fCoverage;
         UniformHandle fColorUniform;
         UniformHandle fCoverageUniform;

         typedef GrGLGeometryProcessor INHERITED;
     };

     virtual void getGLProcessorKey(const GrBatchTracker& bt,
                                    const GrGLCaps& caps,
                                    GrProcessorKeyBuilder* b) const override {
         GLProcessor::GenKey(*this, bt, caps, b);
     }

     virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
                                                      const GrGLCaps&) const override {
         return SkNEW_ARGS(GLProcessor, (*this, bt));
     }

 private:
     DefaultGeoProc(uint32_t gpTypeFlags,
                    GrColor color,
                    const SkMatrix& viewMatrix,
                    const SkMatrix& localMatrix,
                    bool opaqueVertexColors,
                    uint8_t coverage)
         : INHERITED(color, viewMatrix, localMatrix, opaqueVertexColors)
         , fInPosition(NULL)
         , fInColor(NULL)
         , fInLocalCoords(NULL)
         , fInCoverage(NULL)
         , fCoverage(coverage)
         , fFlags(gpTypeFlags) {
         this->initClassID<DefaultGeoProc>();
         bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
         bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
         bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
         fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
         if (hasColor) {
             fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
             this->setHasVertexColor();
         }
         if (hasLocalCoord) {
             fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord",
                                                                 kVec2f_GrVertexAttribType));
             this->setHasLocalCoords();
         }
         if (hasCoverage) {
             fInCoverage = &this->addVertexAttrib(Attribute("inCoverage",
                                                              kFloat_GrVertexAttribType));
         }
     }

     bool onIsEqual(const GrGeometryProcessor& other) const override {
         const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
         return gp.fFlags == this->fFlags;
     }

     void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         if (fInCoverage) {
             out->setUnknownSingleComponent();
         } else {
             // uniform coverage
             out->setKnownSingleComponent(this->coverage());
         }
     }

     struct BatchTracker {
         GrGPInput fInputColorType;
         GrGPInput fInputCoverageType;
         GrColor  fColor;
         GrColor  fCoverage;
         bool fUsesLocalCoords;
     };

     const Attribute* fInPosition;
     const Attribute* fInColor;
     const Attribute* fInLocalCoords;
     const Attribute* fInCoverage;
     uint8_t fCoverage;
     uint32_t fFlags;

     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;

     typedef GrGeometryProcessor INHERITED;
 };

 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);

 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random,
                                                 GrContext*,
                                                 const GrDrawTargetCaps& caps,
                                                 GrTexture*[]) {
     uint32_t flags = 0;
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kColor_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kCoverage_GPType;
     }
     if (random->nextBool()) {
         flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType;
     }

     return DefaultGeoProc::Create(flags,
                                   GrRandomColor(random),
                                   GrProcessorUnitTest::TestMatrix(random),
                                   GrProcessorUnitTest::TestMatrix(random),
                                   random->nextBool(),
                                   GrRandomCoverage(random));
 }

 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags,
                                                            GrColor color,
                                                            const SkMatrix& viewMatrix,
                                                            const SkMatrix& localMatrix,
                                                            bool opaqueVertexColors,
                                                            uint8_t coverage) {
     return DefaultGeoProc::Create(gpTypeFlags,
                                   color,
                                   viewMatrix,
                                   localMatrix,
                                   opaqueVertexColors,
                                   coverage);
 }
	/*
	* Copyright 2014 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "GrDefaultGeoProcFactory.h"

	#include "GrInvariantOutput.h"
	#include "gl/GrGLGeometryProcessor.h"
	#include "gl/builders/GrGLProgramBuilder.h"

	/*
	* The default Geometry Processor simply takes position and multiplies it by the uniform view
	* matrix. It also leaves coverage untouched. Behind the scenes, we may add per vertex color or
	* local coords.
	*/
	typedef GrDefaultGeoProcFactory Flag;

	class DefaultGeoProc : public GrGeometryProcessor {
	public:
	static GrGeometryProcessor* Create(uint32_t gpTypeFlags,
	GrColor color,
	const SkMatrix& viewMatrix,
	const SkMatrix& localMatrix,
	bool opaqueVertexColors,
	uint8_t coverage) {
	return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags,
	color,
	viewMatrix,
	localMatrix,
	opaqueVertexColors,
	coverage));
	}

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

	const Attribute* inPosition() const { return fInPosition; }
	const Attribute* inColor() const { return fInColor; }
	const Attribute* inLocalCoords() const { return fInLocalCoords; }
	const Attribute* inCoverage() const { return fInCoverage; }
	uint8_t coverage() const { return fCoverage; }

	void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const override {
	BatchTracker* local = bt->cast<BatchTracker>();
	local->fInputColorType = GetColorInputType(&local->fColor, this->color(), init,
	SkToBool(fInColor));

	bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored;
	bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage();
	if (covIsSolidWhite) {
	local->fInputCoverageType = kAllOnes_GrGPInput;
	} else if (!hasVertexCoverage) {
	local->fInputCoverageType = kUniform_GrGPInput;
	local->fCoverage = this->coverage();
	} else if (hasVertexCoverage) {
	SkASSERT(fInCoverage);
	local->fInputCoverageType = kAttribute_GrGPInput;
	} else {
	local->fInputCoverageType = kIgnored_GrGPInput;
	}

	local->fUsesLocalCoords = init.fUsesLocalCoords;
	}

	bool onCanMakeEqual(const GrBatchTracker& m,
	const GrGeometryProcessor& that,
	const GrBatchTracker& t) const override {
	const BatchTracker& mine = m.cast<BatchTracker>();
	const BatchTracker& theirs = t.cast<BatchTracker>();
	return CanCombineLocalMatrices(*this, mine.fUsesLocalCoords,
	that, theirs.fUsesLocalCoords) &&
	CanCombineOutput(mine.fInputColorType, mine.fColor,
	theirs.fInputColorType, theirs.fColor) &&
	CanCombineOutput(mine.fInputCoverageType, mine.fCoverage,
	theirs.fInputCoverageType, theirs.fCoverage);
	}

	class GLProcessor : public GrGLGeometryProcessor {
	public:
	GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&)
	: fColor(GrColor_ILLEGAL), fCoverage(0xff) {}

	void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
	const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>();
	GrGLGPBuilder* pb = args.fPB;
	GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder();
	GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder();
	const BatchTracker& local = args.fBT.cast<BatchTracker>();

	// emit attributes
	vsBuilder->emitAttributes(gp);

	// Setup pass through color
	this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputColor, gp.inColor(),
	&fColorUniform);
	// Setup position
	this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatrix());

	if (gp.inLocalCoords()) {
	// emit transforms with explicit local coords
	this->emitTransforms(pb, gpArgs->fPositionVar, gp.inLocalCoords()->fName,
	gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
	} else {
	// emit transforms with position
	this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->fName,
	gp.localMatrix(), args.fTransformsIn, args.fTransformsOut);
	}

	// Setup coverage as pass through
	if (kUniform_GrGPInput == local.fInputCoverageType) {
	const char* fragCoverage;
	fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_Visibility,
	kFloat_GrSLType,
	kDefault_GrSLPrecision,
	"Coverage",
	&fragCoverage);
	fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCoverage);
	} else if (kAttribute_GrGPInput == local.fInputCoverageType) {
	SkASSERT(gp.inCoverage());
	fs->codeAppendf("float alpha = 1.0;");
	args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha");
	fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage);
	} else if (kAllOnes_GrGPInput == local.fInputCoverageType) {
	fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage);
	}
	}

	static inline void GenKey(const GrGeometryProcessor& gp,
	const GrBatchTracker& bt,
	const GrGLCaps&,
	GrProcessorKeyBuilder* b) {
	const DefaultGeoProc& def = gp.cast<DefaultGeoProc>();
	const BatchTracker& local = bt.cast<BatchTracker>();
	uint32_t key = def.fFlags;
	key \|= local.fInputColorType << 8 \| local.fInputCoverageType << 16;
	key \|= local.fUsesLocalCoords && gp.localMatrix().hasPerspective() ? 0x1 << 24 : 0x0;
	key \|= ComputePosKey(gp.viewMatrix()) << 25;
	b->add32(key);
	}

	virtual void setData(const GrGLProgramDataManager& pdman,
	const GrPrimitiveProcessor& gp,
	const GrBatchTracker& bt) override {
	this->setUniformViewMatrix(pdman, gp.viewMatrix());

	const BatchTracker& local = bt.cast<BatchTracker>();
	if (kUniform_GrGPInput == local.fInputColorType && local.fColor != fColor) {
	GrGLfloat c[4];
	GrColorToRGBAFloat(local.fColor, c);
	pdman.set4fv(fColorUniform, 1, c);
	fColor = local.fColor;
	}
	if (kUniform_GrGPInput == local.fInputCoverageType && local.fCoverage != fCoverage) {
	pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCoverage));
	fCoverage = local.fCoverage;
	}
	}

	private:
	GrColor fColor;
	uint8_t fCoverage;
	UniformHandle fColorUniform;
	UniformHandle fCoverageUniform;

	typedef GrGLGeometryProcessor INHERITED;
	};

	virtual void getGLProcessorKey(const GrBatchTracker& bt,
	const GrGLCaps& caps,
	GrProcessorKeyBuilder* b) const override {
	GLProcessor::GenKey(*this, bt, caps, b);
	}

	virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt,
	const GrGLCaps&) const override {
	return SkNEW_ARGS(GLProcessor, (*this, bt));
	}

	private:
	DefaultGeoProc(uint32_t gpTypeFlags,
	GrColor color,
	const SkMatrix& viewMatrix,
	const SkMatrix& localMatrix,
	bool opaqueVertexColors,
	uint8_t coverage)
	: INHERITED(color, viewMatrix, localMatrix, opaqueVertexColors)
	, fInPosition(NULL)
	, fInColor(NULL)
	, fInLocalCoords(NULL)
	, fInCoverage(NULL)
	, fCoverage(coverage)
	, fFlags(gpTypeFlags) {
	this->initClassID<DefaultGeoProc>();
	bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_GPType);
	bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLocalCoord_GPType);
	bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCoverage_GPType);
	fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVertexAttribType));
	if (hasColor) {
	fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVertexAttribType));
	this->setHasVertexColor();
	}
	if (hasLocalCoord) {
	fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord",
	kVec2f_GrVertexAttribType));
	this->setHasLocalCoords();
	}
	if (hasCoverage) {
	fInCoverage = &this->addVertexAttrib(Attribute("inCoverage",
	kFloat_GrVertexAttribType));
	}
	}

	bool onIsEqual(const GrGeometryProcessor& other) const override {
	const DefaultGeoProc& gp = other.cast<DefaultGeoProc>();
	return gp.fFlags == this->fFlags;
	}

	void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
	if (fInCoverage) {
	out->setUnknownSingleComponent();
	} else {
	// uniform coverage
	out->setKnownSingleComponent(this->coverage());
	}
	}

	struct BatchTracker {
	GrGPInput fInputColorType;
	GrGPInput fInputCoverageType;
	GrColor fColor;
	GrColor fCoverage;
	bool fUsesLocalCoords;
	};

	const Attribute* fInPosition;
	const Attribute* fInColor;
	const Attribute* fInLocalCoords;
	const Attribute* fInCoverage;
	uint8_t fCoverage;
	uint32_t fFlags;

	GR_DECLARE_GEOMETRY_PROCESSOR_TEST;

	typedef GrGeometryProcessor INHERITED;
	};

	GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);

	GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random,
	GrContext*,
	const GrDrawTargetCaps& caps,
	GrTexture*[]) {
	uint32_t flags = 0;
	if (random->nextBool()) {
	flags \|= GrDefaultGeoProcFactory::kColor_GPType;
	}
	if (random->nextBool()) {
	flags \|= GrDefaultGeoProcFactory::kCoverage_GPType;
	}
	if (random->nextBool()) {
	flags \|= GrDefaultGeoProcFactory::kLocalCoord_GPType;
	}

	return DefaultGeoProc::Create(flags,
	GrRandomColor(random),
	GrProcessorUnitTest::TestMatrix(random),
	GrProcessorUnitTest::TestMatrix(random),
	random->nextBool(),
	GrRandomCoverage(random));
	}

	const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags,
	GrColor color,
	const SkMatrix& viewMatrix,
	const SkMatrix& localMatrix,
	bool opaqueVertexColors,
	uint8_t coverage) {
	return DefaultGeoProc::Create(gpTypeFlags,
	color,
	viewMatrix,
	localMatrix,
	opaqueVertexColors,
	coverage);
	}