diff options
54 files changed, 1091 insertions, 794 deletions
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp index 1c26989df2..26da791746 100644 --- a/gm/beziereffects.cpp +++ b/gm/beziereffects.cpp @@ -93,14 +93,13 @@ private: void onPrepareDraws(Target* target) override { QuadHelper helper; - size_t vertexStride = this->gp()->getVertexStride(); - SkASSERT(vertexStride == sizeof(SkPoint)); - SkPoint* pts = reinterpret_cast<SkPoint*>(helper.init(target, vertexStride, 1)); + SkASSERT(this->gp()->debugOnly_vertexStride() == sizeof(SkPoint)); + SkPoint* pts = reinterpret_cast<SkPoint*>(helper.init(target, sizeof(SkPoint), 1)); if (!pts) { return; } SkRect rect = this->rect(); - SkPointPriv::SetRectTriStrip(pts, rect, vertexStride); + SkPointPriv::SetRectTriStrip(pts, rect, sizeof(SkPoint)); helper.recordDraw(target, this->gp(), this->makePipeline(target)); } @@ -285,9 +284,8 @@ private: void onPrepareDraws(Target* target) override { QuadHelper helper; - size_t vertexStride = this->gp()->getVertexStride(); - SkASSERT(vertexStride == sizeof(Vertex)); - Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1)); + SkASSERT(this->gp()->debugOnly_vertexStride() == sizeof(Vertex)); + Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, sizeof(Vertex), 1)); if (!verts) { return; } @@ -507,9 +505,8 @@ private: void onPrepareDraws(Target* target) override { QuadHelper helper; - size_t vertexStride = this->gp()->getVertexStride(); - SkASSERT(vertexStride == sizeof(Vertex)); - Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, vertexStride, 1)); + SkASSERT(this->gp()->debugOnly_vertexStride() == sizeof(Vertex)); + Vertex* verts = reinterpret_cast<Vertex*>(helper.init(target, sizeof(Vertex), 1)); if (!verts) { return; } diff --git a/gm/convexpolyeffect.cpp b/gm/convexpolyeffect.cpp index 18c5ebdcdc..496b6b173f 100644 --- a/gm/convexpolyeffect.cpp +++ b/gm/convexpolyeffect.cpp @@ -83,10 +83,9 @@ private: sk_sp<GrGeometryProcessor> gp(GrDefaultGeoProcFactory::Make( color, Coverage::kSolid_Type, LocalCoords::kUnused_Type, SkMatrix::I())); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(SkPoint)); + SkASSERT(gp->debugOnly_vertexStride() == sizeof(SkPoint)); QuadHelper helper; - SkPoint* verts = reinterpret_cast<SkPoint*>(helper.init(target, vertexStride, 1)); + SkPoint* verts = reinterpret_cast<SkPoint*>(helper.init(target, sizeof(SkPoint), 1)); if (!verts) { return; } diff --git a/include/private/GrTypesPriv.h b/include/private/GrTypesPriv.h index 5913a1e48c..e957f1f893 100644 --- a/include/private/GrTypesPriv.h +++ b/include/private/GrTypesPriv.h @@ -694,51 +694,6 @@ enum GrVertexAttribType { static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1; /** - * Returns the size of the attrib type in bytes. - */ -static inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) { - switch (type) { - case kFloat_GrVertexAttribType: - return sizeof(float); - case kFloat2_GrVertexAttribType: - return 2 * sizeof(float); - case kFloat3_GrVertexAttribType: - return 3 * sizeof(float); - case kFloat4_GrVertexAttribType: - return 4 * sizeof(float); - case kHalf_GrVertexAttribType: - return sizeof(float); - case kHalf2_GrVertexAttribType: - return 2 * sizeof(float); - case kHalf3_GrVertexAttribType: - return 3 * sizeof(float); - case kHalf4_GrVertexAttribType: - return 4 * sizeof(float); - case kInt2_GrVertexAttribType: - return 2 * sizeof(int32_t); - case kInt3_GrVertexAttribType: - return 3 * sizeof(int32_t); - case kInt4_GrVertexAttribType: - return 4 * sizeof(int32_t); - case kUByte_norm_GrVertexAttribType: - return 1 * sizeof(char); - case kUByte4_norm_GrVertexAttribType: - return 4 * sizeof(char); - case kShort2_GrVertexAttribType: - return 2 * sizeof(int16_t); - case kUShort2_GrVertexAttribType: // fall through - case kUShort2_norm_GrVertexAttribType: - return 2 * sizeof(uint16_t); - case kInt_GrVertexAttribType: - return sizeof(int32_t); - case kUint_GrVertexAttribType: - return sizeof(uint32_t); - } - SK_ABORT("Unexpected attribute type"); - return 0; -} - -/** * converts a GrVertexAttribType to a GrSLType */ static inline GrSLType GrVertexAttribTypeToSLType(GrVertexAttribType type) { diff --git a/src/gpu/GrDefaultGeoProcFactory.cpp b/src/gpu/GrDefaultGeoProcFactory.cpp index defb214eb0..e2bf87b277 100644 --- a/src/gpu/GrDefaultGeoProcFactory.cpp +++ b/src/gpu/GrDefaultGeoProcFactory.cpp @@ -45,17 +45,13 @@ public: 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; } GrColor color() const { return fColor; } - bool hasVertexColor() const { return SkToBool(fInColor); } + bool hasVertexColor() const { return fInColor.isInitialized(); } const SkMatrix& viewMatrix() const { return fViewMatrix; } const SkMatrix& localMatrix() const { return fLocalMatrix; } bool localCoordsWillBeRead() const { return fLocalCoordsWillBeRead; } uint8_t coverage() const { return fCoverage; } - bool hasVertexCoverage() const { return SkToBool(fInCoverage); } + bool hasVertexCoverage() const { return fInCoverage.isInitialized(); } class GLSLProcessor : public GrGLSLGeometryProcessor { public: @@ -78,7 +74,7 @@ public: varyingHandler->addVarying("color", &varying); // There are several optional steps to process the color. Start with the attribute: - vertBuilder->codeAppendf("half4 color = %s;", gp.inColor()->name()); + vertBuilder->codeAppendf("half4 color = %s;", gp.fInColor.name()); // For SkColor, do a red/blue swap, possible color space conversion, and premul if (gp.fFlags & kColorAttributeIsSkColor_GPFlag) { @@ -107,16 +103,16 @@ public: this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - gp.inPosition()->name(), + gp.fInPosition.name(), gp.viewMatrix(), &fViewMatrixUniform); - if (gp.inLocalCoords()) { + if (gp.fInLocalCoords.isInitialized()) { // emit transforms with explicit local coords this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - gp.inLocalCoords()->asShaderVar(), + gp.fInLocalCoords.asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); } else { @@ -124,7 +120,7 @@ public: this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - gp.inPosition()->asShaderVar(), + gp.fInPosition.asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); } @@ -132,7 +128,7 @@ public: // Setup coverage as pass through if (gp.hasVertexCoverage()) { fragBuilder->codeAppendf("half alpha = 1.0;"); - varyingHandler->addPassThroughAttribute(gp.inCoverage(), "alpha"); + varyingHandler->addPassThroughAttribute(gp.fInCoverage, "alpha"); fragBuilder->codeAppendf("%s = half4(alpha);", args.fOutputCoverage); } else if (gp.coverage() == 0xff) { fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage); @@ -222,22 +218,31 @@ private: , fFlags(gpTypeFlags) , fLocalCoordsWillBeRead(localCoordsWillBeRead) , fColorSpaceXform(std::move(colorSpaceXform)) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); + fInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + int cnt = 1; if (fFlags & kColorAttribute_GPFlag) { - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); + fInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + ++cnt; } if (fFlags & kLocalCoordAttribute_GPFlag) { - fInLocalCoords = &this->addVertexAttrib("inLocalCoord", kFloat2_GrVertexAttribType); + fInLocalCoords = {"inLocalCoord", kFloat2_GrVertexAttribType}; + ++cnt; } if (fFlags & kCoverageAttribute_GPFlag) { - fInCoverage = &this->addVertexAttrib("inCoverage", kHalf_GrVertexAttribType); + fInCoverage = {"inCoverage", kHalf_GrVertexAttribType}; + ++cnt; } + this->setVertexAttributeCnt(cnt); } - const Attribute* fInPosition = nullptr; - const Attribute* fInColor = nullptr; - const Attribute* fInLocalCoords = nullptr; - const Attribute* fInCoverage = nullptr; + const Attribute& onVertexAttribute(int i) const override { + return IthInitializedAttribute(i, fInPosition, fInColor, fInLocalCoords, fInCoverage); + } + + Attribute fInPosition; + Attribute fInColor; + Attribute fInLocalCoords; + Attribute fInCoverage; GrColor fColor; SkMatrix fViewMatrix; SkMatrix fLocalMatrix; diff --git a/src/gpu/GrGeometryProcessor.h b/src/gpu/GrGeometryProcessor.h index a12ab0058d..5035ad0f53 100644 --- a/src/gpu/GrGeometryProcessor.h +++ b/src/gpu/GrGeometryProcessor.h @@ -39,7 +39,44 @@ protected: fSampleShading = sampleShading; } + /** + * Recursive helpers for implementing onVertexAttribute or onInstanceAttribute. + */ + + template <typename... Args> + static const Attribute& IthAttribute(int i, const Attribute& attr0, const Args&... attrs) { + SkASSERT(attr0.isInitialized()); + return (0 == i) ? attr0 : IthAttribute(i - 1, attrs...); + } + + static const Attribute& IthAttribute(int i) { + SK_ABORT("Illegal attribute Index"); + static constexpr Attribute kBogus; + return kBogus; + } + + template <typename... Args> + static const Attribute& IthInitializedAttribute(int i, const Attribute& attr0, + const Args&... attrs) { + if (attr0.isInitialized()) { + if (0 == i) { + return attr0; + } + i -= 1; + } + return IthInitializedAttribute(i, attrs...); + } + + static const Attribute& IthInitializedAttribute(int i) { return IthAttribute(i); } + private: + // Since most subclasses don't use instancing provide a default implementation for that case. + const Attribute& onInstanceAttribute(int i) const override { + SK_ABORT("No instanced attributes"); + static constexpr Attribute kBogus; + return kBogus; + } + bool fWillUseGeoShader; float fSampleShading; diff --git a/src/gpu/GrGpuCommandBuffer.cpp b/src/gpu/GrGpuCommandBuffer.cpp index 13ae6c9844..fa2ce077b5 100644 --- a/src/gpu/GrGpuCommandBuffer.cpp +++ b/src/gpu/GrGpuCommandBuffer.cpp @@ -33,12 +33,12 @@ bool GrGpuRTCommandBuffer::draw(const GrPipeline& pipeline, int meshCount, const SkRect& bounds) { #ifdef SK_DEBUG - SkASSERT(!primProc.hasInstanceAttribs() || this->gpu()->caps()->instanceAttribSupport()); + SkASSERT(!primProc.hasInstanceAttributes() || this->gpu()->caps()->instanceAttribSupport()); for (int i = 0; i < meshCount; ++i) { SkASSERT(!GrPrimTypeRequiresGeometryShaderSupport(meshes[i].primitiveType()) || this->gpu()->caps()->shaderCaps()->geometryShaderSupport()); - SkASSERT(primProc.hasVertexAttribs() == meshes[i].hasVertexData()); - SkASSERT(primProc.hasInstanceAttribs() == meshes[i].isInstanced()); + SkASSERT(primProc.hasVertexAttributes() == meshes[i].hasVertexData()); + SkASSERT(primProc.hasInstanceAttributes() == meshes[i].isInstanced()); } #endif auto resourceProvider = this->gpu()->getContext()->contextPriv().resourceProvider(); @@ -47,7 +47,7 @@ bool GrGpuRTCommandBuffer::draw(const GrPipeline& pipeline, return false; } - if (primProc.numAttribs() > this->gpu()->caps()->maxVertexAttributes()) { + if (primProc.numVertexAttributes() > this->gpu()->caps()->maxVertexAttributes()) { this->gpu()->stats()->incNumFailedDraws(); return false; } diff --git a/src/gpu/GrPathProcessor.h b/src/gpu/GrPathProcessor.h index 72e5168a4f..6893e882dc 100644 --- a/src/gpu/GrPathProcessor.h +++ b/src/gpu/GrPathProcessor.h @@ -38,6 +38,18 @@ public: virtual bool isPathRendering() const override { return true; } private: + const Attribute& onVertexAttribute(int i) const final { + SK_ABORT("No vertex attributes"); + static constexpr Attribute kBogus; + return kBogus; + } + + const Attribute& onInstanceAttribute(int i) const final { + SK_ABORT("No instanced attributes"); + static constexpr Attribute kBogus; + return kBogus; + } + GrPathProcessor(GrColor, const SkMatrix& viewMatrix, const SkMatrix& localMatrix); GrColor fColor; diff --git a/src/gpu/GrPrimitiveProcessor.cpp b/src/gpu/GrPrimitiveProcessor.cpp index 7d1e1a644e..db79fb1052 100644 --- a/src/gpu/GrPrimitiveProcessor.cpp +++ b/src/gpu/GrPrimitiveProcessor.cpp @@ -17,6 +17,58 @@ enum MatrixType { kGeneral_MatrixType = 1, }; +GrPrimitiveProcessor::GrPrimitiveProcessor(ClassID classID) : GrResourceIOProcessor(classID) {} + +const GrPrimitiveProcessor::Attribute& GrPrimitiveProcessor::vertexAttribute(int i) const { + SkASSERT(i >= 0 && i < this->numVertexAttributes()); + const auto& result = this->onVertexAttribute(i); + SkASSERT(result.isInitialized()); + return result; +} + +const GrPrimitiveProcessor::Attribute& GrPrimitiveProcessor::instanceAttribute(int i) const { + SkASSERT(i >= 0 && i < this->numInstanceAttributes()); + const auto& result = this->onInstanceAttribute(i); + SkASSERT(result.isInitialized()); + return result; +} + +#ifdef SK_DEBUG +size_t GrPrimitiveProcessor::debugOnly_vertexStride() const { + size_t stride = 0; + for (int i = 0; i < fVertexAttributeCnt; ++i) { + stride += this->vertexAttribute(i).sizeAlign4(); + } + return stride; +} + +size_t GrPrimitiveProcessor::debugOnly_instanceStride() const { + size_t stride = 0; + for (int i = 0; i < fInstanceAttributeCnt; ++i) { + stride += this->instanceAttribute(i).sizeAlign4(); + } + return stride; +} + +size_t GrPrimitiveProcessor::debugOnly_vertexAttributeOffset(int i) const { + SkASSERT(i >= 0 && i < fVertexAttributeCnt); + size_t offset = 0; + for (int j = 0; j < i; ++j) { + offset += this->vertexAttribute(j).sizeAlign4(); + } + return offset; +} + +size_t GrPrimitiveProcessor::debugOnly_instanceAttributeOffset(int i) const { + SkASSERT(i >= 0 && i < fInstanceAttributeCnt); + size_t offset = 0; + for (int j = 0; j < i; ++j) { + offset += this->instanceAttribute(j).sizeAlign4(); + } + return offset; +} +#endif + uint32_t GrPrimitiveProcessor::getTransformKey(const SkTArray<const GrCoordTransform*, true>& coords, int numCoords) const { diff --git a/src/gpu/GrPrimitiveProcessor.h b/src/gpu/GrPrimitiveProcessor.h index c75f13c496..6563ad9a7d 100644 --- a/src/gpu/GrPrimitiveProcessor.h +++ b/src/gpu/GrPrimitiveProcessor.h @@ -40,23 +40,22 @@ class GrGLSLPrimitiveProcessor; */ class GrPrimitiveProcessor : public GrResourceIOProcessor, public GrProgramElement { public: + /** Describes a vertex or instance attribute. */ class Attribute { public: - enum class InputRate : bool { - kPerVertex, - kPerInstance - }; - constexpr Attribute() = default; - constexpr Attribute(const char* name, GrVertexAttribType type, int offset, InputRate rate) - : fName(name), fType(type), fOffsetInRecord(offset), fInputRate(rate) {} + constexpr Attribute(const char* name, GrVertexAttribType type) : fName(name), fType(type) {} + constexpr Attribute(const Attribute&) = default; + + Attribute& operator=(const Attribute&) = default; + + constexpr bool isInitialized() const { return SkToBool(fName); } - bool isInitialized() const { return SkToBool(fName); } + constexpr const char* name() const { return fName; } + constexpr GrVertexAttribType type() const { return fType; } - const char* name() const { return fName; } - GrVertexAttribType type() const { return fType; } - int offsetInRecord() const { return fOffsetInRecord; } - InputRate inputRate() const { return fInputRate; } + inline constexpr size_t size() const; + constexpr size_t sizeAlign4() const { return SkAlign4(this->size()); } GrShaderVar asShaderVar() const { return {fName, GrVertexAttribTypeToSLType(fType), GrShaderVar::kIn_TypeModifier}; @@ -65,35 +64,34 @@ public: private: const char* fName = nullptr; GrVertexAttribType fType = kFloat_GrVertexAttribType; - int fOffsetInRecord = 0; - InputRate fInputRate = InputRate::kPerVertex; }; - GrPrimitiveProcessor(ClassID classID) - : GrResourceIOProcessor(classID) {} + GrPrimitiveProcessor(ClassID); - int numAttribs() const { return fAttribs.count(); } - const Attribute& getAttrib(int index) const { return fAttribs[index]; } + int numVertexAttributes() const { return fVertexAttributeCnt; } + const Attribute& vertexAttribute(int i) const; + int numInstanceAttributes() const { return fInstanceAttributeCnt; } + const Attribute& instanceAttribute(int i) const; - bool hasVertexAttribs() const { return SkToBool(fVertexStride); } - bool hasInstanceAttribs() const { return SkToBool(fInstanceStride); } + bool hasVertexAttributes() const { return SkToBool(fVertexAttributeCnt); } + bool hasInstanceAttributes() const { return SkToBool(fInstanceAttributeCnt); } +#ifdef SK_DEBUG /** - * These return the strides of the vertex and instance buffers. Attributes are expected to be - * laid out interleaved in their corresponding buffer (vertex or instance). fOffsetInRecord - * indicates an attribute's location in bytes relative to the first attribute. (These are padded - * to the nearest 4 bytes for performance reasons.) - * - * A common practice is to populate the buffer's memory using an implicit array of structs. In - * this case, it is best to assert: - * - * stride == sizeof(struct) and - * offsetof(struct, field[i]) == attrib[i].fOffsetInRecord - * - * NOTE: for instanced draws the vertex buffer has a single record that each instance reuses. + * A common practice is to populate the the vertex/instance's memory using an implicit array of + * structs. In this case, it is best to assert that: + * debugOnly_stride == sizeof(struct) and + * offsetof(struct, field[i]) == debugOnly_AttributeOffset(i) + * In general having Op subclasses assert that attribute offsets and strides agree with their + * tessellation code's expectations is good practice. + * However, these functions walk the attributes to compute offsets and call virtual functions + * to access the attributes. Thus, they are only available in debug builds. */ - int getVertexStride() const { return fVertexStride; } - int getInstanceStride() const { return fInstanceStride; } + size_t debugOnly_vertexStride() const; + size_t debugOnly_instanceStride() const; + size_t debugOnly_vertexAttributeOffset(int) const; + size_t debugOnly_instanceAttributeOffset(int) const; +#endif // Only the GrGeometryProcessor subclass actually has a geo shader or vertex attributes, but // we put these calls on the base class to prevent having to cast @@ -129,24 +127,11 @@ public: */ virtual const char* getDestColorOverride() const { return nullptr; } - virtual float getSampleShading() const { - return 0.0; - } + virtual float getSampleShading() const { return 0.0; } protected: - /** - * Subclasses call these from their constructor to register vertex and instance attributes. - */ - const Attribute& addVertexAttrib(const char* name, GrVertexAttribType type) { - fAttribs.push_back() = {name, type, fVertexStride, Attribute::InputRate::kPerVertex}; - fVertexStride += static_cast<int>(SkAlign4(GrVertexAttribTypeSize(type))); - return fAttribs.back(); - } - const Attribute& addInstanceAttrib(const char* name, GrVertexAttribType type) { - fAttribs.push_back() = {name, type, fInstanceStride, Attribute::InputRate::kPerInstance}; - fInstanceStride += static_cast<int>(SkAlign4(GrVertexAttribTypeSize(type))); - return fAttribs.back(); - } + void setVertexAttributeCnt(int cnt) { fVertexAttributeCnt = cnt; } + void setInstanceAttributeCnt(int cnt) { fInstanceAttributeCnt = cnt; } private: void addPendingIOs() const override { GrResourceIOProcessor::addPendingIOs(); } @@ -154,11 +139,69 @@ private: void pendingIOComplete() const override { GrResourceIOProcessor::pendingIOComplete(); } void notifyRefCntIsZero() const final {} - SkSTArray<8, Attribute> fAttribs; - int fVertexStride = 0; - int fInstanceStride = 0; + virtual const Attribute& onVertexAttribute(int) const = 0; + virtual const Attribute& onInstanceAttribute(int) const = 0; + int fVertexAttributeCnt = 0; + int fInstanceAttributeCnt = 0; typedef GrProcessor INHERITED; }; +////////////////////////////////////////////////////////////////////////////// + +/** + * Returns the size of the attrib type in bytes. + * This was moved from include/private/GrTypesPriv.h in service of Skia dependents that build + * with C++11. + */ +static constexpr inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) { + switch (type) { + case kFloat_GrVertexAttribType: + return sizeof(float); + case kFloat2_GrVertexAttribType: + return 2 * sizeof(float); + case kFloat3_GrVertexAttribType: + return 3 * sizeof(float); + case kFloat4_GrVertexAttribType: + return 4 * sizeof(float); + case kHalf_GrVertexAttribType: + return sizeof(float); + case kHalf2_GrVertexAttribType: + return 2 * sizeof(float); + case kHalf3_GrVertexAttribType: + return 3 * sizeof(float); + case kHalf4_GrVertexAttribType: + return 4 * sizeof(float); + case kInt2_GrVertexAttribType: + return 2 * sizeof(int32_t); + case kInt3_GrVertexAttribType: + return 3 * sizeof(int32_t); + case kInt4_GrVertexAttribType: + return 4 * sizeof(int32_t); + case kUByte_norm_GrVertexAttribType: + return 1 * sizeof(char); + case kUByte4_norm_GrVertexAttribType: + return 4 * sizeof(char); + case kShort2_GrVertexAttribType: + return 2 * sizeof(int16_t); + case kUShort2_GrVertexAttribType: // fall through + case kUShort2_norm_GrVertexAttribType: + return 2 * sizeof(uint16_t); + case kInt_GrVertexAttribType: + return sizeof(int32_t); + case kUint_GrVertexAttribType: + return sizeof(uint32_t); + } + // GCC fails because SK_ABORT evaluates to non constexpr. clang and cl.exe think this is + // unreachable and don't complain. +#if defined(__clang__) || !defined(__GNUC__) + SK_ABORT("Unsupported type conversion"); +#endif + return 0; +} + +constexpr size_t GrPrimitiveProcessor::Attribute::size() const { + return GrVertexAttribTypeSize(fType); +} + #endif diff --git a/src/gpu/ccpr/GrCCCoverageProcessor.h b/src/gpu/ccpr/GrCCCoverageProcessor.h index e3ea34f8dd..89890486d3 100644 --- a/src/gpu/ccpr/GrCCCoverageProcessor.h +++ b/src/gpu/ccpr/GrCCCoverageProcessor.h @@ -246,6 +246,13 @@ private: void initGS(); void initVS(GrResourceProvider*); + const Attribute& onVertexAttribute(int i) const override { return fVertexAttribute; } + + const Attribute& onInstanceAttribute(int i) const override { + SkASSERT(fImpl == Impl::kVertexShader); + return fInstanceAttributes[i]; + } + void appendGSMesh(GrBuffer* instanceBuffer, int instanceCount, int baseInstance, SkTArray<GrMesh>* out) const; void appendVSMesh(GrBuffer* instanceBuffer, int instanceCount, int baseInstance, @@ -253,6 +260,8 @@ private: GrGLSLPrimitiveProcessor* createGSImpl(std::unique_ptr<Shader>) const; GrGLSLPrimitiveProcessor* createVSImpl(std::unique_ptr<Shader>) const; + // The type and meaning of this attribute depends on whether we're using VSImpl or GSImpl. + Attribute fVertexAttribute; const PrimitiveType fPrimitiveType; const Impl fImpl; @@ -262,6 +271,7 @@ private: const GSSubpass fGSSubpass = GSSubpass::kHulls; // Used by VSImpl. + Attribute fInstanceAttributes[2]; sk_sp<const GrBuffer> fVSVertexBuffer; sk_sp<const GrBuffer> fVSIndexBuffer; int fVSNumIndicesPerInstance; diff --git a/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp b/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp index aa7a8db8a5..8134fbe89b 100644 --- a/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp +++ b/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp @@ -31,9 +31,8 @@ protected: const GrCCCoverageProcessor& proc = args.fGP.cast<GrCCCoverageProcessor>(); // The vertex shader simply forwards transposed x or y values to the geometry shader. - SkASSERT(1 == proc.numAttribs()); - gpArgs->fPositionVar.set(GrVertexAttribTypeToSLType(proc.getAttrib(0).type()), - proc.getAttrib(0).name()); + SkASSERT(1 == proc.numVertexAttributes()); + gpArgs->fPositionVar = proc.fVertexAttribute.asShaderVar(); // Geometry shader. GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; @@ -62,7 +61,7 @@ protected: Shader::CalcWind(proc, g, "pts", wind.c_str()); if (PrimitiveType::kWeightedTriangles == proc.fPrimitiveType) { SkASSERT(3 == numInputPoints); - SkASSERT(kFloat4_GrVertexAttribType == proc.getAttrib(0).type()); + SkASSERT(kFloat4_GrVertexAttribType == proc.fVertexAttribute.type()); g->codeAppendf("%s *= sk_in[0].sk_Position.w;", wind.c_str()); } @@ -382,14 +381,19 @@ public: void GrCCCoverageProcessor::initGS() { SkASSERT(Impl::kGeometryShader == fImpl); if (4 == this->numInputPoints() || this->hasInputWeight()) { - this->addVertexAttrib("x_or_y_values", kFloat4_GrVertexAttribType); - SkASSERT(sizeof(QuadPointInstance) == this->getVertexStride() * 2); - SkASSERT(offsetof(QuadPointInstance, fY) == this->getVertexStride()); + fVertexAttribute = {"x_or_y_values", kFloat4_GrVertexAttribType}; + GR_STATIC_ASSERT(sizeof(QuadPointInstance) == + 2 * GrVertexAttribTypeSize(kFloat4_GrVertexAttribType)); + GR_STATIC_ASSERT(offsetof(QuadPointInstance, fY) == + GrVertexAttribTypeSize(kFloat4_GrVertexAttribType)); } else { - this->addVertexAttrib("x_or_y_values", kFloat3_GrVertexAttribType); - SkASSERT(sizeof(TriPointInstance) == this->getVertexStride() * 2); - SkASSERT(offsetof(TriPointInstance, fY) == this->getVertexStride()); + fVertexAttribute = {"x_or_y_values", kFloat3_GrVertexAttribType}; + GR_STATIC_ASSERT(sizeof(TriPointInstance) == + 2 * GrVertexAttribTypeSize(kFloat3_GrVertexAttribType)); + GR_STATIC_ASSERT(offsetof(TriPointInstance, fY) == + GrVertexAttribTypeSize(kFloat3_GrVertexAttribType)); } + this->setVertexAttributeCnt(1); this->setWillUseGeoShader(); } diff --git a/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp b/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp index 3c9fe89fbc..5c5120cf45 100644 --- a/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp +++ b/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp @@ -28,9 +28,8 @@ private: const int fNumSides; }; -static constexpr int kAttribIdx_X = 0; // Transposed X values of all input points. -static constexpr int kAttribIdx_Y = 1; // Transposed Y values of all input points. -static constexpr int kAttribIdx_VertexData = 2; +static constexpr int kInstanceAttribIdx_X = 0; // Transposed X values of all input points. +static constexpr int kInstanceAttribIdx_Y = 1; // Transposed Y values of all input points. // Vertex data tells the shader how to offset vertices for conservative raster, as well as how to // calculate coverage values for corners and edges. @@ -260,15 +259,16 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) int inputWidth = (4 == numInputPoints || proc.hasInputWeight()) ? 4 : 3; const char* swizzle = (4 == inputWidth) ? "xyzw" : "xyz"; v->codeAppendf("float%ix2 pts = transpose(float2x%i(%s.%s, %s.%s));", inputWidth, inputWidth, - proc.getAttrib(kAttribIdx_X).name(), swizzle, - proc.getAttrib(kAttribIdx_Y).name(), swizzle); + proc.fInstanceAttributes[kInstanceAttribIdx_X].name(), swizzle, + proc.fInstanceAttributes[kInstanceAttribIdx_Y].name(), swizzle); v->codeAppend ("half wind;"); Shader::CalcWind(proc, v, "pts", "wind"); if (PrimitiveType::kWeightedTriangles == proc.fPrimitiveType) { SkASSERT(3 == numInputPoints); - SkASSERT(kFloat4_GrVertexAttribType == proc.getAttrib(kAttribIdx_X).type()); - v->codeAppendf("wind *= %s.w;", proc.getAttrib(kAttribIdx_X).name()); + SkASSERT(kFloat4_GrVertexAttribType == + proc.fInstanceAttributes[kInstanceAttribIdx_X].type()); + v->codeAppendf("wind *= %s.w;", proc.fInstanceAttributes[kInstanceAttribIdx_X].name()); } float bloat = kAABloatRadius; @@ -284,12 +284,12 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) // Reverse all indices if the wind is counter-clockwise: [0, 1, 2] -> [2, 1, 0]. v->codeAppendf("int clockwise_indices = wind > 0 ? %s : 0x%x - %s;", - proc.getAttrib(kAttribIdx_VertexData).name(), + proc.fVertexAttribute.name(), ((fNumSides - 1) << kVertexData_LeftNeighborIdShift) | ((fNumSides - 1) << kVertexData_RightNeighborIdShift) | (((1 << kVertexData_RightNeighborIdShift) - 1) ^ 3) | (fNumSides - 1), - proc.getAttrib(kAttribIdx_VertexData).name()); + proc.fVertexAttribute.name()); // Here we generate conservative raster geometry for the input polygon. It is the convex // hull of N pixel-size boxes, one centered on each the input points. Each corner has three @@ -322,7 +322,7 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) v->codeAppend ("rightdir = (float2(0) != rightdir) ? normalize(rightdir) : float2(1, 0);"); v->codeAppendf("if (0 != (%s & %i)) {", // Are we a corner? - proc.getAttrib(kAttribIdx_VertexData).name(), kVertexData_IsCornerBit); + proc.fVertexAttribute.name(), kVertexData_IsCornerBit); // In corner boxes, all 4 coverage values will not map linearly. // Therefore it is important to align the box so its diagonal shared @@ -341,7 +341,7 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) // continue rotating 90 degrees clockwise until we reach the desired raster vertex for this // invocation. Corners with less than 3 corresponding raster vertices will result in // redundant vertices and degenerate triangles. - v->codeAppendf("int bloatidx = (%s >> %i) & 3;", proc.getAttrib(kAttribIdx_VertexData).name(), + v->codeAppendf("int bloatidx = (%s >> %i) & 3;", proc.fVertexAttribute.name(), kVertexData_BloatIdxShift); v->codeAppend ("switch (bloatidx) {"); v->codeAppend ( "case 3:"); @@ -376,12 +376,12 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) v->codeAppend ("}"); v->codeAppendf("if (0 != (%s & %i)) {", // Are we an edge? - proc.getAttrib(kAttribIdx_VertexData).name(), kVertexData_IsEdgeBit); + proc.fVertexAttribute.name(), kVertexData_IsEdgeBit); v->codeAppend ( "coverage = left_coverage;"); v->codeAppend ("}"); v->codeAppendf("if (0 != (%s & %i)) {", // Invert coverage? - proc.getAttrib(kAttribIdx_VertexData).name(), + proc.fVertexAttribute.name(), kVertexData_InvertNegativeCoverageBit); v->codeAppend ( "coverage = -1 - coverage;"); v->codeAppend ("}"); @@ -391,7 +391,7 @@ void GrCCCoverageProcessor::VSImpl::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) v->codeAppend ("half2 corner_coverage = half2(0);"); v->codeAppendf("if (0 != (%s & %i)) {", // Are we a corner? - proc.getAttrib(kAttribIdx_VertexData).name(), kVertexData_IsCornerBit); + proc.fVertexAttribute.name(), kVertexData_IsCornerBit); // We use coverage=-1 to erase what the hull geometry wrote. // // In the context of curves, this effectively means "wind = -wind" and @@ -495,31 +495,27 @@ void GrCCCoverageProcessor::initVS(GrResourceProvider* rp) { } } + GrVertexAttribType xyAttribType; if (4 == this->numInputPoints() || this->hasInputWeight()) { - SkASSERT(kAttribIdx_X == this->numAttribs()); - this->addInstanceAttrib("X", kFloat4_GrVertexAttribType); - - SkASSERT(kAttribIdx_Y == this->numAttribs()); - this->addInstanceAttrib("Y", kFloat4_GrVertexAttribType); - - SkASSERT(offsetof(QuadPointInstance, fX) == this->getAttrib(kAttribIdx_X).offsetInRecord()); - SkASSERT(offsetof(QuadPointInstance, fY) == this->getAttrib(kAttribIdx_Y).offsetInRecord()); - SkASSERT(sizeof(QuadPointInstance) == this->getInstanceStride()); + GR_STATIC_ASSERT(offsetof(QuadPointInstance, fX) == 0); + GR_STATIC_ASSERT(sizeof(QuadPointInstance::fX) == + GrVertexAttribTypeSize(kFloat4_GrVertexAttribType)); + GR_STATIC_ASSERT(sizeof(QuadPointInstance::fY) == + GrVertexAttribTypeSize(kFloat4_GrVertexAttribType)); + xyAttribType = kFloat4_GrVertexAttribType; } else { - SkASSERT(kAttribIdx_X == this->numAttribs()); - this->addInstanceAttrib("X", kFloat3_GrVertexAttribType); - - SkASSERT(kAttribIdx_Y == this->numAttribs()); - this->addInstanceAttrib("Y", kFloat3_GrVertexAttribType); - - SkASSERT(offsetof(TriPointInstance, fX) == this->getAttrib(kAttribIdx_X).offsetInRecord()); - SkASSERT(offsetof(TriPointInstance, fY) == this->getAttrib(kAttribIdx_Y).offsetInRecord()); - SkASSERT(sizeof(TriPointInstance) == this->getInstanceStride()); + GR_STATIC_ASSERT(offsetof(TriPointInstance, fX) == 0); + GR_STATIC_ASSERT(sizeof(TriPointInstance::fX) == + GrVertexAttribTypeSize(kFloat3_GrVertexAttribType)); + GR_STATIC_ASSERT(sizeof(TriPointInstance::fY) == + GrVertexAttribTypeSize(kFloat3_GrVertexAttribType)); + xyAttribType = kFloat3_GrVertexAttribType; } - - SkASSERT(kAttribIdx_VertexData == this->numAttribs()); - this->addVertexAttrib("vertexdata", kInt_GrVertexAttribType); - SkASSERT(sizeof(int32_t) == this->getVertexStride()); + fInstanceAttributes[kInstanceAttribIdx_X] = {"X", xyAttribType}; + fInstanceAttributes[kInstanceAttribIdx_Y] = {"Y", xyAttribType}; + this->setInstanceAttributeCnt(2); + fVertexAttribute = {"vertexdata", kInt_GrVertexAttribType}; + this->setVertexAttributeCnt(1); if (caps.usePrimitiveRestart()) { fVSTriangleType = GrPrimitiveType::kTriangleStrip; diff --git a/src/gpu/ccpr/GrCCPathProcessor.cpp b/src/gpu/ccpr/GrCCPathProcessor.cpp index b8ebb44059..e180724f8a 100644 --- a/src/gpu/ccpr/GrCCPathProcessor.cpp +++ b/src/gpu/ccpr/GrCCPathProcessor.cpp @@ -65,6 +65,9 @@ static constexpr uint16_t kOctoIndicesAsTris[] = { GR_DECLARE_STATIC_UNIQUE_KEY(gIndexBufferKey); +constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kInstanceAttribs[]; +constexpr GrPrimitiveProcessor::Attribute GrCCPathProcessor::kEdgeNormsAttrib; + sk_sp<const GrBuffer> GrCCPathProcessor::FindIndexBuffer(GrOnFlushResourceProvider* onFlushRP) { GR_DEFINE_STATIC_UNIQUE_KEY(gIndexBufferKey); if (onFlushRP->caps()->usePrimitiveRestart()) { @@ -82,24 +85,19 @@ GrCCPathProcessor::GrCCPathProcessor(GrResourceProvider* resourceProvider, : INHERITED(kGrCCPathProcessor_ClassID) , fAtlasAccess(std::move(atlas), GrSamplerState::Filter::kNearest, GrSamplerState::WrapMode::kClamp, kFragment_GrShaderFlag) { - this->addInstanceAttrib("devbounds", kFloat4_GrVertexAttribType); - this->addInstanceAttrib("devbounds45", kFloat4_GrVertexAttribType); - this->addInstanceAttrib("dev_to_atlas_offset", kInt2_GrVertexAttribType); - this->addInstanceAttrib("color", kUByte4_norm_GrVertexAttribType); - - SkASSERT(offsetof(Instance, fDevBounds) == - this->getInstanceAttrib(InstanceAttribs::kDevBounds).offsetInRecord()); - SkASSERT(offsetof(Instance, fDevBounds45) == - this->getInstanceAttrib(InstanceAttribs::kDevBounds45).offsetInRecord()); - SkASSERT(offsetof(Instance, fDevToAtlasOffset) == - this->getInstanceAttrib(InstanceAttribs::kDevToAtlasOffset).offsetInRecord()); - SkASSERT(offsetof(Instance, fColor) == - this->getInstanceAttrib(InstanceAttribs::kColor).offsetInRecord()); - SkASSERT(sizeof(Instance) == this->getInstanceStride()); - - GR_STATIC_ASSERT(4 == kNumInstanceAttribs); - - this->addVertexAttrib("edge_norms", kFloat4_GrVertexAttribType); + this->setInstanceAttributeCnt(kNumInstanceAttribs); + // Check that instance attributes exactly match Instance struct layout. + SkASSERT(!strcmp(this->instanceAttribute(0).name(), "devbounds")); + SkASSERT(!strcmp(this->instanceAttribute(1).name(), "devbounds45")); + SkASSERT(!strcmp(this->instanceAttribute(2).name(), "dev_to_atlas_offset")); + SkASSERT(!strcmp(this->instanceAttribute(3).name(), "color")); + SkASSERT(this->debugOnly_instanceAttributeOffset(0) == offsetof(Instance, fDevBounds)); + SkASSERT(this->debugOnly_instanceAttributeOffset(1) == offsetof(Instance, fDevBounds45)); + SkASSERT(this->debugOnly_instanceAttributeOffset(2) == offsetof(Instance, fDevToAtlasOffset)); + SkASSERT(this->debugOnly_instanceAttributeOffset(3) == offsetof(Instance, fColor)); + SkASSERT(this->debugOnly_instanceStride() == sizeof(Instance)); + + this->setVertexAttributeCnt(1); fAtlasAccess.instantiate(resourceProvider); this->addTextureSampler(&fAtlasAccess); @@ -170,7 +168,7 @@ void GLSLPathProcessor::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLSLVarying texcoord(kFloat3_GrSLType); GrGLSLVarying color(kHalf4_GrSLType); varyingHandler->addVarying("texcoord", &texcoord); - varyingHandler->addPassThroughAttribute(&proc.getInstanceAttrib(InstanceAttribs::kColor), + varyingHandler->addPassThroughAttribute(proc.getInstanceAttrib(InstanceAttribs::kColor), args.fOutputColor, Interpolation::kCanBeFlat); // The vertex shader bloats and intersects the devBounds and devBounds45 rectangles, in order to diff --git a/src/gpu/ccpr/GrCCPathProcessor.h b/src/gpu/ccpr/GrCCPathProcessor.h index 785dd2c919..54c1b7e2ed 100644 --- a/src/gpu/ccpr/GrCCPathProcessor.h +++ b/src/gpu/ccpr/GrCCPathProcessor.h @@ -77,16 +77,11 @@ public: const GrTexture* atlas() const { return fAtlasAccess.peekTexture(); } const SkMatrix& localMatrix() const { return fLocalMatrix; } const Attribute& getInstanceAttrib(InstanceAttribs attribID) const { - const Attribute& attrib = this->getAttrib((int)attribID); - SkASSERT(Attribute::InputRate::kPerInstance == attrib.inputRate()); - return attrib; - } - const Attribute& getEdgeNormsAttrib() const { - SkASSERT(1 + kNumInstanceAttribs == this->numAttribs()); - const Attribute& attrib = this->getAttrib(kNumInstanceAttribs); - SkASSERT(Attribute::InputRate::kPerVertex == attrib.inputRate()); - return attrib; + int idx = static_cast<int>(attribID); + SkASSERT(idx >= 0 && idx < static_cast<int>(SK_ARRAY_COUNT(kInstanceAttribs))); + return kInstanceAttribs[idx]; } + const Attribute& getEdgeNormsAttrib() const { return kEdgeNormsAttrib; } void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {} GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override; @@ -95,8 +90,18 @@ public: int baseInstance, int endInstance, const SkRect& bounds) const; private: + const Attribute& onVertexAttribute(int i) const override { return kEdgeNormsAttrib; } + const Attribute& onInstanceAttribute(int i) const override { return kInstanceAttribs[i]; } + const TextureSampler fAtlasAccess; SkMatrix fLocalMatrix; + static constexpr Attribute kInstanceAttribs[kNumInstanceAttribs] = { + {"devbounds", kFloat4_GrVertexAttribType}, + {"devbounds45", kFloat4_GrVertexAttribType}, + {"dev_to_atlas_offset", kInt2_GrVertexAttribType}, + {"color", kUByte4_norm_GrVertexAttribType} + }; + static constexpr Attribute kEdgeNormsAttrib = {"edge_norms", kFloat4_GrVertexAttribType}; typedef GrGeometryProcessor INHERITED; }; diff --git a/src/gpu/effects/GrBezierEffect.cpp b/src/gpu/effects/GrBezierEffect.cpp index 3dee2f4dab..d68b1bfed6 100644 --- a/src/gpu/effects/GrBezierEffect.cpp +++ b/src/gpu/effects/GrBezierEffect.cpp @@ -79,7 +79,7 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLSLVarying v(kFloat4_GrSLType); varyingHandler->addVarying("ConicCoeffs", &v); - vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs()->name()); + vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inConicCoeffs().name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // Setup pass through color @@ -89,7 +89,7 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - gp.inPosition()->name(), + gp.inPosition().name(), gp.viewMatrix(), &fViewMatrixUniform); @@ -97,7 +97,7 @@ void GrGLConicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - gp.inPosition()->asShaderVar(), + gp.inPosition().asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); @@ -219,6 +219,8 @@ void GrGLConicEffect::GenKey(const GrGeometryProcessor& gp, ////////////////////////////////////////////////////////////////////////////// +constexpr GrPrimitiveProcessor::Attribute GrConicEffect::kAttributes[]; + GrConicEffect::~GrConicEffect() {} void GrConicEffect::getGLSLProcessorKey(const GrShaderCaps& caps, @@ -240,8 +242,7 @@ GrConicEffect::GrConicEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t , fUsesLocalCoords(usesLocalCoords) , fCoverageScale(coverage) , fEdgeType(edgeType) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInConicCoeffs = &this->addVertexAttrib("inConicCoeffs", kHalf4_GrVertexAttribType); + this->setVertexAttributeCnt(2); } ////////////////////////////////////////////////////////////////////////////// @@ -331,7 +332,7 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { GrGLSLVarying v(kHalf4_GrSLType); varyingHandler->addVarying("HairQuadEdge", &v); - vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge()->name()); + vertBuilder->codeAppendf("%s = %s;", v.vsOut(), gp.inHairQuadEdge().name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // Setup pass through color @@ -341,7 +342,7 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - gp.inPosition()->name(), + gp.inPosition().name(), gp.viewMatrix(), &fViewMatrixUniform); @@ -349,7 +350,7 @@ void GrGLQuadEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - gp.inPosition()->asShaderVar(), + gp.inPosition().asShaderVar(), gp.localMatrix(), args.fFPCoordTransformHandler); @@ -420,6 +421,8 @@ void GrGLQuadEffect::GenKey(const GrGeometryProcessor& gp, ////////////////////////////////////////////////////////////////////////////// +constexpr GrPrimitiveProcessor::Attribute GrQuadEffect::kAttributes[]; + GrQuadEffect::~GrQuadEffect() {} void GrQuadEffect::getGLSLProcessorKey(const GrShaderCaps& caps, @@ -441,8 +444,7 @@ GrQuadEffect::GrQuadEffect(GrColor color, const SkMatrix& viewMatrix, uint8_t co , fUsesLocalCoords(usesLocalCoords) , fCoverageScale(coverage) , fEdgeType(edgeType) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInHairQuadEdge = &this->addVertexAttrib("inHairQuadEdge", kHalf4_GrVertexAttribType); + this->setVertexAttributeCnt(2); } ////////////////////////////////////////////////////////////////////////////// @@ -544,7 +546,7 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - gp.inPosition()->name(), + gp.inPosition().name(), gp.viewMatrix(), &fViewMatrixUniform); @@ -576,7 +578,7 @@ void GrGLCubicEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - gp.inPosition()->asShaderVar(), + gp.inPosition().asShaderVar(), args.fFPCoordTransformHandler); GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0); @@ -647,6 +649,8 @@ void GrGLCubicEffect::GenKey(const GrGeometryProcessor& gp, ////////////////////////////////////////////////////////////////////////////// +constexpr GrPrimitiveProcessor::Attribute GrCubicEffect::kInPosition; + GrCubicEffect::~GrCubicEffect() {} void GrCubicEffect::getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const { @@ -664,7 +668,7 @@ GrCubicEffect::GrCubicEffect(GrColor color, const SkMatrix& viewMatrix, const Sk , fViewMatrix(viewMatrix) , fDevKLMMatrix(devKLMMatrix) , fEdgeType(edgeType) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); + this->setVertexAttributeCnt(1); } ////////////////////////////////////////////////////////////////////////////// diff --git a/src/gpu/effects/GrBezierEffect.h b/src/gpu/effects/GrBezierEffect.h index 174470410c..eebe42a5cd 100644 --- a/src/gpu/effects/GrBezierEffect.h +++ b/src/gpu/effects/GrBezierEffect.h @@ -93,8 +93,8 @@ public: const char* name() const override { return "Conic"; } - inline const Attribute* inPosition() const { return fInPosition; } - inline const Attribute* inConicCoeffs() const { return fInConicCoeffs; } + inline const Attribute& inPosition() const { return kAttributes[0]; } + inline const Attribute& inConicCoeffs() const { return kAttributes[1]; } inline bool isAntiAliased() const { return GrProcessorEdgeTypeIsAA(fEdgeType); } inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrClipEdgeType getEdgeType() const { return fEdgeType; } @@ -112,14 +112,16 @@ private: GrConicEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrClipEdgeType, const SkMatrix& localMatrix, bool usesLocalCoords); + const Attribute& onVertexAttribute(int i) const override { return kAttributes[i]; } + GrColor fColor; SkMatrix fViewMatrix; SkMatrix fLocalMatrix; bool fUsesLocalCoords; uint8_t fCoverageScale; GrClipEdgeType fEdgeType; - const Attribute* fInPosition; - const Attribute* fInConicCoeffs; + static constexpr Attribute kAttributes[] = {{"inPosition", kFloat2_GrVertexAttribType}, + {"inConicCoeffs", kHalf4_GrVertexAttribType}}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST @@ -175,8 +177,8 @@ public: const char* name() const override { return "Quad"; } - inline const Attribute* inPosition() const { return fInPosition; } - inline const Attribute* inHairQuadEdge() const { return fInHairQuadEdge; } + inline const Attribute& inPosition() const { return kAttributes[0]; } + inline const Attribute& inHairQuadEdge() const { return kAttributes[1]; } inline bool isAntiAliased() const { return GrProcessorEdgeTypeIsAA(fEdgeType); } inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrClipEdgeType getEdgeType() const { return fEdgeType; } @@ -194,14 +196,17 @@ private: GrQuadEffect(GrColor, const SkMatrix& viewMatrix, uint8_t coverage, GrClipEdgeType, const SkMatrix& localMatrix, bool usesLocalCoords); - GrColor fColor; - SkMatrix fViewMatrix; - SkMatrix fLocalMatrix; - bool fUsesLocalCoords; - uint8_t fCoverageScale; + const Attribute& onVertexAttribute(int i) const override { return kAttributes[i]; } + + GrColor fColor; + SkMatrix fViewMatrix; + SkMatrix fLocalMatrix; + bool fUsesLocalCoords; + uint8_t fCoverageScale; GrClipEdgeType fEdgeType; - const Attribute* fInPosition; - const Attribute* fInHairQuadEdge; + + static constexpr Attribute kAttributes[] = {{"inPosition", kFloat2_GrVertexAttribType}, + {"inHairQuadEdge", kHalf4_GrVertexAttribType}}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST @@ -263,7 +268,7 @@ public: const char* name() const override { return "Cubic"; } - inline const Attribute* inPosition() const { return fInPosition; } + inline const Attribute& inPosition() const { return kInPosition; } inline bool isAntiAliased() const { return GrProcessorEdgeTypeIsAA(fEdgeType); } inline bool isFilled() const { return GrProcessorEdgeTypeIsFill(fEdgeType); } inline GrClipEdgeType getEdgeType() const { return fEdgeType; } @@ -280,11 +285,14 @@ private: GrCubicEffect(GrColor, const SkMatrix& viewMatrix, const SkMatrix& devKLMMatrix, GrClipEdgeType); - GrColor fColor; - SkMatrix fViewMatrix; - SkMatrix fDevKLMMatrix; + const Attribute& onVertexAttribute(int) const override { return kInPosition; } + + GrColor fColor; + SkMatrix fViewMatrix; + SkMatrix fDevKLMMatrix; GrClipEdgeType fEdgeType; - const Attribute* fInPosition; + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST diff --git a/src/gpu/effects/GrBitmapTextGeoProc.cpp b/src/gpu/effects/GrBitmapTextGeoProc.cpp index 4089555362..2594f40ee5 100644 --- a/src/gpu/effects/GrBitmapTextGeoProc.cpp +++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp @@ -40,7 +40,7 @@ public: GrGLSLVarying uv(kFloat2_GrSLType); GrSLType texIdxType = args.fShaderCaps->integerSupport() ? kInt_GrSLType : kFloat_GrSLType; GrGLSLVarying texIdx(texIdxType); - append_index_uv_varyings(args, btgp.inTextureCoords()->name(), atlasSizeInvName, &uv, + append_index_uv_varyings(args, btgp.inTextureCoords().name(), atlasSizeInvName, &uv, &texIdx, nullptr); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; @@ -53,13 +53,13 @@ public: } // Setup position - gpArgs->fPositionVar = btgp.inPosition()->asShaderVar(); + gpArgs->fPositionVar = btgp.inPosition().asShaderVar(); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - btgp.inPosition()->asShaderVar(), + btgp.inPosition().asShaderVar(), btgp.localMatrix(), args.fFPCoordTransformHandler); @@ -129,23 +129,26 @@ GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, , fColor(color) , fLocalMatrix(localMatrix) , fUsesW(usesW) - , fInColor(nullptr) , fMaskFormat(format) { SkASSERT(numActiveProxies <= kMaxTextures); if (usesW) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat3_GrVertexAttribType); + fInPosition = {"inPosition", kFloat3_GrVertexAttribType}; } else { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); + fInPosition = {"inPosition", kFloat2_GrVertexAttribType}; } + fInTextureCoords = {"inTextureCoords", kUShort2_GrVertexAttribType}; + int cnt = 2; bool hasVertexColor = kA8_GrMaskFormat == fMaskFormat || kA565_GrMaskFormat == fMaskFormat; if (hasVertexColor) { - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); + fInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + ++cnt; } - fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType); + this->setVertexAttributeCnt(cnt); + for (int i = 0; i < numActiveProxies; ++i) { SkASSERT(proxies[i]); @@ -154,6 +157,10 @@ GrBitmapTextGeoProc::GrBitmapTextGeoProc(GrColor color, } } +const GrPrimitiveProcessor::Attribute& GrBitmapTextGeoProc::onVertexAttribute(int i) const { + return IthInitializedAttribute(i, fInPosition, fInColor, fInTextureCoords); +} + void GrBitmapTextGeoProc::addNewProxies(const sk_sp<GrTextureProxy>* proxies, int numActiveProxies, const GrSamplerState& params) { diff --git a/src/gpu/effects/GrBitmapTextGeoProc.h b/src/gpu/effects/GrBitmapTextGeoProc.h index 40ba8559e5..5e444977c2 100644 --- a/src/gpu/effects/GrBitmapTextGeoProc.h +++ b/src/gpu/effects/GrBitmapTextGeoProc.h @@ -36,12 +36,12 @@ public: const char* name() const override { return "Texture"; } - const Attribute* inPosition() const { return fInPosition; } - const Attribute* inColor() const { return fInColor; } - const Attribute* inTextureCoords() const { return fInTextureCoords; } + const Attribute& inPosition() const { return fInPosition; } + const Attribute& inColor() const { return fInColor; } + const Attribute& inTextureCoords() const { return fInTextureCoords; } GrMaskFormat maskFormat() const { return fMaskFormat; } GrColor color() const { return fColor; } - bool hasVertexColor() const { return SkToBool(fInColor); } + bool hasVertexColor() const { return fInColor.isInitialized(); } const SkMatrix& localMatrix() const { return fLocalMatrix; } bool usesW() const { return fUsesW; } @@ -58,13 +58,15 @@ private: const GrSamplerState& params, GrMaskFormat format, const SkMatrix& localMatrix, bool usesW); + const Attribute& onVertexAttribute(int i) const override; + GrColor fColor; SkMatrix fLocalMatrix; bool fUsesW; TextureSampler fTextureSamplers[kMaxTextures]; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInTextureCoords; + Attribute fInPosition; + Attribute fInColor; + Attribute fInTextureCoords; GrMaskFormat fMaskFormat; GR_DECLARE_GEOMETRY_PROCESSOR_TEST diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.cpp b/src/gpu/effects/GrDistanceFieldGeoProc.cpp index 5ac73989ee..4d5d50b8db 100644 --- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp +++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp @@ -54,13 +54,13 @@ public: varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor); // Setup position - gpArgs->fPositionVar = dfTexEffect.inPosition()->asShaderVar(); + gpArgs->fPositionVar = dfTexEffect.inPosition().asShaderVar(); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - dfTexEffect.inPosition()->asShaderVar(), + dfTexEffect.inPosition().asShaderVar(), dfTexEffect.localMatrix(), args.fFPCoordTransformHandler); @@ -69,7 +69,7 @@ public: GrSLType texIdxType = args.fShaderCaps->integerSupport() ? kInt_GrSLType : kFloat_GrSLType; GrGLSLVarying texIdx(texIdxType); GrGLSLVarying st(kFloat2_GrSLType); - append_index_uv_varyings(args, dfTexEffect.inTextureCoords()->name(), atlasSizeInvName, &uv, + append_index_uv_varyings(args, dfTexEffect.inTextureCoords().name(), atlasSizeInvName, &uv, &texIdx, &st); bool isUniformScale = (dfTexEffect.getFlags() & kUniformScale_DistanceFieldEffectMask) == @@ -206,32 +206,34 @@ private: /////////////////////////////////////////////////////////////////////////////// -GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc( - const sk_sp<GrTextureProxy>* proxies, - int numProxies, - const GrSamplerState& params, +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldA8TextGeoProc::kInColor; +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldA8TextGeoProc::kInTextureCoords; + +GrDistanceFieldA8TextGeoProc::GrDistanceFieldA8TextGeoProc(const sk_sp<GrTextureProxy>* proxies, + int numProxies, + const GrSamplerState& params, #ifdef SK_GAMMA_APPLY_TO_A8 - float distanceAdjust, + float distanceAdjust, #endif - uint32_t flags, - const SkMatrix& localMatrix) + uint32_t flags, + const SkMatrix& localMatrix) : INHERITED(kGrDistanceFieldA8TextGeoProc_ClassID) + , fLocalMatrix(localMatrix) + , fFlags(flags & kNonLCD_DistanceFieldEffectMask) #ifdef SK_GAMMA_APPLY_TO_A8 , fDistanceAdjust(distanceAdjust) #endif - , fFlags(flags & kNonLCD_DistanceFieldEffectMask) - , fInColor(nullptr) - , fLocalMatrix(localMatrix) { +{ SkASSERT(numProxies <= kMaxTextures); - SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); + if (flags & kPerspective_DistanceFieldEffectFlag) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat3_GrVertexAttribType); + fInPosition = {"inPosition", kFloat3_GrVertexAttribType}; } else { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); + fInPosition = {"inPosition", kFloat2_GrVertexAttribType}; } - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType); + this->setVertexAttributeCnt(3); + for (int i = 0; i < numProxies; ++i) { SkASSERT(proxies[i]); @@ -337,8 +339,8 @@ public: GrSLType texIdxType = args.fShaderCaps->integerSupport() ? kInt_GrSLType : kFloat_GrSLType; GrGLSLVarying texIdx(texIdxType); GrGLSLVarying st(kFloat2_GrSLType); - append_index_uv_varyings(args, dfPathEffect.inTextureCoords()->name(), atlasSizeInvName, - &uv, &texIdx, &st); + append_index_uv_varyings(args, dfPathEffect.inTextureCoords().name(), atlasSizeInvName, &uv, + &texIdx, &st); // setup pass through color varyingHandler->addPassThroughAttribute(dfPathEffect.inColor(), args.fOutputColor); @@ -348,7 +350,7 @@ public: this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - dfPathEffect.inPosition()->name(), + dfPathEffect.inPosition().name(), dfPathEffect.matrix(), &fMatrixUniform); @@ -356,17 +358,17 @@ public: this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - dfPathEffect.inPosition()->asShaderVar(), + dfPathEffect.inPosition().asShaderVar(), args.fFPCoordTransformHandler); } else { // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, dfPathEffect.inPosition()->name()); + this->writeOutputPosition(vertBuilder, gpArgs, dfPathEffect.inPosition().name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - dfPathEffect.inPosition()->asShaderVar(), + dfPathEffect.inPosition().asShaderVar(), dfPathEffect.matrix(), args.fFPCoordTransformHandler); } @@ -499,22 +501,22 @@ private: }; /////////////////////////////////////////////////////////////////////////////// -GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc( - const SkMatrix& matrix, - const sk_sp<GrTextureProxy>* proxies, - int numProxies, - const GrSamplerState& params, - uint32_t flags) +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldPathGeoProc::kInPosition; +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldPathGeoProc::kInColor; +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldPathGeoProc::kInTextureCoords; + +GrDistanceFieldPathGeoProc::GrDistanceFieldPathGeoProc(const SkMatrix& matrix, + const sk_sp<GrTextureProxy>* proxies, + int numProxies, + const GrSamplerState& params, + uint32_t flags) : INHERITED(kGrDistanceFieldPathGeoProc_ClassID) , fMatrix(matrix) - , fFlags(flags & kNonLCD_DistanceFieldEffectMask) - , fInColor(nullptr) { + , fFlags(flags & kNonLCD_DistanceFieldEffectMask) { SkASSERT(numProxies <= kMaxTextures); - SkASSERT(!(flags & ~kNonLCD_DistanceFieldEffectMask)); - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType); + + this->setVertexAttributeCnt(3); for (int i = 0; i < numProxies; ++i) { SkASSERT(proxies[i]); @@ -548,6 +550,10 @@ GrDistanceFieldPathGeoProc::createGLSLInstance(const GrShaderCaps&) const { return new GrGLDistanceFieldPathGeoProc(); } +const GrPrimitiveProcessor::Attribute& GrDistanceFieldPathGeoProc::onVertexAttribute(int i) const { + return IthAttribute(i, kInPosition, kInColor, kInTextureCoords); +} + /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldPathGeoProc); @@ -614,13 +620,13 @@ public: varyingHandler->addPassThroughAttribute(dfTexEffect.inColor(), args.fOutputColor); // Setup position - gpArgs->fPositionVar = dfTexEffect.inPosition()->asShaderVar(); + gpArgs->fPositionVar = dfTexEffect.inPosition().asShaderVar(); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - dfTexEffect.inPosition()->asShaderVar(), + dfTexEffect.inPosition().asShaderVar(), dfTexEffect.localMatrix(), args.fFPCoordTransformHandler); @@ -629,7 +635,7 @@ public: GrSLType texIdxType = args.fShaderCaps->integerSupport() ? kInt_GrSLType : kFloat_GrSLType; GrGLSLVarying texIdx(texIdxType); GrGLSLVarying st(kFloat2_GrSLType); - append_index_uv_varyings(args, dfTexEffect.inTextureCoords()->name(), atlasSizeInvName, &uv, + append_index_uv_varyings(args, dfTexEffect.inTextureCoords().name(), atlasSizeInvName, &uv, &texIdx, &st); GrGLSLVarying delta(kFloat_GrSLType); @@ -802,27 +808,30 @@ private: }; /////////////////////////////////////////////////////////////////////////////// -GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc( - const sk_sp<GrTextureProxy>* proxies, - int numProxies, - const GrSamplerState& params, - DistanceAdjust distanceAdjust, - uint32_t flags, - const SkMatrix& localMatrix) + +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldLCDTextGeoProc::kInColor; +constexpr GrPrimitiveProcessor::Attribute GrDistanceFieldLCDTextGeoProc::kInTextureCoords; + +GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(const sk_sp<GrTextureProxy>* proxies, + int numProxies, + const GrSamplerState& params, + DistanceAdjust distanceAdjust, + uint32_t flags, + const SkMatrix& localMatrix) : INHERITED(kGrDistanceFieldLCDTextGeoProc_ClassID) + , fLocalMatrix(localMatrix) , fDistanceAdjust(distanceAdjust) - , fFlags(flags & kLCD_DistanceFieldEffectMask) - , fLocalMatrix(localMatrix) { + , fFlags(flags & kLCD_DistanceFieldEffectMask) { SkASSERT(numProxies <= kMaxTextures); - SkASSERT(!(flags & ~kLCD_DistanceFieldEffectMask) && (flags & kUseLCD_DistanceFieldEffectFlag)); + if (fFlags & kPerspective_DistanceFieldEffectFlag) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat3_GrVertexAttribType); + fInPosition = {"inPosition", kFloat3_GrVertexAttribType}; } else { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); + fInPosition = {"inPosition", kFloat2_GrVertexAttribType}; } - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInTextureCoords = &this->addVertexAttrib("inTextureCoords", kUShort2_GrVertexAttribType); + this->setVertexAttributeCnt(3); + for (int i = 0; i < numProxies; ++i) { SkASSERT(proxies[i]); @@ -855,6 +864,11 @@ GrGLSLPrimitiveProcessor* GrDistanceFieldLCDTextGeoProc::createGLSLInstance(cons return new GrGLDistanceFieldLCDTextGeoProc(); } +const GrPrimitiveProcessor::Attribute& GrDistanceFieldLCDTextGeoProc::onVertexAttribute( + int i) const { + return IthAttribute(i, fInPosition, kInColor, kInTextureCoords); +} + /////////////////////////////////////////////////////////////////////////////// GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrDistanceFieldLCDTextGeoProc); diff --git a/src/gpu/effects/GrDistanceFieldGeoProc.h b/src/gpu/effects/GrDistanceFieldGeoProc.h index 5ba19ed5a5..71626fa938 100644 --- a/src/gpu/effects/GrDistanceFieldGeoProc.h +++ b/src/gpu/effects/GrDistanceFieldGeoProc.h @@ -76,9 +76,9 @@ public: const char* name() const override { return "DistanceFieldA8Text"; } - const Attribute* inPosition() const { return fInPosition; } - const Attribute* inColor() const { return fInColor; } - const Attribute* inTextureCoords() const { return fInTextureCoords; } + const Attribute& inPosition() const { return fInPosition; } + const Attribute& inColor() const { return kInColor; } + const Attribute& inTextureCoords() const { return kInTextureCoords; } const SkMatrix& localMatrix() const { return fLocalMatrix; } #ifdef SK_GAMMA_APPLY_TO_A8 float getDistanceAdjust() const { return fDistanceAdjust; } @@ -100,17 +100,22 @@ private: #endif uint32_t flags, const SkMatrix& localMatrix); + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, fInPosition, kInColor, kInTextureCoords); + } + static constexpr int kMaxTextures = 4; TextureSampler fTextureSamplers[kMaxTextures]; + SkMatrix fLocalMatrix; + Attribute fInPosition; + uint32_t fFlags; #ifdef SK_GAMMA_APPLY_TO_A8 float fDistanceAdjust; #endif - uint32_t fFlags; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInTextureCoords; - SkMatrix fLocalMatrix; + + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInTextureCoords = {"inTextureCoords", kUShort2_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST @@ -139,9 +144,9 @@ public: const char* name() const override { return "DistanceFieldPath"; } - const Attribute* inPosition() const { return fInPosition; } - const Attribute* inColor() const { return fInColor; } - const Attribute* inTextureCoords() const { return fInTextureCoords; } + const Attribute& inPosition() const { return kInPosition; } + const Attribute& inColor() const { return kInColor; } + const Attribute& inTextureCoords() const { return kInTextureCoords; } const SkMatrix& matrix() const { return fMatrix; } uint32_t getFlags() const { return fFlags; } @@ -159,12 +164,14 @@ private: int numActiveProxies, const GrSamplerState&, uint32_t flags); + const Attribute& onVertexAttribute(int i) const override; + SkMatrix fMatrix; // view matrix if perspective, local matrix otherwise TextureSampler fTextureSamplers[kMaxTextures]; uint32_t fFlags; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInTextureCoords; + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInTextureCoords = {"inTextureCoords", kUShort2_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST @@ -209,9 +216,9 @@ public: const char* name() const override { return "DistanceFieldLCDText"; } - const Attribute* inPosition() const { return fInPosition; } - const Attribute* inColor() const { return fInColor; } - const Attribute* inTextureCoords() const { return fInTextureCoords; } + const Attribute& inPosition() const { return fInPosition; } + const Attribute& inColor() const { return kInColor; } + const Attribute& inTextureCoords() const { return kInTextureCoords; } DistanceAdjust getDistanceAdjust() const { return fDistanceAdjust; } uint32_t getFlags() const { return fFlags; } const SkMatrix& localMatrix() const { return fLocalMatrix; } @@ -227,15 +234,18 @@ private: const GrSamplerState& params, DistanceAdjust wa, uint32_t flags, const SkMatrix& localMatrix); + const Attribute& onVertexAttribute(int) const override; + static constexpr int kMaxTextures = 4; TextureSampler fTextureSamplers[kMaxTextures]; + const SkMatrix fLocalMatrix; DistanceAdjust fDistanceAdjust; + Attribute fInPosition; uint32_t fFlags; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInTextureCoords; - const SkMatrix fLocalMatrix; + + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInTextureCoords = {"inTextureCoords", kUShort2_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST diff --git a/src/gpu/effects/GrShadowGeoProc.cpp b/src/gpu/effects/GrShadowGeoProc.cpp index 52bf287bea..bf78f41c97 100644 --- a/src/gpu/effects/GrShadowGeoProc.cpp +++ b/src/gpu/effects/GrShadowGeoProc.cpp @@ -33,13 +33,13 @@ public: varyingHandler->addPassThroughAttribute(rsgp.inColor(), args.fOutputColor); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, rsgp.inPosition()->name()); + this->writeOutputPosition(vertBuilder, gpArgs, rsgp.inPosition().name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - rsgp.inPosition()->asShaderVar(), + rsgp.inPosition().asShaderVar(), args.fFPCoordTransformHandler); fragBuilder->codeAppend("half d = length(shadowParams.xy);"); @@ -62,11 +62,8 @@ private: /////////////////////////////////////////////////////////////////////////////// -GrRRectShadowGeoProc::GrRRectShadowGeoProc() -: INHERITED(kGrRRectShadowGeoProc_ClassID) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInShadowParams = &this->addVertexAttrib("inShadowParams", kHalf4_GrVertexAttribType); +GrRRectShadowGeoProc::GrRRectShadowGeoProc() : INHERITED(kGrRRectShadowGeoProc_ClassID) { + this->setVertexAttributeCnt(3); } GrGLSLPrimitiveProcessor* GrRRectShadowGeoProc::createGLSLInstance(const GrShaderCaps&) const { @@ -75,6 +72,10 @@ GrGLSLPrimitiveProcessor* GrRRectShadowGeoProc::createGLSLInstance(const GrShade /////////////////////////////////////////////////////////////////////////////// +constexpr GrPrimitiveProcessor::Attribute GrRRectShadowGeoProc::kInPosition; +constexpr GrPrimitiveProcessor::Attribute GrRRectShadowGeoProc::kInColor; +constexpr GrPrimitiveProcessor::Attribute GrRRectShadowGeoProc::kInShadowParams; + GR_DEFINE_GEOMETRY_PROCESSOR_TEST(GrRRectShadowGeoProc); #if GR_TEST_UTILS diff --git a/src/gpu/effects/GrShadowGeoProc.h b/src/gpu/effects/GrShadowGeoProc.h index 0b4baf49b8..df3e501c59 100644 --- a/src/gpu/effects/GrShadowGeoProc.h +++ b/src/gpu/effects/GrShadowGeoProc.h @@ -25,9 +25,9 @@ public: const char* name() const override { return "RRectShadow"; } - const Attribute* inPosition() const { return fInPosition; } - const Attribute* inColor() const { return fInColor; } - const Attribute* inShadowParams() const { return fInShadowParams; } + const Attribute& inPosition() const { return kInPosition; } + const Attribute& inColor() const { return kInColor; } + const Attribute& inShadowParams() const { return kInShadowParams; } GrColor color() const { return fColor; } void getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {} @@ -37,10 +37,15 @@ public: private: GrRRectShadowGeoProc(); + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInColor, kInShadowParams); + } + GrColor fColor; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInShadowParams; + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInShadowParams = {"inShadowParams", kHalf4_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp index 88f5abecb4..be53222ee8 100644 --- a/src/gpu/gl/GrGLGpu.cpp +++ b/src/gpu/gl/GrGLGpu.cpp @@ -1775,35 +1775,29 @@ void GrGLGpu::setupGeometry(const GrBuffer* indexBuffer, attribState = fHWVertexArrayState.bindInternalVertexArray(this); } - struct { - const GrBuffer* fBuffer; - int fStride; - size_t fBufferOffset; - } bindings[2]; + int numAttribs = fHWProgram->numVertexAttributes() + fHWProgram->numInstanceAttributes(); + attribState->enableVertexArrays(this, numAttribs, enablePrimitiveRestart); if (int vertexStride = fHWProgram->vertexStride()) { SkASSERT(vertexBuffer && !vertexBuffer->isMapped()); - bindings[0].fBuffer = vertexBuffer; - bindings[0].fStride = vertexStride; - bindings[0].fBufferOffset = vertexBuffer->baseOffset() + baseVertex * vertexStride; + size_t bufferOffset = vertexBuffer->baseOffset() + baseVertex * vertexStride; + for (int i = 0; i < fHWProgram->numVertexAttributes(); ++i) { + const auto& attrib = fHWProgram->vertexAttribute(i); + static constexpr int kDivisor = 0; + attribState->set(this, attrib.fLocation, vertexBuffer, attrib.fType, vertexStride, + bufferOffset + attrib.fOffset, kDivisor); + } } if (int instanceStride = fHWProgram->instanceStride()) { SkASSERT(instanceBuffer && !instanceBuffer->isMapped()); - bindings[1].fBuffer = instanceBuffer; - bindings[1].fStride = instanceStride; - bindings[1].fBufferOffset = instanceBuffer->baseOffset() + baseInstance * instanceStride; - } - - auto numAttributes = fHWProgram->numAttributes(); - attribState->enableVertexArrays(this, numAttributes, enablePrimitiveRestart); - - for (int i = 0; i < numAttributes; ++i) { - using InputRate = GrPrimitiveProcessor::Attribute::InputRate; - const GrGLProgram::Attribute& attribute = fHWProgram->attribute(i); - const int divisor = InputRate::kPerInstance == attribute.fInputRate ? 1 : 0; - const auto& binding = bindings[divisor]; - attribState->set(this, attribute.fLocation, binding.fBuffer, attribute.fType, - binding.fStride, binding.fBufferOffset + attribute.fOffset, divisor); + size_t bufferOffset = instanceBuffer->baseOffset() + baseInstance * instanceStride; + int attribIdx = fHWProgram->numVertexAttributes(); + for (int i = 0; i < fHWProgram->numInstanceAttributes(); ++i, ++attribIdx) { + const auto& attrib = fHWProgram->instanceAttribute(i); + static constexpr int kDivisor = 1; + attribState->set(this, attrib.fLocation, instanceBuffer, attrib.fType, instanceStride, + bufferOffset + attrib.fOffset, kDivisor); + } } } diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp index 262f0b21c4..3d4bd380fa 100644 --- a/src/gpu/gl/GrGLProgram.cpp +++ b/src/gpu/gl/GrGLProgram.cpp @@ -38,7 +38,8 @@ GrGLProgram::GrGLProgram( std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors, int fragmentProcessorCnt, std::unique_ptr<Attribute[]> attributes, - int attributeCnt, + int vertexAttributeCnt, + int instanceAttributeCnt, int vertexStride, int instanceStride) : fBuiltinUniformHandles(builtinUniforms) @@ -48,7 +49,8 @@ GrGLProgram::GrGLProgram( , fFragmentProcessors(std::move(fragmentProcessors)) , fFragmentProcessorCnt(fragmentProcessorCnt) , fAttributes(std::move(attributes)) - , fAttributeCnt(attributeCnt) + , fVertexAttributeCnt(vertexAttributeCnt) + , fInstanceAttributeCnt(instanceAttributeCnt) , fVertexStride(vertexStride) , fInstanceStride(instanceStride) , fGpu(gpu) diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h index 6ea1f2cbf9..ca4eddce4b 100644 --- a/src/gpu/gl/GrGLProgram.h +++ b/src/gpu/gl/GrGLProgram.h @@ -10,7 +10,6 @@ #define GrGLProgram_DEFINED #include "GrGLProgramDataManager.h" -#include "GrPrimitiveProcessor.h" #include "glsl/GrGLSLProgramDataManager.h" #include "glsl/GrGLSLUniformHandler.h" @@ -35,15 +34,18 @@ public: */ struct Attribute { GrVertexAttribType fType; - int fOffset; + size_t fOffset; GrGLint fLocation; - GrPrimitiveProcessor::Attribute::InputRate fInputRate; }; using UniformHandle = GrGLSLProgramDataManager::UniformHandle; using UniformInfoArray = GrGLProgramDataManager::UniformInfoArray; using VaryingInfoArray = GrGLProgramDataManager::VaryingInfoArray; + /** + * The attribute array consists of vertexAttributeCnt + instanceAttributeCnt elements with + * the vertex attributes preceding the instance attributes. + */ GrGLProgram(GrGLGpu*, const GrGLSLBuiltinUniformHandles&, GrGLuint programID, @@ -56,7 +58,8 @@ public: std::unique_ptr<std::unique_ptr<GrGLSLFragmentProcessor>[]> fragmentProcessors, int fragmentProcessorCnt, std::unique_ptr<Attribute[]>, - int attributeCnt, + int vertexAttributeCnt, + int instanceAttributeCnt, int vertexStride, int instanceStride); @@ -124,8 +127,17 @@ public: int vertexStride() const { return fVertexStride; } int instanceStride() const { return fInstanceStride; } - int numAttributes() const { return fAttributeCnt; } - const Attribute& attribute(int i) const { return fAttributes[i]; } + int numVertexAttributes() const { return fVertexAttributeCnt; } + const Attribute& vertexAttribute(int i) const { + SkASSERT(i >= 0 && i < fVertexAttributeCnt); + return fAttributes[i]; + } + + int numInstanceAttributes() const { return fInstanceAttributeCnt; } + const Attribute& instanceAttribute(int i) const { + SkASSERT(i >= 0 && i < fInstanceAttributeCnt); + return fAttributes[i + fVertexAttributeCnt]; + } private: // A helper to loop over effects, set the transforms (via subclass) and bind textures @@ -153,7 +165,8 @@ private: int fFragmentProcessorCnt; std::unique_ptr<Attribute[]> fAttributes; - int fAttributeCnt; + int fVertexAttributeCnt; + int fInstanceAttributeCnt; int fVertexStride; int fInstanceStride; diff --git a/src/gpu/gl/GrGLVaryingHandler.cpp b/src/gpu/gl/GrGLVaryingHandler.cpp index eecc63e617..e426d46e14 100644 --- a/src/gpu/gl/GrGLVaryingHandler.cpp +++ b/src/gpu/gl/GrGLVaryingHandler.cpp @@ -20,7 +20,8 @@ GrGLSLVaryingHandler::VaryingHandle GrGLVaryingHandler::addPathProcessingVarying SkASSERT(glPB->gpu()->glCaps().shaderCaps()->pathRenderingSupport() && glPB->fPrimProc.isPathRendering() && !glPB->fPrimProc.willUseGeoShader() && - glPB->fPrimProc.numAttribs() == 0); + !glPB->fPrimProc.numVertexAttributes() && + !glPB->fPrimProc.numInstanceAttributes()); #endif this->addVarying(name, v); auto varyingInfo = fPathProcVaryingInfos.push_back(); diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp index 0cdc3b5b21..79e13d3555 100644 --- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp +++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp @@ -70,7 +70,8 @@ GrGLProgramBuilder::GrGLProgramBuilder(GrGLGpu* gpu, , fGpu(gpu) , fVaryingHandler(this) , fUniformHandler(this) - , fAttributeCnt(0) + , fVertexAttributeCnt(0) + , fInstanceAttributeCnt(0) , fVertexStride(0) , fInstanceStride(0) {} @@ -227,18 +228,30 @@ GrGLProgram* GrGLProgramBuilder::finalize() { // NVPR actually requires a vertex shader to compile bool useNvpr = primProc.isPathRendering(); if (!useNvpr) { - fAttributeCnt = primProc.numAttribs(); - fAttributes.reset(new GrGLProgram::Attribute[fAttributeCnt]); - fVertexStride = primProc.getVertexStride(); - fInstanceStride = primProc.getInstanceStride(); - for (int i = 0; i < fAttributeCnt; i++) { - const auto& attr = primProc.getAttrib(i); - fAttributes[i].fInputRate = attr.inputRate(); - fAttributes[i].fType = attr.type(); - fAttributes[i].fOffset = attr.offsetInRecord(); + fVertexAttributeCnt = primProc.numVertexAttributes(); + fInstanceAttributeCnt = primProc.numInstanceAttributes(); + fAttributes.reset( + new GrGLProgram::Attribute[fVertexAttributeCnt + fInstanceAttributeCnt]); + auto addAttr = [&](int i, const auto& a, size_t* stride) { + fAttributes[i].fType = a.type(); + fAttributes[i].fOffset = *stride; + *stride += a.sizeAlign4(); fAttributes[i].fLocation = i; - GL_CALL(BindAttribLocation(programID, i, attr.name())); + GL_CALL(BindAttribLocation(programID, i, a.name())); + }; + fVertexStride = 0; + int i = 0; + for (; i < fVertexAttributeCnt; i++) { + addAttr(i, primProc.vertexAttribute(i), &fVertexStride); + SkASSERT(fAttributes[i].fOffset == primProc.debugOnly_vertexAttributeOffset(i)); } + SkASSERT(fVertexStride == primProc.debugOnly_vertexStride()); + fInstanceStride = 0; + for (int j = 0; j < fInstanceAttributeCnt; j++, ++i) { + addAttr(i, primProc.instanceAttribute(j), &fInstanceStride); + SkASSERT(fAttributes[i].fOffset == primProc.debugOnly_instanceAttributeOffset(j)); + } + SkASSERT(fInstanceStride == primProc.debugOnly_instanceStride()); } if (primProc.willUseGeoShader()) { @@ -406,7 +419,8 @@ GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) { std::move(fFragmentProcessors), fFragmentProcessorCnt, std::move(fAttributes), - fAttributeCnt, + fVertexAttributeCnt, + fInstanceAttributeCnt, fVertexStride, fInstanceStride); } diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h index ea3432bd04..30d5179325 100644 --- a/src/gpu/gl/builders/GrGLProgramBuilder.h +++ b/src/gpu/gl/builders/GrGLProgramBuilder.h @@ -81,9 +81,10 @@ private: GrGLUniformHandler fUniformHandler; std::unique_ptr<GrGLProgram::Attribute[]> fAttributes; - int fAttributeCnt; - int fVertexStride; - int fInstanceStride; + int fVertexAttributeCnt; + int fInstanceAttributeCnt; + size_t fVertexStride; + size_t fInstanceStride; // shader pulled from cache. Data is organized as: // SkSL::Program::Inputs inputs diff --git a/src/gpu/glsl/GrGLSLVarying.cpp b/src/gpu/glsl/GrGLSLVarying.cpp index f8ec1c24d9..0563406385 100644 --- a/src/gpu/glsl/GrGLSLVarying.cpp +++ b/src/gpu/glsl/GrGLSLVarying.cpp @@ -9,14 +9,15 @@ #include "glsl/GrGLSLVarying.h" #include "glsl/GrGLSLProgramBuilder.h" -void GrGLSLVaryingHandler::addPassThroughAttribute(const GrGeometryProcessor::Attribute* input, +void GrGLSLVaryingHandler::addPassThroughAttribute(const GrGeometryProcessor::Attribute& input, const char* output, Interpolation interpolation) { + SkASSERT(input.isInitialized()); SkASSERT(!fProgramBuilder->primitiveProcessor().willUseGeoShader()); - GrSLType type = GrVertexAttribTypeToSLType(input->type()); + GrSLType type = GrVertexAttribTypeToSLType(input.type()); GrGLSLVarying v(type); - this->addVarying(input->name(), &v, interpolation); - fProgramBuilder->fVS.codeAppendf("%s = %s;", v.vsOut(), input->name()); + this->addVarying(input.name(), &v, interpolation); + fProgramBuilder->fVS.codeAppendf("%s = %s;", v.vsOut(), input.name()); fProgramBuilder->fFS.codeAppendf("%s = %s;", output, v.fsIn()); } @@ -67,10 +68,13 @@ void GrGLSLVaryingHandler::addVarying(const char* name, GrGLSLVarying* varying, } void GrGLSLVaryingHandler::emitAttributes(const GrGeometryProcessor& gp) { - int vaCount = gp.numAttribs(); + int vaCount = gp.numVertexAttributes(); for (int i = 0; i < vaCount; i++) { - const GrGeometryProcessor::Attribute& attr = gp.getAttrib(i); - this->addAttribute(attr.asShaderVar()); + this->addAttribute(gp.vertexAttribute(i).asShaderVar()); + } + int iaCount = gp.numInstanceAttributes(); + for (int i = 0; i < iaCount; i++) { + this->addAttribute(gp.instanceAttribute(i).asShaderVar()); } } diff --git a/src/gpu/glsl/GrGLSLVarying.h b/src/gpu/glsl/GrGLSLVarying.h index 57704ad075..0da88a0fbd 100644 --- a/src/gpu/glsl/GrGLSLVarying.h +++ b/src/gpu/glsl/GrGLSLVarying.h @@ -104,7 +104,7 @@ public: * that will be set as the output varying for all emitted vertices. * TODO it might be nicer behavior to have a flag to declare output inside these calls */ - void addPassThroughAttribute(const GrGeometryProcessor::Attribute*, const char* output, + void addPassThroughAttribute(const GrGeometryProcessor::Attribute&, const char* output, Interpolation = Interpolation::kInterpolated); void emitAttributes(const GrGeometryProcessor& gp); diff --git a/src/gpu/ops/GrAAConvexPathRenderer.cpp b/src/gpu/ops/GrAAConvexPathRenderer.cpp index 3237afeaed..566eebd827 100644 --- a/src/gpu/ops/GrAAConvexPathRenderer.cpp +++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp @@ -576,21 +576,21 @@ public: GrGLSLVarying v(kHalf4_GrSLType); varyingHandler->addVarying("QuadEdge", &v); - vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.fInQuadEdge->name()); + vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.kInQuadEdge.name()); // Setup pass through color - varyingHandler->addPassThroughAttribute(qe.fInColor, args.fOutputColor); + varyingHandler->addPassThroughAttribute(qe.kInColor, args.fOutputColor); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, qe.fInPosition->name()); + this->writeOutputPosition(vertBuilder, gpArgs, qe.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - qe.fInPosition->asShaderVar(), + qe.kInPosition.asShaderVar(), qe.fLocalMatrix, args.fFPCoordTransformHandler); @@ -646,21 +646,25 @@ private: : INHERITED(kQuadEdgeEffect_ClassID) , fLocalMatrix(localMatrix) , fUsesLocalCoords(usesLocalCoords) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInQuadEdge = &this->addVertexAttrib("inQuadEdge", kHalf4_GrVertexAttribType); + this->setVertexAttributeCnt(3); } - const Attribute* fInPosition; - const Attribute* fInQuadEdge; - const Attribute* fInColor; - SkMatrix fLocalMatrix; - bool fUsesLocalCoords; + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInColor, kInQuadEdge); + } + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInQuadEdge = {"inQuadEdge", kHalf4_GrVertexAttribType}; + SkMatrix fLocalMatrix; + bool fUsesLocalCoords; GR_DECLARE_GEOMETRY_PROCESSOR_TEST typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute QuadEdgeEffect::kInPosition; +constexpr GrPrimitiveProcessor::Attribute QuadEdgeEffect::kInColor; +constexpr GrPrimitiveProcessor::Attribute QuadEdgeEffect::kInQuadEdge; GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect); @@ -795,12 +799,10 @@ private: return; } - size_t vertexStride = gp->getVertexStride(); - - SkASSERT(fHelper.compatibleWithAlphaAsCoverage() - ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) - : vertexStride == - sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr)); + size_t vertexStride = fHelper.compatibleWithAlphaAsCoverage() + ? sizeof(GrDefaultGeoProcFactory::PositionColorAttr) + : sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); GrAAConvexTessellator tess; @@ -901,9 +903,9 @@ private: const GrBuffer* vertexBuffer; int firstVertex; - size_t vertexStride = quadProcessor->getVertexStride(); + SkASSERT(sizeof(QuadVertex) == quadProcessor->debugOnly_vertexStride()); QuadVertex* verts = reinterpret_cast<QuadVertex*>(target->makeVertexSpace( - vertexStride, vertexCount, &vertexBuffer, &firstVertex)); + sizeof(QuadVertex), vertexCount, &vertexBuffer, &firstVertex)); if (!verts) { SkDebugf("Could not allocate vertices\n"); diff --git a/src/gpu/ops/GrAAFillRectOp.cpp b/src/gpu/ops/GrAAFillRectOp.cpp index 5472f11f71..76bc8128cf 100644 --- a/src/gpu/ops/GrAAFillRectOp.cpp +++ b/src/gpu/ops/GrAAFillRectOp.cpp @@ -242,12 +242,19 @@ private: void onPrepareDraws(Target* target) override { using namespace GrDefaultGeoProcFactory; + size_t vertexStride = sizeof(SkPoint) + sizeof(GrColor); Color color(Color::kPremulGrColorAttribute_Type); - Coverage::Type coverageType = fHelper.compatibleWithAlphaAsCoverage() - ? Coverage::kSolid_Type - : Coverage::kAttribute_Type; - LocalCoords lc = fHelper.usesLocalCoords() ? LocalCoords::kHasExplicit_Type - : LocalCoords::kUnused_Type; + Coverage::Type coverageType = Coverage::kSolid_Type; + if (!fHelper.compatibleWithAlphaAsCoverage()) { + coverageType = Coverage::kAttribute_Type; + vertexStride += sizeof(float); + } + LocalCoords lc = LocalCoords::kUnused_Type; + if (fHelper.usesLocalCoords()) { + lc = LocalCoords::kHasExplicit_Type; + vertexStride += sizeof(SkPoint); + } + sk_sp<GrGeometryProcessor> gp = GrDefaultGeoProcFactory::Make(color, coverageType, lc, SkMatrix::I()); if (!gp) { @@ -255,7 +262,7 @@ private: return; } - size_t vertexStride = gp->getVertexStride(); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); sk_sp<const GrBuffer> indexBuffer = get_index_buffer(target->resourceProvider()); PatternHelper helper(GrPrimitiveType::kTriangles); diff --git a/src/gpu/ops/GrAAHairLinePathRenderer.cpp b/src/gpu/ops/GrAAHairLinePathRenderer.cpp index b62c14b197..89dedc48a4 100644 --- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp +++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp @@ -959,18 +959,16 @@ void AAHairlineOp::onPrepareDraws(Target* target) { const GrBuffer* vertexBuffer; int firstVertex; - size_t vertexStride = lineGP->getVertexStride(); + SkASSERT(sizeof(LineVertex) == lineGP->debugOnly_vertexStride()); int vertexCount = kLineSegNumVertices * lineCount; - LineVertex* verts = reinterpret_cast<LineVertex*>( - target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex)); + LineVertex* verts = reinterpret_cast<LineVertex*>(target->makeVertexSpace( + sizeof(LineVertex), vertexCount, &vertexBuffer, &firstVertex)); if (!verts|| !linesIndexBuffer) { SkDebugf("Could not allocate vertices\n"); return; } - SkASSERT(lineGP->getVertexStride() == sizeof(LineVertex)); - for (int i = 0; i < lineCount; ++i) { add_line(&lines[2*i], toSrc, this->coverage(), &verts); } @@ -1004,10 +1002,11 @@ void AAHairlineOp::onPrepareDraws(Target* target) { sk_sp<const GrBuffer> quadsIndexBuffer = get_quads_index_buffer(target->resourceProvider()); - size_t vertexStride = sizeof(BezierVertex); + SkASSERT(sizeof(BezierVertex) == quadGP->debugOnly_vertexStride()); + SkASSERT(sizeof(BezierVertex) == conicGP->debugOnly_vertexStride()); int vertexCount = kQuadNumVertices * quadAndConicCount; - void *vertices = target->makeVertexSpace(vertexStride, vertexCount, - &vertexBuffer, &firstVertex); + void* vertices = target->makeVertexSpace(sizeof(BezierVertex), vertexCount, &vertexBuffer, + &firstVertex); if (!vertices || !quadsIndexBuffer) { SkDebugf("Could not allocate vertices\n"); diff --git a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp index 5659099c84..b6b70779ff 100644 --- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp +++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp @@ -249,12 +249,10 @@ private: return; } - size_t vertexStride = gp->getVertexStride(); - - SkASSERT(fHelper.compatibleWithAlphaAsCoverage() - ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) - : vertexStride == - sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr)); + size_t vertexStride = fHelper.compatibleWithAlphaAsCoverage() + ? sizeof(GrDefaultGeoProcFactory::PositionColorAttr) + : sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); int instanceCount = fPaths.count(); diff --git a/src/gpu/ops/GrAAStrokeRectOp.cpp b/src/gpu/ops/GrAAStrokeRectOp.cpp index b9a6d88021..3347227f04 100644 --- a/src/gpu/ops/GrAAStrokeRectOp.cpp +++ b/src/gpu/ops/GrAAStrokeRectOp.cpp @@ -268,11 +268,11 @@ void AAStrokeRectOp::onPrepareDraws(Target* target) { return; } - size_t vertexStride = gp->getVertexStride(); + size_t vertexStride = fHelper.compatibleWithAlphaAsCoverage() + ? sizeof(GrDefaultGeoProcFactory::PositionColorAttr) + : sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr); - SkASSERT(fHelper.compatibleWithAlphaAsCoverage() - ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr) - : vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr)); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); int innerVertexNum = 4; int outerVertexNum = this->miterStroke() ? 4 : 8; int verticesPerInstance = (outerVertexNum + innerVertexNum) * 2; diff --git a/src/gpu/ops/GrAtlasTextOp.cpp b/src/gpu/ops/GrAtlasTextOp.cpp index 1ea3ddfae6..fc5e5804eb 100644 --- a/src/gpu/ops/GrAtlasTextOp.cpp +++ b/src/gpu/ops/GrAtlasTextOp.cpp @@ -312,8 +312,8 @@ void GrAtlasTextOp::onPrepareDraws(Target* target) { } flushInfo.fGlyphsToFlush = 0; - size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride(); - SkASSERT(vertexStride == GrTextBlob::GetVertexStride(maskFormat, vmPerspective)); + size_t vertexStride = GrTextBlob::GetVertexStride(maskFormat, vmPerspective); + SkASSERT(vertexStride == flushInfo.fGeometryProcessor->debugOnly_vertexStride()); int glyphCount = this->numGlyphs(); const GrBuffer* vertexBuffer; diff --git a/src/gpu/ops/GrDashOp.cpp b/src/gpu/ops/GrDashOp.cpp index cafb3e54c9..968d169376 100644 --- a/src/gpu/ops/GrDashOp.cpp +++ b/src/gpu/ops/GrDashOp.cpp @@ -626,7 +626,15 @@ private: } QuadHelper helper; - void* vertices = helper.init(target, gp->getVertexStride(), totalRectCount); + size_t vertexStride; + if (fullDash) { + vertexStride = + SkPaint::kRound_Cap == fCap ? sizeof(DashCircleVertex) : sizeof(DashLineVertex); + } else { + vertexStride = sizeof(SkPoint); + } + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); + void* vertices = helper.init(target, vertexStride, totalRectCount); if (!vertices) { return; } @@ -638,15 +646,13 @@ private: if (!draws[i].fLineDone) { if (fullDash) { - setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, - draws[i].fStartOffset, draws[i].fDevBloatX, - draws[i].fDevBloatY, draws[i].fLineLength, - draws[i].fHalfDevStroke, draws[i].fIntervals[0], - draws[i].fIntervals[1], draws[i].fStrokeWidth, - capType, gp->getVertexStride()); + setup_dashed_rect( + rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, + draws[i].fStartOffset, draws[i].fDevBloatX, draws[i].fDevBloatY, + draws[i].fLineLength, draws[i].fHalfDevStroke, draws[i].fIntervals[0], + draws[i].fIntervals[1], draws[i].fStrokeWidth, capType, vertexStride); } else { SkPoint* verts = reinterpret_cast<SkPoint*>(vertices); - SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts); } curVIdx += 4; @@ -655,15 +661,13 @@ private: if (draws[i].fHasStartRect) { if (fullDash) { - setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, - draws[i].fStartOffset, draws[i].fDevBloatX, - draws[i].fDevBloatY, draws[i].fIntervals[0], - draws[i].fHalfDevStroke, draws[i].fIntervals[0], - draws[i].fIntervals[1], draws[i].fStrokeWidth, capType, - gp->getVertexStride()); + setup_dashed_rect( + rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, + draws[i].fStartOffset, draws[i].fDevBloatX, draws[i].fDevBloatY, + draws[i].fIntervals[0], draws[i].fHalfDevStroke, draws[i].fIntervals[0], + draws[i].fIntervals[1], draws[i].fStrokeWidth, capType, vertexStride); } else { SkPoint* verts = reinterpret_cast<SkPoint*>(vertices); - SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts); } curVIdx += 4; @@ -672,15 +676,13 @@ private: if (draws[i].fHasEndRect) { if (fullDash) { - setup_dashed_rect(rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, - draws[i].fStartOffset, draws[i].fDevBloatX, - draws[i].fDevBloatY, draws[i].fIntervals[0], - draws[i].fHalfDevStroke, draws[i].fIntervals[0], - draws[i].fIntervals[1], draws[i].fStrokeWidth, capType, - gp->getVertexStride()); + setup_dashed_rect( + rects[rectIndex], vertices, curVIdx, geom.fSrcRotInv, + draws[i].fStartOffset, draws[i].fDevBloatX, draws[i].fDevBloatY, + draws[i].fIntervals[0], draws[i].fHalfDevStroke, draws[i].fIntervals[0], + draws[i].fIntervals[1], draws[i].fStrokeWidth, capType, vertexStride); } else { SkPoint* verts = reinterpret_cast<SkPoint*>(vertices); - SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); setup_dashed_rect_pos(rects[rectIndex], curVIdx, geom.fSrcRotInv, verts); } curVIdx += 4; @@ -840,12 +842,6 @@ public: const char* name() const override { return "DashingCircleEffect"; } - const Attribute* inPosition() const { return fInPosition; } - - const Attribute* inDashParams() const { return fInDashParams; } - - const Attribute* inCircleParams() const { return fInCircleParams; } - AAMode aaMode() const { return fAAMode; } GrColor color() const { return fColor; } @@ -862,18 +858,27 @@ private: DashingCircleEffect(GrColor, AAMode aaMode, const SkMatrix& localMatrix, bool usesLocalCoords); + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInDashParams, kInCircleParams); + } + GrColor fColor; SkMatrix fLocalMatrix; bool fUsesLocalCoords; AAMode fAAMode; - const Attribute* fInPosition; - const Attribute* fInDashParams; - const Attribute* fInCircleParams; + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInDashParams = {"inDashParams", kHalf3_GrVertexAttribType}; + static constexpr Attribute kInCircleParams = {"inCircleParams", kHalf2_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST + friend class GLDashingCircleEffect; typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute DashingCircleEffect::kInPosition; +constexpr GrPrimitiveProcessor::Attribute DashingCircleEffect::kInDashParams; +constexpr GrPrimitiveProcessor::Attribute DashingCircleEffect::kInCircleParams; ////////////////////////////////////////////////////////////////////////////// @@ -918,25 +923,25 @@ void GLDashingCircleEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { // XY are dashPos, Z is dashInterval GrGLSLVarying dashParams(kHalf3_GrSLType); varyingHandler->addVarying("DashParam", &dashParams); - vertBuilder->codeAppendf("%s = %s;", dashParams.vsOut(), dce.inDashParams()->name()); + vertBuilder->codeAppendf("%s = %s;", dashParams.vsOut(), dce.kInDashParams.name()); // x refers to circle radius - 0.5, y refers to cicle's center x coord GrGLSLVarying circleParams(kHalf2_GrSLType); varyingHandler->addVarying("CircleParams", &circleParams); - vertBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.inCircleParams()->name()); + vertBuilder->codeAppendf("%s = %s;", circleParams.vsOut(), dce.kInCircleParams.name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // Setup pass through color this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, dce.inPosition()->name()); + this->writeOutputPosition(vertBuilder, gpArgs, dce.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - dce.inPosition()->asShaderVar(), + dce.kInPosition.asShaderVar(), dce.localMatrix(), args.fFPCoordTransformHandler); @@ -1009,9 +1014,7 @@ DashingCircleEffect::DashingCircleEffect(GrColor color, , fLocalMatrix(localMatrix) , fUsesLocalCoords(usesLocalCoords) , fAAMode(aaMode) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInDashParams = &this->addVertexAttrib("inDashParams", kHalf3_GrVertexAttribType); - fInCircleParams = &this->addVertexAttrib("inCircleParams", kHalf2_GrVertexAttribType); + this->setVertexAttributeCnt(3); } GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingCircleEffect); @@ -1049,12 +1052,6 @@ public: const char* name() const override { return "DashingEffect"; } - const Attribute* inPosition() const { return fInPosition; } - - const Attribute* inDashParams() const { return fInDashParams; } - - const Attribute* inRectParams() const { return fInRectParams; } - AAMode aaMode() const { return fAAMode; } GrColor color() const { return fColor; } @@ -1071,18 +1068,28 @@ private: DashingLineEffect(GrColor, AAMode aaMode, const SkMatrix& localMatrix, bool usesLocalCoords); + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInDashParams, kInRectParams); + } + GrColor fColor; SkMatrix fLocalMatrix; bool fUsesLocalCoords; AAMode fAAMode; - const Attribute* fInPosition; - const Attribute* fInDashParams; - const Attribute* fInRectParams; + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInDashParams = {"inDashParams", kHalf3_GrVertexAttribType}; + static constexpr Attribute kInRectParams = {"inRect", kHalf4_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST + friend class GLDashingLineEffect; + typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute DashingLineEffect::kInPosition; +constexpr GrPrimitiveProcessor::Attribute DashingLineEffect::kInDashParams; +constexpr GrPrimitiveProcessor::Attribute DashingLineEffect::kInRectParams; ////////////////////////////////////////////////////////////////////////////// @@ -1120,26 +1127,26 @@ void GLDashingLineEffect::onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) { // XY refers to dashPos, Z is the dash interval length GrGLSLVarying inDashParams(kFloat3_GrSLType); varyingHandler->addVarying("DashParams", &inDashParams); - vertBuilder->codeAppendf("%s = %s;", inDashParams.vsOut(), de.inDashParams()->name()); + vertBuilder->codeAppendf("%s = %s;", inDashParams.vsOut(), de.kInDashParams.name()); // The rect uniform's xyzw refer to (left + 0.5, top + 0.5, right - 0.5, bottom - 0.5), // respectively. GrGLSLVarying inRectParams(kFloat4_GrSLType); varyingHandler->addVarying("RectParams", &inRectParams); - vertBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.inRectParams()->name()); + vertBuilder->codeAppendf("%s = %s;", inRectParams.vsOut(), de.kInRectParams.name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // Setup pass through color this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor, &fColorUniform); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, de.inPosition()->name()); + this->writeOutputPosition(vertBuilder, gpArgs, de.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - de.inPosition()->asShaderVar(), + de.kInPosition.asShaderVar(), de.localMatrix(), args.fFPCoordTransformHandler); @@ -1230,9 +1237,7 @@ DashingLineEffect::DashingLineEffect(GrColor color, , fLocalMatrix(localMatrix) , fUsesLocalCoords(usesLocalCoords) , fAAMode(aaMode) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInDashParams = &this->addVertexAttrib("inDashParams", kHalf3_GrVertexAttribType); - fInRectParams = &this->addVertexAttrib("inRect", kHalf4_GrVertexAttribType); + this->setVertexAttributeCnt(3); } GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DashingLineEffect); @@ -1244,8 +1249,8 @@ sk_sp<GrGeometryProcessor> DashingLineEffect::TestCreate(GrProcessorTestData* d) aaMode, GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool()); } -#endif +#endif ////////////////////////////////////////////////////////////////////////////// static sk_sp<GrGeometryProcessor> make_dash_gp(GrColor color, diff --git a/src/gpu/ops/GrDefaultPathRenderer.cpp b/src/gpu/ops/GrDefaultPathRenderer.cpp index df6f81f552..aa0963b02a 100644 --- a/src/gpu/ops/GrDefaultPathRenderer.cpp +++ b/src/gpu/ops/GrDefaultPathRenderer.cpp @@ -404,7 +404,7 @@ private: gp = GrDefaultGeoProcFactory::Make(color, coverage, localCoords, this->viewMatrix()); } - SkASSERT(gp->getVertexStride() == sizeof(SkPoint)); + SkASSERT(gp->debugOnly_vertexStride() == sizeof(SkPoint)); int instanceCount = fPaths.count(); diff --git a/src/gpu/ops/GrDrawAtlasOp.cpp b/src/gpu/ops/GrDrawAtlasOp.cpp index fa08e558f3..47bad8b2a4 100644 --- a/src/gpu/ops/GrDrawAtlasOp.cpp +++ b/src/gpu/ops/GrDrawAtlasOp.cpp @@ -122,9 +122,9 @@ void GrDrawAtlasOp::onPrepareDraws(Target* target) { sk_sp<GrGeometryProcessor> gp(make_gp(this->hasColors(), this->color(), this->viewMatrix())); int instanceCount = fGeoData.count(); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == - sizeof(SkPoint) + sizeof(SkPoint) + (this->hasColors() ? sizeof(GrColor) : 0)); + size_t vertexStride = + sizeof(SkPoint) + sizeof(SkPoint) + (this->hasColors() ? sizeof(GrColor) : 0); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); QuadHelper helper; int numQuads = this->quadCount(); diff --git a/src/gpu/ops/GrDrawVerticesOp.cpp b/src/gpu/ops/GrDrawVerticesOp.cpp index c968611152..8f6ad9745d 100644 --- a/src/gpu/ops/GrDrawVerticesOp.cpp +++ b/src/gpu/ops/GrDrawVerticesOp.cpp @@ -140,10 +140,10 @@ void GrDrawVerticesOp::onPrepareDraws(Target* target) { bool hasColorAttribute; bool hasLocalCoordsAttribute; sk_sp<GrGeometryProcessor> gp = this->makeGP(&hasColorAttribute, &hasLocalCoordsAttribute); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(SkPoint) + (hasColorAttribute ? sizeof(uint32_t) : 0) + - (hasLocalCoordsAttribute ? sizeof(SkPoint) : 0)); + size_t vertexStride = sizeof(SkPoint) + (hasColorAttribute ? sizeof(uint32_t) : 0) + + (hasLocalCoordsAttribute ? sizeof(SkPoint) : 0); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); int instanceCount = fMeshes.count(); diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp index 5903231cb2..7bfa72ec94 100644 --- a/src/gpu/ops/GrLatticeOp.cpp +++ b/src/gpu/ops/GrLatticeOp.cpp @@ -62,19 +62,19 @@ public: latticeGP.fColorSpaceXform.get()); args.fVaryingHandler->emitAttributes(latticeGP); - this->writeOutputPosition(args.fVertBuilder, gpArgs, latticeGP.fPositions.name()); + this->writeOutputPosition(args.fVertBuilder, gpArgs, latticeGP.kPositions.name()); this->emitTransforms(args.fVertBuilder, args.fVaryingHandler, args.fUniformHandler, - latticeGP.fTextureCoords.asShaderVar(), + latticeGP.kTextureCoords.asShaderVar(), args.fFPCoordTransformHandler); args.fFragBuilder->codeAppend("float2 textureCoords;"); - args.fVaryingHandler->addPassThroughAttribute(&latticeGP.fTextureCoords, + args.fVaryingHandler->addPassThroughAttribute(latticeGP.kTextureCoords, "textureCoords"); args.fFragBuilder->codeAppend("float4 textureDomain;"); args.fVaryingHandler->addPassThroughAttribute( - &latticeGP.fTextureDomain, "textureDomain", Interpolation::kCanBeFlat); - args.fVaryingHandler->addPassThroughAttribute(&latticeGP.fColors, args.fOutputColor, + latticeGP.kTextureDomain, "textureDomain", Interpolation::kCanBeFlat); + args.fVaryingHandler->addPassThroughAttribute(latticeGP.kColors, args.fOutputColor, Interpolation::kCanBeFlat); args.fFragBuilder->codeAppendf("%s = ", args.fOutputColor); args.fFragBuilder->appendTextureLookupAndModulate( @@ -95,24 +95,31 @@ private: LatticeGP(sk_sp<GrTextureProxy> proxy, sk_sp<GrColorSpaceXform> csxf, GrSamplerState::Filter filter) : INHERITED(kLatticeGP_ClassID), fColorSpaceXform(std::move(csxf)) { - fPositions = this->addVertexAttrib("position", kFloat2_GrVertexAttribType); fSampler.reset(std::move(proxy), filter); this->addTextureSampler(&fSampler); - fTextureCoords = this->addVertexAttrib("textureCoords", kFloat2_GrVertexAttribType); - fTextureDomain = this->addVertexAttrib("textureDomain", kFloat4_GrVertexAttribType); - fColors = this->addVertexAttrib("color", kUByte4_norm_GrVertexAttribType); + this->setVertexAttributeCnt(4); } - Attribute fPositions; - Attribute fTextureCoords; - Attribute fTextureDomain; - Attribute fColors; + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kPositions, kTextureCoords, kTextureDomain, kColors); + } + + static constexpr Attribute kPositions = {"position", kFloat2_GrVertexAttribType}; + static constexpr Attribute kTextureCoords = {"textureCoords", kFloat2_GrVertexAttribType}; + static constexpr Attribute kTextureDomain = {"textureDomain", kFloat4_GrVertexAttribType}; + static constexpr Attribute kColors = {"color", kUByte4_norm_GrVertexAttribType}; + sk_sp<GrColorSpaceXform> fColorSpaceXform; TextureSampler fSampler; typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute LatticeGP::kPositions; +constexpr GrPrimitiveProcessor::Attribute LatticeGP::kTextureCoords; +constexpr GrPrimitiveProcessor::Attribute LatticeGP::kTextureDomain; +constexpr GrPrimitiveProcessor::Attribute LatticeGP::kColors; + class NonAALatticeOp final : public GrMeshDrawOp { private: using Helper = GrSimpleMeshDrawOpHelper; @@ -200,7 +207,10 @@ private: return; } - size_t vertexStride = gp->getVertexStride(); + static constexpr size_t kVertexStide = + sizeof(SkPoint) + sizeof(SkPoint) + sizeof(SkRect) + sizeof(uint32_t); + SkASSERT(kVertexStide == gp->debugOnly_vertexStride()); + int patchCnt = fPatches.count(); int numRects = 0; for (int i = 0; i < patchCnt; i++) { @@ -213,7 +223,7 @@ private: sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); PatternHelper helper(GrPrimitiveType::kTriangles); - void* vertices = helper.init(target, vertexStride, indexBuffer.get(), kVertsPerRect, + void* vertices = helper.init(target, kVertexStide, indexBuffer.get(), kVertsPerRect, kIndicesPerRect, numRects); if (!vertices || !indexBuffer) { SkDebugf("Could not allocate vertices\n"); @@ -241,7 +251,7 @@ private: static const Sk4f kFlipMuls(1.f, -1.f, 1.f, -1.f); while (patch.fIter->next(&srcR, &dstR)) { auto vertices = reinterpret_cast<LatticeGP::Vertex*>(verts); - SkPointPriv::SetRectTriStrip(&vertices->fPosition, dstR, vertexStride); + SkPointPriv::SetRectTriStrip(&vertices->fPosition, dstR, kVertexStide); Sk4f coords(SkIntToScalar(srcR.fLeft), SkIntToScalar(srcR.fTop), SkIntToScalar(srcR.fRight), SkIntToScalar(srcR.fBottom)); Sk4f domain = coords + kDomainOffsets; @@ -252,7 +262,7 @@ private: domain = SkNx_shuffle<0, 3, 2, 1>(kFlipMuls * domain + kFlipOffsets); } SkPointPriv::SetRectTriStrip(&vertices->fTextureCoords, coords[0], coords[1], - coords[2], coords[3], vertexStride); + coords[2], coords[3], kVertexStide); for (int j = 0; j < kVertsPerRect; ++j) { vertices[j].fTextureDomain = {domain[0], domain[1], domain[2], domain[3]}; } @@ -260,13 +270,13 @@ private: for (int j = 0; j < kVertsPerRect; ++j) { vertices[j].fColor = patch.fColor; } - verts += kVertsPerRect * vertexStride; + verts += kVertsPerRect * kVertexStide; } // If we didn't handle it above, apply the matrix here. if (!isScaleTranslate) { SkPoint* positions = reinterpret_cast<SkPoint*>(patchVerts); - SkMatrixPriv::MapPointsWithStride(patch.fViewMatrix, positions, vertexStride, + SkMatrixPriv::MapPointsWithStride(patch.fViewMatrix, positions, kVertexStide, kVertsPerRect * patch.fIter->numRectsToDraw()); } } diff --git a/src/gpu/ops/GrNonAAFillRectOp.cpp b/src/gpu/ops/GrNonAAFillRectOp.cpp index 20bd599133..d4ebedc6e1 100644 --- a/src/gpu/ops/GrNonAAFillRectOp.cpp +++ b/src/gpu/ops/GrNonAAFillRectOp.cpp @@ -181,15 +181,16 @@ private: SkDebugf("Couldn't create GrGeometryProcessor\n"); return; } - SkASSERT(gp->getVertexStride() == - sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr)); - size_t vertexStride = gp->getVertexStride(); + static constexpr size_t kVertexStride = + sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr); + SkASSERT(kVertexStride == gp->debugOnly_vertexStride()); + int rectCount = fRects.count(); sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); PatternHelper helper(GrPrimitiveType::kTriangles); - void* vertices = helper.init(target, vertexStride, indexBuffer.get(), kVertsPerRect, + void* vertices = helper.init(target, kVertexStride, indexBuffer.get(), kVertsPerRect, kIndicesPerRect, rectCount); if (!vertices || !indexBuffer) { SkDebugf("Could not allocate vertices\n"); @@ -198,8 +199,8 @@ private: for (int i = 0; i < rectCount; i++) { intptr_t verts = - reinterpret_cast<intptr_t>(vertices) + i * kVertsPerRect * vertexStride; - tesselate(verts, vertexStride, fRects[i].fColor, &fRects[i].fViewMatrix, + reinterpret_cast<intptr_t>(vertices) + i * kVertsPerRect * kVertexStride; + tesselate(verts, kVertexStride, fRects[i].fColor, &fRects[i].fViewMatrix, fRects[i].fRect, &fRects[i].fLocalQuad); } helper.recordDraw(target, gp.get(), fHelper.makePipeline(target)); @@ -311,13 +312,11 @@ private: SkDebugf("Couldn't create GrGeometryProcessor\n"); return; } - SkASSERT(fHasLocalRect - ? gp->getVertexStride() == - sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) - : gp->getVertexStride() == - sizeof(GrDefaultGeoProcFactory::PositionColorAttr)); + size_t vertexStride = fHasLocalRect + ? sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) + : sizeof(GrDefaultGeoProcFactory::PositionColorAttr); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); - size_t vertexStride = gp->getVertexStride(); int rectCount = fRects.count(); sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); diff --git a/src/gpu/ops/GrNonAAStrokeRectOp.cpp b/src/gpu/ops/GrNonAAStrokeRectOp.cpp index 5e00e559e7..11c2f8cda5 100644 --- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp +++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp @@ -152,9 +152,9 @@ private: fViewMatrix); } - size_t vertexStride = gp->getVertexStride(); + static constexpr size_t kVertexStride = sizeof(GrDefaultGeoProcFactory::PositionAttr); - SkASSERT(vertexStride == sizeof(GrDefaultGeoProcFactory::PositionAttr)); + SkASSERT(kVertexStride == gp->debugOnly_vertexStride()); int vertexCount = kVertsPerHairlineRect; if (fStrokeWidth > 0) { @@ -165,7 +165,7 @@ private: int firstVertex; void* verts = - target->makeVertexSpace(vertexStride, vertexCount, &vertexBuffer, &firstVertex); + target->makeVertexSpace(kVertexStride, vertexCount, &vertexBuffer, &firstVertex); if (!verts) { SkDebugf("Could not allocate vertices\n"); diff --git a/src/gpu/ops/GrOvalOpFactory.cpp b/src/gpu/ops/GrOvalOpFactory.cpp index 7b0e4621e9..1655b76326 100644 --- a/src/gpu/ops/GrOvalOpFactory.cpp +++ b/src/gpu/ops/GrOvalOpFactory.cpp @@ -75,32 +75,26 @@ public: : INHERITED(kCircleGeometryProcessor_ClassID) , fLocalMatrix(localMatrix) , fStroke(stroke) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInCircleEdge = &this->addVertexAttrib("inCircleEdge", kFloat4_GrVertexAttribType); + int cnt = 3; if (clipPlane) { - fInClipPlane = &this->addVertexAttrib("inClipPlane", kHalf3_GrVertexAttribType); - } else { - fInClipPlane = nullptr; + fInClipPlane = {"inClipPlane", kHalf3_GrVertexAttribType}; + ++cnt; } if (isectPlane) { - fInIsectPlane = &this->addVertexAttrib("inIsectPlane", kHalf3_GrVertexAttribType); - } else { - fInIsectPlane = nullptr; + fInIsectPlane = {"inIsectPlane", kHalf3_GrVertexAttribType}; + ++cnt; } if (unionPlane) { - fInUnionPlane = &this->addVertexAttrib("inUnionPlane", kHalf3_GrVertexAttribType); - } else { - fInUnionPlane = nullptr; + fInUnionPlane = {"inUnionPlane", kHalf3_GrVertexAttribType}; + ++cnt; } if (roundCaps) { SkASSERT(stroke); SkASSERT(clipPlane); - fInRoundCapCenters = - &this->addVertexAttrib("inRoundCapCenters", kFloat4_GrVertexAttribType); - } else { - fInRoundCapCenters = nullptr; + fInRoundCapCenters = {"inRoundCapCenters", kFloat4_GrVertexAttribType}; + ++cnt; } + this->setVertexAttributeCnt(cnt); } ~CircleGeometryProcessor() override {} @@ -130,23 +124,22 @@ private: // emit attributes varyingHandler->emitAttributes(cgp); fragBuilder->codeAppend("float4 circleEdge;"); - varyingHandler->addPassThroughAttribute(cgp.fInCircleEdge, "circleEdge"); - if (cgp.fInClipPlane) { + varyingHandler->addPassThroughAttribute(cgp.kInCircleEdge, "circleEdge"); + if (cgp.fInClipPlane.isInitialized()) { fragBuilder->codeAppend("half3 clipPlane;"); varyingHandler->addPassThroughAttribute(cgp.fInClipPlane, "clipPlane"); } - if (cgp.fInIsectPlane) { - SkASSERT(cgp.fInClipPlane); + if (cgp.fInIsectPlane.isInitialized()) { fragBuilder->codeAppend("half3 isectPlane;"); varyingHandler->addPassThroughAttribute(cgp.fInIsectPlane, "isectPlane"); } - if (cgp.fInUnionPlane) { - SkASSERT(cgp.fInClipPlane); + if (cgp.fInUnionPlane.isInitialized()) { + SkASSERT(cgp.fInClipPlane.isInitialized()); fragBuilder->codeAppend("half3 unionPlane;"); varyingHandler->addPassThroughAttribute(cgp.fInUnionPlane, "unionPlane"); } GrGLSLVarying capRadius(kFloat_GrSLType); - if (cgp.fInRoundCapCenters) { + if (cgp.fInRoundCapCenters.isInitialized()) { fragBuilder->codeAppend("float4 roundCapCenters;"); varyingHandler->addPassThroughAttribute(cgp.fInRoundCapCenters, "roundCapCenters"); varyingHandler->addVarying("capRadius", &capRadius, @@ -154,20 +147,20 @@ private: // This is the cap radius in normalized space where the outer radius is 1 and // circledEdge.w is the normalized inner radius. vertBuilder->codeAppendf("%s = (1.0 - %s.w) / 2.0;", capRadius.vsOut(), - cgp.fInCircleEdge->name()); + cgp.kInCircleEdge.name()); } // setup pass through color - varyingHandler->addPassThroughAttribute(cgp.fInColor, args.fOutputColor); + varyingHandler->addPassThroughAttribute(cgp.kInColor, args.fOutputColor); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, cgp.fInPosition->name()); + this->writeOutputPosition(vertBuilder, gpArgs, cgp.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - cgp.fInPosition->asShaderVar(), + cgp.kInPosition.asShaderVar(), cgp.fLocalMatrix, args.fFPCoordTransformHandler); @@ -181,22 +174,22 @@ private: fragBuilder->codeAppend("edgeAlpha *= innerAlpha;"); } - if (cgp.fInClipPlane) { + if (cgp.fInClipPlane.isInitialized()) { fragBuilder->codeAppend( "half clip = clamp(circleEdge.z * dot(circleEdge.xy, clipPlane.xy) + " "clipPlane.z, 0.0, 1.0);"); - if (cgp.fInIsectPlane) { + if (cgp.fInIsectPlane.isInitialized()) { fragBuilder->codeAppend( "clip *= clamp(circleEdge.z * dot(circleEdge.xy, isectPlane.xy) + " "isectPlane.z, 0.0, 1.0);"); } - if (cgp.fInUnionPlane) { + if (cgp.fInUnionPlane.isInitialized()) { fragBuilder->codeAppend( "clip += (1.0 - clip)*clamp(circleEdge.z * dot(circleEdge.xy, " "unionPlane.xy) + unionPlane.z, 0.0, 1.0);"); } fragBuilder->codeAppend("edgeAlpha *= clip;"); - if (cgp.fInRoundCapCenters) { + if (cgp.fInRoundCapCenters.isInitialized()) { // We compute coverage of the round caps as circles at the butt caps produced // by the clip planes. The inverse of the clip planes is applied so that there // is no double counting. @@ -220,10 +213,10 @@ private: uint16_t key; key = cgp.fStroke ? 0x01 : 0x0; key |= cgp.fLocalMatrix.hasPerspective() ? 0x02 : 0x0; - key |= cgp.fInClipPlane ? 0x04 : 0x0; - key |= cgp.fInIsectPlane ? 0x08 : 0x0; - key |= cgp.fInUnionPlane ? 0x10 : 0x0; - key |= cgp.fInRoundCapCenters ? 0x20 : 0x0; + key |= cgp.fInClipPlane.isInitialized() ? 0x04 : 0x0; + key |= cgp.fInIsectPlane.isInitialized() ? 0x08 : 0x0; + key |= cgp.fInUnionPlane.isInitialized() ? 0x10 : 0x0; + key |= cgp.fInRoundCapCenters.isInitialized() ? 0x20 : 0x0; b->add32(key); } @@ -237,19 +230,31 @@ private: typedef GrGLSLGeometryProcessor INHERITED; }; + const Attribute& onVertexAttribute(int i) const override { + return IthInitializedAttribute(i, kInPosition, kInColor, kInCircleEdge, fInClipPlane, + fInIsectPlane, fInUnionPlane, fInRoundCapCenters); + } + SkMatrix fLocalMatrix; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInCircleEdge; - const Attribute* fInClipPlane; - const Attribute* fInIsectPlane; - const Attribute* fInUnionPlane; - const Attribute* fInRoundCapCenters; + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInCircleEdge = {"inCircleEdge", kFloat4_GrVertexAttribType}; + + // Optional attributes. + Attribute fInClipPlane; + Attribute fInIsectPlane; + Attribute fInUnionPlane; + Attribute fInRoundCapCenters; + bool fStroke; GR_DECLARE_GEOMETRY_PROCESSOR_TEST typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute CircleGeometryProcessor::kInPosition; +constexpr GrPrimitiveProcessor::Attribute CircleGeometryProcessor::kInColor; +constexpr GrPrimitiveProcessor::Attribute CircleGeometryProcessor::kInCircleEdge; GR_DEFINE_GEOMETRY_PROCESSOR_TEST(CircleGeometryProcessor); @@ -270,10 +275,7 @@ class ButtCapDashedCircleGeometryProcessor : public GrGeometryProcessor { public: ButtCapDashedCircleGeometryProcessor(const SkMatrix& localMatrix) : INHERITED(kButtCapStrokedCircleGeometryProcessor_ClassID), fLocalMatrix(localMatrix) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInCircleEdge = &this->addVertexAttrib("inCircleEdge", kFloat4_GrVertexAttribType); - fInDashParams = &this->addVertexAttrib("inDashParams", kFloat4_GrVertexAttribType); + this->setVertexAttributeCnt(4); } ~ButtCapDashedCircleGeometryProcessor() override {} @@ -304,11 +306,11 @@ private: // emit attributes varyingHandler->emitAttributes(bcscgp); fragBuilder->codeAppend("float4 circleEdge;"); - varyingHandler->addPassThroughAttribute(bcscgp.fInCircleEdge, "circleEdge"); + varyingHandler->addPassThroughAttribute(bcscgp.kInCircleEdge, "circleEdge"); fragBuilder->codeAppend("float4 dashParams;"); varyingHandler->addPassThroughAttribute( - bcscgp.fInDashParams, "dashParams", + bcscgp.kInDashParams, "dashParams", GrGLSLVaryingHandler::Interpolation::kCanBeFlat); GrGLSLVarying wrapDashes(kHalf4_GrSLType); varyingHandler->addVarying("wrapDashes", &wrapDashes, @@ -316,7 +318,7 @@ private: GrGLSLVarying lastIntervalLength(kHalf_GrSLType); varyingHandler->addVarying("lastIntervalLength", &lastIntervalLength, GrGLSLVaryingHandler::Interpolation::kCanBeFlat); - vertBuilder->codeAppendf("float4 dashParams = %s;", bcscgp.fInDashParams->name()); + vertBuilder->codeAppendf("float4 dashParams = %s;", bcscgp.kInDashParams.name()); // Our fragment shader works in on/off intervals as specified by dashParams.xy: // x = length of on interval, y = length of on + off. // There are two other parameters in dashParams.zw: @@ -378,17 +380,17 @@ private: // setup pass through color varyingHandler->addPassThroughAttribute( - bcscgp.fInColor, args.fOutputColor, + bcscgp.kInColor, args.fOutputColor, GrGLSLVaryingHandler::Interpolation::kCanBeFlat); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, bcscgp.fInPosition->name()); + this->writeOutputPosition(vertBuilder, gpArgs, bcscgp.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - bcscgp.fInPosition->asShaderVar(), + bcscgp.kInPosition.asShaderVar(), bcscgp.fLocalMatrix, args.fFPCoordTransformHandler); GrShaderVar fnArgs[] = { @@ -482,16 +484,24 @@ private: typedef GrGLSLGeometryProcessor INHERITED; }; + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInColor, kInCircleEdge, kInDashParams); + } + SkMatrix fLocalMatrix; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInCircleEdge; - const Attribute* fInDashParams; + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInCircleEdge = {"inCircleEdge", kFloat4_GrVertexAttribType}; + static constexpr Attribute kInDashParams = {"inDashParams", kFloat4_GrVertexAttribType}; GR_DECLARE_GEOMETRY_PROCESSOR_TEST typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute ButtCapDashedCircleGeometryProcessor::kInPosition; +constexpr GrPrimitiveProcessor::Attribute ButtCapDashedCircleGeometryProcessor::kInColor; +constexpr GrPrimitiveProcessor::Attribute ButtCapDashedCircleGeometryProcessor::kInCircleEdge; +constexpr GrPrimitiveProcessor::Attribute ButtCapDashedCircleGeometryProcessor::kInDashParams; #if GR_TEST_UTILS sk_sp<GrGeometryProcessor> ButtCapDashedCircleGeometryProcessor::TestCreate(GrProcessorTestData* d) { @@ -515,10 +525,7 @@ public: EllipseGeometryProcessor(bool stroke, const SkMatrix& localMatrix) : INHERITED(kEllipseGeometryProcessor_ClassID) , fLocalMatrix(localMatrix) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInEllipseOffset = &this->addVertexAttrib("inEllipseOffset", kHalf2_GrVertexAttribType); - fInEllipseRadii = &this->addVertexAttrib("inEllipseRadii", kHalf4_GrVertexAttribType); + this->setVertexAttributeCnt(4); fStroke = stroke; } @@ -551,24 +558,24 @@ private: GrGLSLVarying ellipseOffsets(kHalf2_GrSLType); varyingHandler->addVarying("EllipseOffsets", &ellipseOffsets); vertBuilder->codeAppendf("%s = %s;", ellipseOffsets.vsOut(), - egp.fInEllipseOffset->name()); + egp.kInEllipseOffset.name()); GrGLSLVarying ellipseRadii(kHalf4_GrSLType); varyingHandler->addVarying("EllipseRadii", &ellipseRadii); - vertBuilder->codeAppendf("%s = %s;", ellipseRadii.vsOut(), egp.fInEllipseRadii->name()); + vertBuilder->codeAppendf("%s = %s;", ellipseRadii.vsOut(), egp.kInEllipseRadii.name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; // setup pass through color - varyingHandler->addPassThroughAttribute(egp.fInColor, args.fOutputColor); + varyingHandler->addPassThroughAttribute(egp.kInColor, args.fOutputColor); // Setup position - this->writeOutputPosition(vertBuilder, gpArgs, egp.fInPosition->name()); + this->writeOutputPosition(vertBuilder, gpArgs, egp.kInPosition.name()); // emit transforms this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - egp.fInPosition->asShaderVar(), + egp.kInPosition.asShaderVar(), egp.fLocalMatrix, args.fFPCoordTransformHandler); @@ -616,10 +623,15 @@ private: typedef GrGLSLGeometryProcessor INHERITED; }; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInEllipseOffset; - const Attribute* fInEllipseRadii; + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInColor, kInEllipseOffset, kInEllipseRadii); + } + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInEllipseOffset = {"inEllipseOffset", kHalf2_GrVertexAttribType}; + static constexpr Attribute kInEllipseRadii = {"inEllipseRadii", kHalf4_GrVertexAttribType}; + SkMatrix fLocalMatrix; bool fStroke; @@ -627,6 +639,10 @@ private: typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute EllipseGeometryProcessor::kInPosition; +constexpr GrPrimitiveProcessor::Attribute EllipseGeometryProcessor::kInColor; +constexpr GrPrimitiveProcessor::Attribute EllipseGeometryProcessor::kInEllipseOffset; +constexpr GrPrimitiveProcessor::Attribute EllipseGeometryProcessor::kInEllipseRadii; GR_DEFINE_GEOMETRY_PROCESSOR_TEST(EllipseGeometryProcessor); @@ -655,11 +671,8 @@ public: DIEllipseGeometryProcessor(const SkMatrix& viewMatrix, DIEllipseStyle style) : INHERITED(kDIEllipseGeometryProcessor_ClassID) , fViewMatrix(viewMatrix) { - fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType); - fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType); - fInEllipseOffsets0 = &this->addVertexAttrib("inEllipseOffsets0", kHalf2_GrVertexAttribType); - fInEllipseOffsets1 = &this->addVertexAttrib("inEllipseOffsets1", kHalf2_GrVertexAttribType); fStyle = style; + this->setVertexAttributeCnt(4); } ~DIEllipseGeometryProcessor() override {} @@ -690,22 +703,20 @@ private: GrGLSLVarying offsets0(kHalf2_GrSLType); varyingHandler->addVarying("EllipseOffsets0", &offsets0); - vertBuilder->codeAppendf("%s = %s;", offsets0.vsOut(), - diegp.fInEllipseOffsets0->name()); + vertBuilder->codeAppendf("%s = %s;", offsets0.vsOut(), diegp.kInEllipseOffsets0.name()); GrGLSLVarying offsets1(kHalf2_GrSLType); varyingHandler->addVarying("EllipseOffsets1", &offsets1); - vertBuilder->codeAppendf("%s = %s;", offsets1.vsOut(), - diegp.fInEllipseOffsets1->name()); + vertBuilder->codeAppendf("%s = %s;", offsets1.vsOut(), diegp.kInEllipseOffsets1.name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; - varyingHandler->addPassThroughAttribute(diegp.fInColor, args.fOutputColor); + varyingHandler->addPassThroughAttribute(diegp.kInColor, args.fOutputColor); // Setup position this->writeOutputPosition(vertBuilder, uniformHandler, gpArgs, - diegp.fInPosition->name(), + diegp.kInPosition.name(), diegp.fViewMatrix, &fViewMatrixUniform); @@ -713,7 +724,7 @@ private: this->emitTransforms(vertBuilder, varyingHandler, uniformHandler, - diegp.fInPosition->asShaderVar(), + diegp.kInPosition.asShaderVar(), args.fFPCoordTransformHandler); // for outer curve @@ -784,10 +795,17 @@ private: typedef GrGLSLGeometryProcessor INHERITED; }; - const Attribute* fInPosition; - const Attribute* fInColor; - const Attribute* fInEllipseOffsets0; - const Attribute* fInEllipseOffsets1; + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kInPosition, kInColor, kInEllipseOffsets0, kInEllipseOffsets1); + } + + static constexpr Attribute kInPosition = {"inPosition", kFloat2_GrVertexAttribType}; + static constexpr Attribute kInColor = {"inColor", kUByte4_norm_GrVertexAttribType}; + static constexpr Attribute kInEllipseOffsets0 = {"inEllipseOffsets0", + kHalf2_GrVertexAttribType}; + static constexpr Attribute kInEllipseOffsets1 = {"inEllipseOffsets1", + kHalf2_GrVertexAttribType}; + SkMatrix fViewMatrix; DIEllipseStyle fStyle; @@ -795,6 +813,10 @@ private: typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute DIEllipseGeometryProcessor::kInPosition; +constexpr GrPrimitiveProcessor::Attribute DIEllipseGeometryProcessor::kInColor; +constexpr GrPrimitiveProcessor::Attribute DIEllipseGeometryProcessor::kInEllipseOffsets0; +constexpr GrPrimitiveProcessor::Attribute DIEllipseGeometryProcessor::kInEllipseOffsets1; GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DIEllipseGeometryProcessor); @@ -1144,11 +1166,11 @@ private: auto vertexCapCenters = [numPlanes](CircleVertex* v) { return (void*)(v->fHalfPlanes + numPlanes); }; - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(CircleVertex) - (fClipPlane ? 0 : 3 * sizeof(SkScalar)) - - (fClipPlaneIsect ? 0 : 3 * sizeof(SkScalar)) - - (fClipPlaneUnion ? 0 : 3 * sizeof(SkScalar)) + - (fRoundCaps ? 2 * sizeof(SkPoint) : 0)); + size_t vertexStride = sizeof(CircleVertex) - (fClipPlane ? 0 : 3 * sizeof(SkScalar)) - + (fClipPlaneIsect ? 0 : 3 * sizeof(SkScalar)) - + (fClipPlaneUnion ? 0 : 3 * sizeof(SkScalar)) + + (fRoundCaps ? 2 * sizeof(SkPoint) : 0); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); const GrBuffer* vertexBuffer; int firstVertex; @@ -1632,12 +1654,12 @@ private: SkScalar fPhaseAngle; }; - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(CircleVertex)); + static constexpr size_t kVertexStride = sizeof(CircleVertex); + SkASSERT(kVertexStride == gp->debugOnly_vertexStride()); const GrBuffer* vertexBuffer; int firstVertex; - char* vertices = (char*)target->makeVertexSpace(vertexStride, fVertCount, &vertexBuffer, + char* vertices = (char*)target->makeVertexSpace(kVertexStride, fVertCount, &vertexBuffer, &firstVertex); if (!vertices) { SkDebugf("Could not allocate vertices\n"); @@ -1688,7 +1710,7 @@ private: SkPoint center = SkPoint::Make(bounds.centerX(), bounds.centerY()); SkScalar halfWidth = 0.5f * bounds.width(); auto init_outer_vertex = [&](int idx, SkScalar x, SkScalar y) { - CircleVertex* v = reinterpret_cast<CircleVertex*>(vertices + idx * vertexStride); + CircleVertex* v = reinterpret_cast<CircleVertex*>(vertices + idx * kVertexStride); v->fPos = center + SkPoint{x * halfWidth, y * halfWidth}; v->fOffset = {x, y}; init_const_attrs_and_reflect(v); @@ -1706,7 +1728,7 @@ private: // Compute the vertices of the inner octagon. auto init_inner_vertex = [&](int idx, SkScalar x, SkScalar y) { CircleVertex* v = - reinterpret_cast<CircleVertex*>(vertices + (idx + 8) * vertexStride); + reinterpret_cast<CircleVertex*>(vertices + (idx + 8) * kVertexStride); v->fPos = center + SkPoint{x * circle.fInnerRadius, y * circle.fInnerRadius}; v->fOffset = {x * normInnerRadius, y * normInnerRadius}; init_const_attrs_and_reflect(v); @@ -1732,7 +1754,7 @@ private: } currStartVertex += circle_type_to_vert_count(true); - vertices += circle_type_to_vert_count(true) * vertexStride; + vertices += circle_type_to_vert_count(true) * kVertexStride; } GrMesh mesh(GrPrimitiveType::kTriangles); @@ -1934,10 +1956,9 @@ private: sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, localMatrix)); QuadHelper helper; - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(EllipseVertex)); + SkASSERT(sizeof(EllipseVertex) == gp->debugOnly_vertexStride()); EllipseVertex* verts = reinterpret_cast<EllipseVertex*>( - helper.init(target, vertexStride, fEllipses.count())); + helper.init(target, sizeof(EllipseVertex), fEllipses.count())); if (!verts) { return; } @@ -2163,11 +2184,10 @@ private: sk_sp<GrGeometryProcessor> gp( new DIEllipseGeometryProcessor(this->viewMatrix(), this->style())); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(DIEllipseVertex)); + SkASSERT(sizeof(DIEllipseVertex) == gp->debugOnly_vertexStride()); QuadHelper helper; DIEllipseVertex* verts = reinterpret_cast<DIEllipseVertex*>( - helper.init(target, vertexStride, fEllipses.count())); + helper.init(target, sizeof(DIEllipseVertex), fEllipses.count())); if (!verts) { return; } @@ -2578,14 +2598,13 @@ private: sk_sp<GrGeometryProcessor> gp( new CircleGeometryProcessor(!fAllFill, false, false, false, false, localMatrix)); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(sizeof(CircleVertex) == vertexStride); + SkASSERT(sizeof(CircleVertex) == gp->debugOnly_vertexStride()); const GrBuffer* vertexBuffer; int firstVertex; - CircleVertex* verts = (CircleVertex*)target->makeVertexSpace(vertexStride, fVertCount, - &vertexBuffer, &firstVertex); + CircleVertex* verts = (CircleVertex*)target->makeVertexSpace( + sizeof(CircleVertex), fVertCount, &vertexBuffer, &firstVertex); if (!verts) { SkDebugf("Could not allocate vertices\n"); return; @@ -2867,8 +2886,7 @@ private: // Setup geometry processor sk_sp<GrGeometryProcessor> gp(new EllipseGeometryProcessor(fStroked, localMatrix)); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(vertexStride == sizeof(EllipseVertex)); + SkASSERT(sizeof(EllipseVertex) == gp->debugOnly_vertexStride()); // drop out the middle quad if we're stroked int indicesPerInstance = fStroked ? kIndicesPerStrokeRRect : kIndicesPerFillRRect; @@ -2877,8 +2895,8 @@ private: PatternHelper helper(GrPrimitiveType::kTriangles); EllipseVertex* verts = reinterpret_cast<EllipseVertex*>( - helper.init(target, vertexStride, indexBuffer.get(), kVertsPerStandardRRect, - indicesPerInstance, fRRects.count())); + helper.init(target, sizeof(EllipseVertex), indexBuffer.get(), + kVertsPerStandardRRect, indicesPerInstance, fRRects.count())); if (!verts || !indexBuffer) { SkDebugf("Could not allocate vertices\n"); return; diff --git a/src/gpu/ops/GrRegionOp.cpp b/src/gpu/ops/GrRegionOp.cpp index 9e81d66730..9a9814e0be 100644 --- a/src/gpu/ops/GrRegionOp.cpp +++ b/src/gpu/ops/GrRegionOp.cpp @@ -115,7 +115,8 @@ private: SkDebugf("Couldn't create GrGeometryProcessor\n"); return; } - SkASSERT(gp->getVertexStride() == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)); + static constexpr size_t kVertexStride = sizeof(GrDefaultGeoProcFactory::PositionColorAttr); + SkASSERT(kVertexStride == gp->debugOnly_vertexStride()); int numRegions = fRegions.count(); int numRects = 0; @@ -126,12 +127,10 @@ private: if (!numRects) { return; } - size_t vertexStride = gp->getVertexStride(); sk_sp<const GrBuffer> indexBuffer = target->resourceProvider()->refQuadIndexBuffer(); PatternHelper helper(GrPrimitiveType::kTriangles); - void* vertices = - helper.init(target, vertexStride, indexBuffer.get(), kVertsPerInstance, - kIndicesPerInstance, numRects); + void* vertices = helper.init(target, kVertexStride, indexBuffer.get(), kVertsPerInstance, + kIndicesPerInstance, numRects); if (!vertices || !indexBuffer) { SkDebugf("Could not allocate vertices\n"); return; @@ -139,9 +138,9 @@ private: intptr_t verts = reinterpret_cast<intptr_t>(vertices); for (int i = 0; i < numRegions; i++) { - tesselate_region(verts, vertexStride, fRegions[i].fColor, fRegions[i].fRegion); + tesselate_region(verts, kVertexStride, fRegions[i].fColor, fRegions[i].fRegion); int numRectsInRegion = fRegions[i].fRegion.computeRegionComplexity(); - verts += numRectsInRegion * kVertsPerInstance * vertexStride; + verts += numRectsInRegion * kVertsPerInstance * kVertexStride; } helper.recordDraw(target, gp.get(), fHelper.makePipeline(target)); } diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp index f61d11dd53..afb084dc36 100644 --- a/src/gpu/ops/GrShadowRRectOp.cpp +++ b/src/gpu/ops/GrShadowRRectOp.cpp @@ -576,13 +576,12 @@ private: sk_sp<GrGeometryProcessor> gp = GrRRectShadowGeoProc::Make(); int instanceCount = fGeoData.count(); - size_t vertexStride = gp->getVertexStride(); - SkASSERT(sizeof(CircleVertex) == vertexStride); + SkASSERT(sizeof(CircleVertex) == gp->debugOnly_vertexStride()); const GrBuffer* vertexBuffer; int firstVertex; - CircleVertex* verts = (CircleVertex*)target->makeVertexSpace(vertexStride, fVertCount, - &vertexBuffer, &firstVertex); + CircleVertex* verts = (CircleVertex*)target->makeVertexSpace( + sizeof(CircleVertex), fVertCount, &vertexBuffer, &firstVertex); if (!verts) { SkDebugf("Could not allocate vertices\n"); return; diff --git a/src/gpu/ops/GrSmallPathRenderer.cpp b/src/gpu/ops/GrSmallPathRenderer.cpp index 4ffe47855e..a0c9f9cf2b 100644 --- a/src/gpu/ops/GrSmallPathRenderer.cpp +++ b/src/gpu/ops/GrSmallPathRenderer.cpp @@ -351,8 +351,9 @@ private: } // allocate vertices - size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride(); - SkASSERT(vertexStride == sizeof(SkPoint) + sizeof(GrColor) + 2*sizeof(uint16_t)); + static constexpr size_t kVertexStride = + sizeof(SkPoint) + sizeof(GrColor) + 2 * sizeof(uint16_t); + SkASSERT(kVertexStride == flushInfo.fGeometryProcessor->debugOnly_vertexStride()); const GrBuffer* vertexBuffer; @@ -361,7 +362,7 @@ private: if (instanceCount > SK_MaxS32 / kVerticesPerQuad) { return; } - void* vertices = target->makeVertexSpace(vertexStride, + void* vertices = target->makeVertexSpace(kVertexStride, kVerticesPerQuad * instanceCount, &vertexBuffer, &flushInfo.fVertexOffset); @@ -476,13 +477,9 @@ private: auto uploadTarget = target->deferredUploadTarget(); fAtlas->setLastUseToken(shapeData->fID, uploadTarget->tokenTracker()->nextDrawToken()); - this->writePathVertices(fAtlas, - offset, - args.fColor, - vertexStride, - args.fViewMatrix, - shapeData); - offset += kVerticesPerQuad * vertexStride; + this->writePathVertices( + fAtlas, offset, args.fColor, kVertexStride, args.fViewMatrix, shapeData); + offset += kVerticesPerQuad * kVertexStride; flushInfo.fInstancesToFlush++; } diff --git a/src/gpu/ops/GrTessellatingPathRenderer.cpp b/src/gpu/ops/GrTessellatingPathRenderer.cpp index 51dac5adff..4c436c291d 100644 --- a/src/gpu/ops/GrTessellatingPathRenderer.cpp +++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp @@ -237,7 +237,7 @@ private: return path; } - void draw(Target* target, const GrGeometryProcessor* gp) { + void draw(Target* target, const GrGeometryProcessor* gp, size_t vertexStride) { SkASSERT(!fAntiAlias); GrResourceProvider* rp = target->resourceProvider(); bool inverseFill = fShape.inverseFilled(); @@ -274,7 +274,7 @@ private: vmi.mapRect(&clipBounds); bool isLinear; bool canMapVB = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags(); - StaticVertexAllocator allocator(gp->getVertexStride(), rp, canMapVB); + StaticVertexAllocator allocator(vertexStride, rp, canMapVB); int count = GrTessellator::PathToTriangles(getPath(), tol, clipBounds, &allocator, false, GrColor(), false, &isLinear); if (count == 0) { @@ -289,7 +289,7 @@ private: fShape.addGenIDChangeListener(sk_make_sp<PathInvalidator>(key)); } - void drawAA(Target* target, const GrGeometryProcessor* gp) { + void drawAA(Target* target, const GrGeometryProcessor* gp, size_t vertexStride) { SkASSERT(fAntiAlias); SkPath path = getPath(); if (path.isEmpty()) { @@ -299,7 +299,7 @@ private: path.transform(fViewMatrix); SkScalar tol = GrPathUtils::kDefaultTolerance; bool isLinear; - DynamicVertexAllocator allocator(gp->getVertexStride(), target); + DynamicVertexAllocator allocator(vertexStride, target); int count = GrTessellator::PathToTriangles(path, tol, clipBounds, &allocator, true, fColor, fHelper.compatibleWithAlphaAsCoverage(), &isLinear); @@ -311,9 +311,12 @@ private: void onPrepareDraws(Target* target) override { sk_sp<GrGeometryProcessor> gp; + size_t vertexStride; { using namespace GrDefaultGeoProcFactory; + vertexStride = sizeof(SkPoint); // position + Color color(fColor); LocalCoords::Type localCoordsType = fHelper.usesLocalCoords() ? LocalCoords::kUsePosition_Type @@ -321,10 +324,12 @@ private: Coverage::Type coverageType; if (fAntiAlias) { color = Color(Color::kPremulGrColorAttribute_Type); + vertexStride += sizeof(uint32_t); if (fHelper.compatibleWithAlphaAsCoverage()) { coverageType = Coverage::kSolid_Type; } else { coverageType = Coverage::kAttribute_Type; + vertexStride += 4; } } else { coverageType = Coverage::kSolid_Type; @@ -340,10 +345,11 @@ private: if (!gp.get()) { return; } + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); if (fAntiAlias) { - this->drawAA(target, gp.get()); + this->drawAA(target, gp.get(), vertexStride); } else { - this->draw(target, gp.get()); + this->draw(target, gp.get(), vertexStride); } } diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp index e06d94f806..a895230241 100644 --- a/src/gpu/ops/GrTextureOp.cpp +++ b/src/gpu/ops/GrTextureOp.cpp @@ -163,16 +163,14 @@ public: args.fUniformHandler, textureGP.fTextureCoords.asShaderVar(), args.fFPCoordTransformHandler); - args.fVaryingHandler->addPassThroughAttribute(&textureGP.fColors, - args.fOutputColor, - Interpolation::kCanBeFlat); + args.fVaryingHandler->addPassThroughAttribute( + textureGP.fColors, args.fOutputColor, Interpolation::kCanBeFlat); args.fFragBuilder->codeAppend("float2 texCoord;"); - args.fVaryingHandler->addPassThroughAttribute(&textureGP.fTextureCoords, - "texCoord"); + args.fVaryingHandler->addPassThroughAttribute(textureGP.fTextureCoords, "texCoord"); if (textureGP.fDomain.isInitialized()) { args.fFragBuilder->codeAppend("float4 domain;"); args.fVaryingHandler->addPassThroughAttribute( - &textureGP.fDomain, "domain", + textureGP.fDomain, "domain", GrGLSLVaryingHandler::Interpolation::kCanBeFlat); args.fFragBuilder->codeAppend( "texCoord = clamp(texCoord, domain.xy, domain.zw);"); @@ -182,7 +180,7 @@ public: SkASSERT(kInt_GrVertexAttribType == textureGP.fTextureIdx.type()); SkASSERT(args.fShaderCaps->integerSupport()); args.fFragBuilder->codeAppend("int texIdx;"); - args.fVaryingHandler->addPassThroughAttribute(&textureGP.fTextureIdx, "texIdx", + args.fVaryingHandler->addPassThroughAttribute(textureGP.fTextureIdx, "texIdx", Interpolation::kMustBeFlat); args.fFragBuilder->codeAppend("switch (texIdx) {"); for (int i = 0; i < textureGP.numTextureSamplers(); ++i) { @@ -316,12 +314,13 @@ private: } if (perspective) { - fPositions = this->addVertexAttrib("position", kFloat3_GrVertexAttribType); + fPositions = {"position", kFloat3_GrVertexAttribType}; } else { - fPositions = this->addVertexAttrib("position", kFloat2_GrVertexAttribType); + fPositions = {"position", kFloat2_GrVertexAttribType}; } - fColors = this->addVertexAttrib("color", kUByte4_norm_GrVertexAttribType); - fTextureCoords = this->addVertexAttrib("textureCoords", kFloat2_GrVertexAttribType); + fColors = {"color", kUByte4_norm_GrVertexAttribType}; + fTextureCoords = {"textureCoords", kFloat2_GrVertexAttribType}; + int vertexAttributeCnt = 3; if (samplerCnt > 1) { // Here we initialize any extra samplers by repeating the last one samplerCnt - proxyCnt @@ -332,17 +331,26 @@ private: this->addTextureSampler(&fSamplers[i]); } SkASSERT(caps.integerSupport()); - fTextureIdx = this->addVertexAttrib("textureIdx", kInt_GrVertexAttribType); + fTextureIdx = {"textureIdx", kInt_GrVertexAttribType}; + ++vertexAttributeCnt; } if (domain == Domain::kYes) { - fDomain = this->addVertexAttrib("domain", kFloat4_GrVertexAttribType); + fDomain = {"domain", kFloat4_GrVertexAttribType}; + ++vertexAttributeCnt; } if (coverageAA) { - fAAEdges[0] = this->addVertexAttrib("aaEdge0", kFloat3_GrVertexAttribType); - fAAEdges[1] = this->addVertexAttrib("aaEdge1", kFloat3_GrVertexAttribType); - fAAEdges[2] = this->addVertexAttrib("aaEdge2", kFloat3_GrVertexAttribType); - fAAEdges[3] = this->addVertexAttrib("aaEdge3", kFloat3_GrVertexAttribType); + fAAEdges[0] = {"aaEdge0", kFloat3_GrVertexAttribType}; + fAAEdges[1] = {"aaEdge1", kFloat3_GrVertexAttribType}; + fAAEdges[2] = {"aaEdge2", kFloat3_GrVertexAttribType}; + fAAEdges[3] = {"aaEdge3", kFloat3_GrVertexAttribType}; + vertexAttributeCnt += 4; } + this->setVertexAttributeCnt(vertexAttributeCnt); + } + + const Attribute& onVertexAttribute(int i) const override { + return IthInitializedAttribute(i, fPositions, fColors, fTextureCoords, fTextureIdx, fDomain, + fAAEdges[0], fAAEdges[1], fAAEdges[2], fAAEdges[3]); } Attribute fPositions; @@ -746,7 +754,7 @@ __attribute__((no_sanitize("float-cast-overflow"))) template <typename Pos, MultiTexture MT, Domain D, GrAA AA> void tess(void* v, const float iw[], const float ih[], const GrGeometryProcessor* gp) { using Vertex = TextureGeometryProcessor::Vertex<Pos, MT, D, AA>; - SkASSERT(gp->getVertexStride() == sizeof(Vertex)); + SkASSERT(gp->debugOnly_vertexStride() == sizeof(Vertex)); auto vertices = static_cast<Vertex*>(v); auto proxies = this->proxies(); auto filters = this->filters(); @@ -787,10 +795,47 @@ __attribute__((no_sanitize("float-cast-overflow"))) const GrPipeline* pipeline = target->allocPipeline(args, GrProcessorSet::MakeEmptySet(), target->detachAppliedClip()); + using TessFn = + decltype(&TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kNo>); +#define TESS_FN_AND_VERTEX_SIZE(Point, MT, Domain, AA) \ + { \ + &TextureOp::tess<Point, MT, Domain, AA>, \ + sizeof(TextureGeometryProcessor::Vertex<Point, MT, Domain, AA>) \ + } + static constexpr struct { + TessFn fTessFn; + size_t fVertexSize; + } kTessFnsAndVertexSizes[] = { + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kNo, Domain::kYes, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kNo, Domain::kYes, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kYes, Domain::kNo, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kYes, Domain::kNo, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kYes, Domain::kYes, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint, MultiTexture::kYes, Domain::kYes, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kNo, Domain::kNo, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kNo, Domain::kNo, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kNo, Domain::kYes, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kNo, Domain::kYes, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kYes, Domain::kNo, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kYes, Domain::kNo, GrAA::kYes), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kYes, Domain::kYes, GrAA::kNo), + TESS_FN_AND_VERTEX_SIZE(SkPoint3, MultiTexture::kYes, Domain::kYes, GrAA::kYes), + }; +#undef TESS_FN_AND_VERTEX_SIZE + int tessFnIdx = 0; + tessFnIdx |= coverageAA ? 0x1 : 0x0; + tessFnIdx |= fDomain ? 0x2 : 0x0; + tessFnIdx |= (fProxyCnt > 1) ? 0x4 : 0x0; + tessFnIdx |= fPerspective ? 0x8 : 0x0; + + SkASSERT(kTessFnsAndVertexSizes[tessFnIdx].fVertexSize == gp->debugOnly_vertexStride()); + int vstart; const GrBuffer* vbuffer; - void* vdata = target->makeVertexSpace(gp->getVertexStride(), 4 * fDraws.count(), &vbuffer, - &vstart); + void* vdata = target->makeVertexSpace(kTessFnsAndVertexSizes[tessFnIdx].fVertexSize, + 4 * fDraws.count(), &vbuffer, &vstart); if (!vdata) { SkDebugf("Could not allocate vertices\n"); return; @@ -804,32 +849,7 @@ __attribute__((no_sanitize("float-cast-overflow"))) ih[t] = 1.f / texture->height(); } - using TessFn = - decltype(&TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kNo>); - static constexpr TessFn kTessFns[] = { - &TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kNo>, - &TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kNo, GrAA::kYes>, - &TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kYes, GrAA::kNo>, - &TextureOp::tess<SkPoint, MultiTexture::kNo, Domain::kYes, GrAA::kYes>, - &TextureOp::tess<SkPoint, MultiTexture::kYes, Domain::kNo, GrAA::kNo>, - &TextureOp::tess<SkPoint, MultiTexture::kYes, Domain::kNo, GrAA::kYes>, - &TextureOp::tess<SkPoint, MultiTexture::kYes, Domain::kYes, GrAA::kNo>, - &TextureOp::tess<SkPoint, MultiTexture::kYes, Domain::kYes, GrAA::kYes>, - &TextureOp::tess<SkPoint3, MultiTexture::kNo, Domain::kNo, GrAA::kNo>, - &TextureOp::tess<SkPoint3, MultiTexture::kNo, Domain::kNo, GrAA::kYes>, - &TextureOp::tess<SkPoint3, MultiTexture::kNo, Domain::kYes, GrAA::kNo>, - &TextureOp::tess<SkPoint3, MultiTexture::kNo, Domain::kYes, GrAA::kYes>, - &TextureOp::tess<SkPoint3, MultiTexture::kYes, Domain::kNo, GrAA::kNo>, - &TextureOp::tess<SkPoint3, MultiTexture::kYes, Domain::kNo, GrAA::kYes>, - &TextureOp::tess<SkPoint3, MultiTexture::kYes, Domain::kYes, GrAA::kNo>, - &TextureOp::tess<SkPoint3, MultiTexture::kYes, Domain::kYes, GrAA::kYes>, - }; - int tessFnIdx = 0; - tessFnIdx |= coverageAA ? 0x1 : 0x0; - tessFnIdx |= fDomain ? 0x2 : 0x0; - tessFnIdx |= (fProxyCnt > 1) ? 0x4 : 0x0; - tessFnIdx |= fPerspective ? 0x8 : 0x0; - (this->*(kTessFns[tessFnIdx]))(vdata, iw, ih, gp.get()); + (this->*(kTessFnsAndVertexSizes[tessFnIdx].fTessFn))(vdata, iw, ih, gp.get()); GrPrimitiveType primitiveType = fDraws.count() > 1 ? GrPrimitiveType::kTriangles : GrPrimitiveType::kTriangleStrip; diff --git a/src/gpu/vk/GrVkPipeline.cpp b/src/gpu/vk/GrVkPipeline.cpp index 500ab967cc..c5b4592950 100644 --- a/src/gpu/vk/GrVkPipeline.cpp +++ b/src/gpu/vk/GrVkPipeline.cpp @@ -59,37 +59,58 @@ static void setup_vertex_input_state(const GrPrimitiveProcessor& primProc, VkVertexInputAttributeDescription* attributeDesc) { uint32_t vertexBinding = 0, instanceBinding = 0; - if (primProc.hasVertexAttribs()) { - vertexBinding = bindingDescs->count(); - bindingDescs->push_back() = { - vertexBinding, - (uint32_t) primProc.getVertexStride(), - VK_VERTEX_INPUT_RATE_VERTEX - }; + int nextBinding = bindingDescs->count(); + if (primProc.hasVertexAttributes()) { + vertexBinding = nextBinding++; } - if (primProc.hasInstanceAttribs()) { - instanceBinding = bindingDescs->count(); - bindingDescs->push_back() = { - instanceBinding, - (uint32_t) primProc.getInstanceStride(), - VK_VERTEX_INPUT_RATE_INSTANCE - }; + if (primProc.hasInstanceAttributes()) { + instanceBinding = nextBinding; } // setup attribute descriptions - int vaCount = primProc.numAttribs(); - if (vaCount > 0) { - for (int attribIndex = 0; attribIndex < vaCount; attribIndex++) { - using InputRate = GrPrimitiveProcessor::Attribute::InputRate; - const GrGeometryProcessor::Attribute& attrib = primProc.getAttrib(attribIndex); - VkVertexInputAttributeDescription& vkAttrib = attributeDesc[attribIndex]; - vkAttrib.location = attribIndex; // for now assume location = attribIndex - vkAttrib.binding = - InputRate::kPerInstance == attrib.inputRate() ? instanceBinding : vertexBinding; - vkAttrib.format = attrib_type_to_vkformat(attrib.type()); - vkAttrib.offset = attrib.offsetInRecord(); - } + int vaCount = primProc.numVertexAttributes(); + int attribIndex = 0; + size_t vertexAttributeOffset = 0; + for (; attribIndex < vaCount; attribIndex++) { + const GrGeometryProcessor::Attribute& attrib = primProc.vertexAttribute(attribIndex); + VkVertexInputAttributeDescription& vkAttrib = attributeDesc[attribIndex]; + vkAttrib.location = attribIndex; // for now assume location = attribIndex + vkAttrib.binding = vertexBinding; + vkAttrib.format = attrib_type_to_vkformat(attrib.type()); + vkAttrib.offset = vertexAttributeOffset; + SkASSERT(vkAttrib.offset == primProc.debugOnly_vertexAttributeOffset(attribIndex)); + vertexAttributeOffset += attrib.sizeAlign4(); + } + SkASSERT(vertexAttributeOffset == primProc.debugOnly_vertexStride()); + + int iaCount = primProc.numInstanceAttributes(); + size_t instanceAttributeOffset = 0; + for (int iaIndex = 0; iaIndex < iaCount; ++iaIndex, ++attribIndex) { + const GrGeometryProcessor::Attribute& attrib = primProc.instanceAttribute(iaIndex); + VkVertexInputAttributeDescription& vkAttrib = attributeDesc[attribIndex]; + vkAttrib.location = attribIndex; // for now assume location = attribIndex + vkAttrib.binding = instanceBinding; + vkAttrib.format = attrib_type_to_vkformat(attrib.type()); + vkAttrib.offset = instanceAttributeOffset; + SkASSERT(vkAttrib.offset == primProc.debugOnly_instanceAttributeOffset(iaIndex)); + instanceAttributeOffset += attrib.sizeAlign4(); + } + SkASSERT(instanceAttributeOffset == primProc.debugOnly_instanceStride()); + + if (primProc.hasVertexAttributes()) { + bindingDescs->push_back() = { + vertexBinding, + (uint32_t) vertexAttributeOffset, + VK_VERTEX_INPUT_RATE_VERTEX + }; + } + if (primProc.hasInstanceAttributes()) { + bindingDescs->push_back() = { + instanceBinding, + (uint32_t) instanceAttributeOffset, + VK_VERTEX_INPUT_RATE_INSTANCE + }; } memset(vertexInputInfo, 0, sizeof(VkPipelineVertexInputStateCreateInfo)); @@ -98,7 +119,7 @@ static void setup_vertex_input_state(const GrPrimitiveProcessor& primProc, vertexInputInfo->flags = 0; vertexInputInfo->vertexBindingDescriptionCount = bindingDescs->count(); vertexInputInfo->pVertexBindingDescriptions = bindingDescs->begin(); - vertexInputInfo->vertexAttributeDescriptionCount = vaCount; + vertexInputInfo->vertexAttributeDescriptionCount = vaCount + iaCount; vertexInputInfo->pVertexAttributeDescriptions = attributeDesc; } @@ -432,8 +453,9 @@ GrVkPipeline* GrVkPipeline::Create(GrVkGpu* gpu, const GrPipeline& pipeline, VkPipelineVertexInputStateCreateInfo vertexInputInfo; SkSTArray<2, VkVertexInputBindingDescription, true> bindingDescs; SkSTArray<16, VkVertexInputAttributeDescription> attributeDesc; - SkASSERT(primProc.numAttribs() <= gpu->vkCaps().maxVertexAttributes()); - VkVertexInputAttributeDescription* pAttribs = attributeDesc.push_back_n(primProc.numAttribs()); + int totalAttributeCnt = primProc.numVertexAttributes() + primProc.numInstanceAttributes(); + SkASSERT(totalAttributeCnt <= gpu->vkCaps().maxVertexAttributes()); + VkVertexInputAttributeDescription* pAttribs = attributeDesc.push_back_n(totalAttributeCnt); setup_vertex_input_state(primProc, &vertexInputInfo, &bindingDescs, pAttribs); VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo; diff --git a/tests/GrMeshTest.cpp b/tests/GrMeshTest.cpp index 4d9773b1a9..f95dbc8603 100644 --- a/tests/GrMeshTest.cpp +++ b/tests/GrMeshTest.cpp @@ -294,35 +294,46 @@ private: class GrMeshTestProcessor : public GrGeometryProcessor { public: GrMeshTestProcessor(bool instanced, bool hasVertexBuffer) - : INHERITED(kGrMeshTestProcessor_ClassID) - , fInstanceLocation(nullptr) - , fVertex(nullptr) - , fColor(nullptr) { + : INHERITED(kGrMeshTestProcessor_ClassID) { if (instanced) { - fInstanceLocation = &this->addInstanceAttrib("location", kHalf2_GrVertexAttribType); + fInstanceLocation = {"location", kHalf2_GrVertexAttribType}; + fColor = {"color", kUByte4_norm_GrVertexAttribType}; + this->setInstanceAttributeCnt(2); if (hasVertexBuffer) { - fVertex = &this->addVertexAttrib("vertex", kHalf2_GrVertexAttribType); + fVertex = {"vertex", kHalf2_GrVertexAttribType}; + this->setVertexAttributeCnt(1); } - fColor = &this->addInstanceAttrib("color", kUByte4_norm_GrVertexAttribType); } else { - fVertex = &this->addVertexAttrib("vertex", kHalf2_GrVertexAttribType); - fColor = &this->addVertexAttrib("color", kUByte4_norm_GrVertexAttribType); + fVertex = {"vertex", kHalf2_GrVertexAttribType}; + fColor = {"color", kUByte4_norm_GrVertexAttribType}; + this->setVertexAttributeCnt(2); } } const char* name() const override { return "GrMeshTest Processor"; } void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const final { - b->add32(SkToBool(fInstanceLocation)); - b->add32(SkToBool(fVertex)); + b->add32(fInstanceLocation.isInitialized()); + b->add32(fVertex.isInitialized()); } GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final; -protected: - const Attribute* fInstanceLocation; - const Attribute* fVertex; - const Attribute* fColor; +private: + const Attribute& onVertexAttribute(int i) const override { + if (fInstanceLocation.isInitialized()) { + return fVertex; + } + return IthAttribute(i, fVertex, fColor); + } + + const Attribute& onInstanceAttribute(int i) const override { + return IthAttribute(i, fInstanceLocation, fColor); + } + + Attribute fInstanceLocation; + Attribute fVertex; + Attribute fColor; friend class GLSLMeshTestProcessor; typedef GrGeometryProcessor INHERITED; @@ -340,15 +351,15 @@ class GLSLMeshTestProcessor : public GrGLSLGeometryProcessor { varyingHandler->addPassThroughAttribute(mp.fColor, args.fOutputColor); GrGLSLVertexBuilder* v = args.fVertBuilder; - if (!mp.fInstanceLocation) { - v->codeAppendf("float2 vertex = %s;", mp.fVertex->name()); + if (!mp.fInstanceLocation.isInitialized()) { + v->codeAppendf("float2 vertex = %s;", mp.fVertex.name()); } else { - if (mp.fVertex) { - v->codeAppendf("float2 offset = %s;", mp.fVertex->name()); + if (mp.fVertex.isInitialized()) { + v->codeAppendf("float2 offset = %s;", mp.fVertex.name()); } else { v->codeAppend ("float2 offset = float2(sk_VertexID / 2, sk_VertexID % 2);"); } - v->codeAppendf("float2 vertex = %s + offset * %i;", mp.fInstanceLocation->name(), + v->codeAppendf("float2 vertex = %s + offset * %i;", mp.fInstanceLocation.name(), kBoxSize); } gpArgs->fPositionVar.set(kFloat2_GrSLType, "vertex"); diff --git a/tests/GrPipelineDynamicStateTest.cpp b/tests/GrPipelineDynamicStateTest.cpp index a197650c4f..b5bc74d382 100644 --- a/tests/GrPipelineDynamicStateTest.cpp +++ b/tests/GrPipelineDynamicStateTest.cpp @@ -58,9 +58,9 @@ struct Vertex { class GrPipelineDynamicStateTestProcessor : public GrGeometryProcessor { public: GrPipelineDynamicStateTestProcessor() - : INHERITED(kGrPipelineDynamicStateTestProcessor_ClassID) - , fVertex(this->addVertexAttrib("vertex", kHalf2_GrVertexAttribType)) - , fColor(this->addVertexAttrib("color", kUByte4_norm_GrVertexAttribType)) {} + : INHERITED(kGrPipelineDynamicStateTestProcessor_ClassID) { + this->setVertexAttributeCnt(2); + } const char* name() const override { return "GrPipelineDynamicStateTest Processor"; } @@ -68,13 +68,19 @@ public: GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final; -protected: - const Attribute& fVertex; - const Attribute& fColor; +private: + const Attribute& onVertexAttribute(int i) const override { + return IthAttribute(i, kVertex, kColor); + } + + static constexpr Attribute kVertex = {"vertex", kHalf2_GrVertexAttribType}; + static constexpr Attribute kColor = {"color", kUByte4_norm_GrVertexAttribType}; friend class GLSLPipelineDynamicStateTestProcessor; typedef GrGeometryProcessor INHERITED; }; +constexpr GrPrimitiveProcessor::Attribute GrPipelineDynamicStateTestProcessor::kVertex; +constexpr GrPrimitiveProcessor::Attribute GrPipelineDynamicStateTestProcessor::kColor; class GLSLPipelineDynamicStateTestProcessor : public GrGLSLGeometryProcessor { void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor&, @@ -86,10 +92,10 @@ class GLSLPipelineDynamicStateTestProcessor : public GrGLSLGeometryProcessor { GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler; varyingHandler->emitAttributes(mp); - varyingHandler->addPassThroughAttribute(&mp.fColor, args.fOutputColor); + varyingHandler->addPassThroughAttribute(mp.kColor, args.fOutputColor); GrGLSLVertexBuilder* v = args.fVertBuilder; - v->codeAppendf("float2 vertex = %s;", mp.fVertex.name()); + v->codeAppendf("float2 vertex = %s;", mp.kVertex.name()); gpArgs->fPositionVar.set(kFloat2_GrSLType, "vertex"); GrGLSLFPFragmentBuilder* f = args.fFragBuilder; diff --git a/tests/OnFlushCallbackTest.cpp b/tests/OnFlushCallbackTest.cpp index e2f6fbf9e1..a8752057c8 100644 --- a/tests/OnFlushCallbackTest.cpp +++ b/tests/OnFlushCallbackTest.cpp @@ -110,11 +110,10 @@ private: return; } - size_t vertexStride = gp->getVertexStride(); - - SkASSERT(fHasLocalRect - ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) - : vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)); + size_t vertexStride = fHasLocalRect + ? sizeof(GrDefaultGeoProcFactory::PositionColorLocalCoordAttr) + : sizeof(GrDefaultGeoProcFactory::PositionColorAttr); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); const GrBuffer* indexBuffer; int firstIndex; diff --git a/tests/PrimitiveProcessorTest.cpp b/tests/PrimitiveProcessorTest.cpp index 74a73a66a9..60b2205cf7 100644 --- a/tests/PrimitiveProcessorTest.cpp +++ b/tests/PrimitiveProcessorTest.cpp @@ -59,15 +59,15 @@ private: void onPrepareDraws(Target* target) override { class GP : public GrGeometryProcessor { public: - GP(int numAttribs) - : INHERITED(kGP_ClassID) { + GP(int numAttribs) : INHERITED(kGP_ClassID), fNumAttribs(numAttribs) { SkASSERT(numAttribs > 1); + fAttribNames.reset(new SkString[numAttribs]); + fAttributes.reset(new Attribute[numAttribs]); for (auto i = 0; i < numAttribs; ++i) { - fAttribNames.push_back().printf("attr%d", i); - } - for (auto i = 0; i < numAttribs; ++i) { - this->addVertexAttrib(fAttribNames[i].c_str(), kFloat2_GrVertexAttribType); + fAttribNames[i].printf("attr%d", i); + fAttributes[i] = {fAttribNames[i].c_str(), kFloat2_GrVertexAttribType}; } + this->setVertexAttributeCnt(numAttribs); } const char* name() const override { return "Dummy GP"; } @@ -78,7 +78,7 @@ private: const GP& gp = args.fGP.cast<GP>(); args.fVaryingHandler->emitAttributes(gp); this->writeOutputPosition(args.fVertBuilder, gpArgs, - gp.getAttrib(0).name()); + gp.fAttributes[0].name()); GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder; fragBuilder->codeAppendf("%s = half4(1);", args.fOutputColor); fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage); @@ -91,17 +91,24 @@ private: } void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* builder) const override { - builder->add32(this->numAttribs()); + builder->add32(fNumAttribs); } private: - SkTArray<SkString> fAttribNames; + const GrPrimitiveProcessor::Attribute& onVertexAttribute(int i) const override { + return fAttributes[i]; + } + + int fNumAttribs; + std::unique_ptr<SkString[]> fAttribNames; + std::unique_ptr<Attribute[]> fAttributes; typedef GrGeometryProcessor INHERITED; }; sk_sp<GrGeometryProcessor> gp(new GP(fNumAttribs)); QuadHelper helper; - size_t vertexStride = gp->getVertexStride(); + size_t vertexStride = fNumAttribs * GrVertexAttribTypeSize(kFloat2_GrVertexAttribType); + SkASSERT(vertexStride == gp->debugOnly_vertexStride()); SkPoint* vertices = reinterpret_cast<SkPoint*>(helper.init(target, vertexStride, 1)); SkPointPriv::SetRectTriStrip(vertices, 0.f, 0.f, 1.f, 1.f, vertexStride); helper.recordDraw(target, gp.get(), |