Revert "Revert "Change how vertex/instance attributes are handled in geometry processors.""
This reverts commit 5045e501d2aec23e5f1e4b46346033ac3202c6b0.
TBR=csmartdalton@google.com
Change-Id: Ifbf5f1d8f8ef340fdc69653e931b6d68d4bf0854
Reviewed-on: https://skia-review.googlesource.com/135862
Reviewed-by: Brian Salomon <bsalomon@google.com>
Commit-Queue: Brian Salomon <bsalomon@google.com>
diff --git a/gm/beziereffects.cpp b/gm/beziereffects.cpp
index 1c26989..26da791 100644
--- a/gm/beziereffects.cpp
+++ b/gm/beziereffects.cpp
@@ -93,14 +93,13 @@
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 @@
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 @@
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 18c5ebd..496b6b1 100644
--- a/gm/convexpolyeffect.cpp
+++ b/gm/convexpolyeffect.cpp
@@ -83,10 +83,9 @@
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 5913a1e..e957f1f 100644
--- a/include/private/GrTypesPriv.h
+++ b/include/private/GrTypesPriv.h
@@ -694,51 +694,6 @@
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 defb214..e2bf87b 100644
--- a/src/gpu/GrDefaultGeoProcFactory.cpp
+++ b/src/gpu/GrDefaultGeoProcFactory.cpp
@@ -45,17 +45,13 @@
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 @@
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 @@
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 @@
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
- gp.inPosition()->asShaderVar(),
+ gp.fInPosition.asShaderVar(),
gp.localMatrix(),
args.fFPCoordTransformHandler);
}
@@ -132,7 +128,7 @@
// 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 @@
, 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 a12ab00..5035ad0 100644
--- a/src/gpu/GrGeometryProcessor.h
+++ b/src/gpu/GrGeometryProcessor.h
@@ -39,7 +39,44 @@
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 13ae6c9..fa2ce07 100644
--- a/src/gpu/GrGpuCommandBuffer.cpp
+++ b/src/gpu/GrGpuCommandBuffer.cpp
@@ -33,12 +33,12 @@
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 @@
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 72e5168..6893e88 100644
--- a/src/gpu/GrPathProcessor.h
+++ b/src/gpu/GrPathProcessor.h
@@ -38,6 +38,18 @@
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 7d1e1a6..db79fb1 100644
--- a/src/gpu/GrPrimitiveProcessor.cpp
+++ b/src/gpu/GrPrimitiveProcessor.cpp
@@ -17,6 +17,58 @@
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 c75f13c..6563ad9 100644
--- a/src/gpu/GrPrimitiveProcessor.h
+++ b/src/gpu/GrPrimitiveProcessor.h
@@ -40,23 +40,22 @@
*/
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;
- bool isInitialized() const { return SkToBool(fName); }
+ Attribute& operator=(const Attribute&) = default;
- const char* name() const { return fName; }
- GrVertexAttribType type() const { return fType; }
- int offsetInRecord() const { return fOffsetInRecord; }
- InputRate inputRate() const { return fInputRate; }
+ constexpr bool isInitialized() const { return SkToBool(fName); }
+
+ constexpr const char* name() const { return fName; }
+ constexpr GrVertexAttribType type() const { return fType; }
+
+ 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 @@
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 @@
*/
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 @@
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 e3ea34f..8989048 100644
--- a/src/gpu/ccpr/GrCCCoverageProcessor.h
+++ b/src/gpu/ccpr/GrCCCoverageProcessor.h
@@ -246,6 +246,13 @@
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 @@
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 @@
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 aa7a8db..8134fbe 100644
--- a/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp
+++ b/src/gpu/ccpr/GrCCCoverageProcessor_GSImpl.cpp
@@ -31,9 +31,8 @@
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 @@
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 @@
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 3c9fe89..5c5120c 100644
--- a/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp
+++ b/src/gpu/ccpr/GrCCCoverageProcessor_VSImpl.cpp
@@ -28,9 +28,8 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
}
}
+ 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 b8ebb44..e180724 100644
--- a/src/gpu/ccpr/GrCCPathProcessor.cpp
+++ b/src/gpu/ccpr/GrCCPathProcessor.cpp
@@ -65,6 +65,9 @@
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 @@
: 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);
+ 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));
- 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->setVertexAttributeCnt(1);
fAtlasAccess.instantiate(resourceProvider);
this->addTextureSampler(&fAtlasAccess);
@@ -170,7 +168,7 @@
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 785dd2c..54c1b7e 100644
--- a/src/gpu/ccpr/GrCCPathProcessor.h
+++ b/src/gpu/ccpr/GrCCPathProcessor.h
@@ -77,16 +77,11 @@
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;
+ int idx = static_cast<int>(attribID);
+ SkASSERT(idx >= 0 && idx < static_cast<int>(SK_ARRAY_COUNT(kInstanceAttribs)));
+ return kInstanceAttribs[idx];
}
- const Attribute& getEdgeNormsAttrib() const {
- SkASSERT(1 + kNumInstanceAttribs == this->numAttribs());
- const Attribute& attrib = this->getAttrib(kNumInstanceAttribs);
- SkASSERT(Attribute::InputRate::kPerVertex == attrib.inputRate());
- return attrib;
- }
+ const Attribute& getEdgeNormsAttrib() const { return kEdgeNormsAttrib; }
void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override;
@@ -95,8 +90,18 @@
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 3dee2f4..d68b1bf 100644
--- a/src/gpu/effects/GrBezierEffect.cpp
+++ b/src/gpu/effects/GrBezierEffect.cpp
@@ -79,7 +79,7 @@
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 @@
this->writeOutputPosition(vertBuilder,
uniformHandler,
gpArgs,
- gp.inPosition()->name(),
+ gp.inPosition().name(),
gp.viewMatrix(),
&fViewMatrixUniform);
@@ -97,7 +97,7 @@
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
- gp.inPosition()->asShaderVar(),
+ gp.inPosition().asShaderVar(),
gp.localMatrix(),
args.fFPCoordTransformHandler);
@@ -219,6 +219,8 @@
//////////////////////////////////////////////////////////////////////////////
+constexpr GrPrimitiveProcessor::Attribute GrConicEffect::kAttributes[];
+
GrConicEffect::~GrConicEffect() {}
void GrConicEffect::getGLSLProcessorKey(const GrShaderCaps& caps,
@@ -240,8 +242,7 @@
, 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 @@
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 @@
this->writeOutputPosition(vertBuilder,
uniformHandler,
gpArgs,
- gp.inPosition()->name(),
+ gp.inPosition().name(),
gp.viewMatrix(),
&fViewMatrixUniform);
@@ -349,7 +350,7 @@
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
- gp.inPosition()->asShaderVar(),
+ gp.inPosition().asShaderVar(),
gp.localMatrix(),
args.fFPCoordTransformHandler);
@@ -420,6 +421,8 @@
//////////////////////////////////////////////////////////////////////////////
+constexpr GrPrimitiveProcessor::Attribute GrQuadEffect::kAttributes[];
+
GrQuadEffect::~GrQuadEffect() {}
void GrQuadEffect::getGLSLProcessorKey(const GrShaderCaps& caps,
@@ -441,8 +444,7 @@
, 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 @@
this->writeOutputPosition(vertBuilder,
uniformHandler,
gpArgs,
- gp.inPosition()->name(),
+ gp.inPosition().name(),
gp.viewMatrix(),
&fViewMatrixUniform);
@@ -576,7 +578,7 @@
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
- gp.inPosition()->asShaderVar(),
+ gp.inPosition().asShaderVar(),
args.fFPCoordTransformHandler);
GrShaderVar edgeAlpha("edgeAlpha", kFloat_GrSLType, 0);
@@ -647,6 +649,8 @@
//////////////////////////////////////////////////////////////////////////////
+constexpr GrPrimitiveProcessor::Attribute GrCubicEffect::kInPosition;
+
GrCubicEffect::~GrCubicEffect() {}
void GrCubicEffect::getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const {
@@ -664,7 +668,7 @@
, 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 1744704..eebe42a 100644
--- a/src/gpu/effects/GrBezierEffect.h
+++ b/src/gpu/effects/GrBezierEffect.h
@@ -93,8 +93,8 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 4089555..2594f40 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.cpp
+++ b/src/gpu/effects/GrBitmapTextGeoProc.cpp
@@ -40,7 +40,7 @@
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 @@
}
// 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 @@
, 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 @@
}
}
+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 40ba855..5e44497 100644
--- a/src/gpu/effects/GrBitmapTextGeoProc.h
+++ b/src/gpu/effects/GrBitmapTextGeoProc.h
@@ -36,12 +36,12 @@
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 @@
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 5ac7398..4d5d50b 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.cpp
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.cpp
@@ -54,13 +54,13 @@
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 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
this->writeOutputPosition(vertBuilder,
uniformHandler,
gpArgs,
- dfPathEffect.inPosition()->name(),
+ dfPathEffect.inPosition().name(),
dfPathEffect.matrix(),
&fMatrixUniform);
@@ -356,17 +358,17 @@
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 @@
};
///////////////////////////////////////////////////////////////////////////////
-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 @@
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 @@
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 @@
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 @@
};
///////////////////////////////////////////////////////////////////////////////
-GrDistanceFieldLCDTextGeoProc::GrDistanceFieldLCDTextGeoProc(
- const sk_sp<GrTextureProxy>* proxies,
- int numProxies,
- const GrSamplerState& params,
- DistanceAdjust distanceAdjust,
- uint32_t flags,
- const SkMatrix& localMatrix)
- : INHERITED(kGrDistanceFieldLCDTextGeoProc_ClassID)
- , fDistanceAdjust(distanceAdjust)
- , fFlags(flags & kLCD_DistanceFieldEffectMask)
- , fLocalMatrix(localMatrix) {
- SkASSERT(numProxies <= kMaxTextures);
+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) {
+ 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 @@
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 5ba19ed..71626fa 100644
--- a/src/gpu/effects/GrDistanceFieldGeoProc.h
+++ b/src/gpu/effects/GrDistanceFieldGeoProc.h
@@ -76,9 +76,9 @@
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 @@
#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 @@
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 @@
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 @@
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 @@
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];
- DistanceAdjust fDistanceAdjust;
- uint32_t fFlags;
- const Attribute* fInPosition;
- const Attribute* fInColor;
- const Attribute* fInTextureCoords;
const SkMatrix fLocalMatrix;
+ DistanceAdjust fDistanceAdjust;
+ Attribute fInPosition;
+ uint32_t fFlags;
+
+ 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 52bf287..bf78f41 100644
--- a/src/gpu/effects/GrShadowGeoProc.cpp
+++ b/src/gpu/effects/GrShadowGeoProc.cpp
@@ -33,13 +33,13 @@
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 @@
///////////////////////////////////////////////////////////////////////////////
-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 @@
///////////////////////////////////////////////////////////////////////////////
+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 0b4baf4..df3e501 100644
--- a/src/gpu/effects/GrShadowGeoProc.h
+++ b/src/gpu/effects/GrShadowGeoProc.h
@@ -25,9 +25,9 @@
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 @@
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 88f5abe..be53222 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -1775,35 +1775,29 @@
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 262f0b2..3d4bd38 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -38,7 +38,8 @@
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 @@
, 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 6ea1f2c..ca4eddc 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 @@
*/
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 @@
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 @@
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 @@
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 eecc63e..e426d46 100644
--- a/src/gpu/gl/GrGLVaryingHandler.cpp
+++ b/src/gpu/gl/GrGLVaryingHandler.cpp
@@ -20,7 +20,8 @@
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 0cdc3b5..79e13d3 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -70,7 +70,8 @@
, fGpu(gpu)
, fVaryingHandler(this)
, fUniformHandler(this)
- , fAttributeCnt(0)
+ , fVertexAttributeCnt(0)
+ , fInstanceAttributeCnt(0)
, fVertexStride(0)
, fInstanceStride(0) {}
@@ -227,18 +228,30 @@
// 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 @@
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 ea3432b..30d5179 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -81,9 +81,10 @@
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 f8ec1c2..0563406 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::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 57704ad..0da88a0 100644
--- a/src/gpu/glsl/GrGLSLVarying.h
+++ b/src/gpu/glsl/GrGLSLVarying.h
@@ -104,7 +104,7 @@
* 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 3237afe..566eebd 100644
--- a/src/gpu/ops/GrAAConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAAConvexPathRenderer.cpp
@@ -576,21 +576,21 @@
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 @@
: 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 @@
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 @@
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 5472f11..76bc812 100644
--- a/src/gpu/ops/GrAAFillRectOp.cpp
+++ b/src/gpu/ops/GrAAFillRectOp.cpp
@@ -242,12 +242,19 @@
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 @@
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 b62c14b..89dedc4 100644
--- a/src/gpu/ops/GrAAHairLinePathRenderer.cpp
+++ b/src/gpu/ops/GrAAHairLinePathRenderer.cpp
@@ -959,18 +959,16 @@
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 @@
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 5659099..b6b7077 100644
--- a/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
+++ b/src/gpu/ops/GrAALinearizingConvexPathRenderer.cpp
@@ -249,12 +249,10 @@
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 b9a6d88..3347227 100644
--- a/src/gpu/ops/GrAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrAAStrokeRectOp.cpp
@@ -268,11 +268,11 @@
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 1ea3ddf..fc5e580 100644
--- a/src/gpu/ops/GrAtlasTextOp.cpp
+++ b/src/gpu/ops/GrAtlasTextOp.cpp
@@ -312,8 +312,8 @@
}
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 cafb3e5..968d169 100644
--- a/src/gpu/ops/GrDashOp.cpp
+++ b/src/gpu/ops/GrDashOp.cpp
@@ -626,7 +626,15 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
, 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 @@
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 @@
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 @@
// 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 @@
, 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 @@
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 df6f81f..aa0963b 100644
--- a/src/gpu/ops/GrDefaultPathRenderer.cpp
+++ b/src/gpu/ops/GrDefaultPathRenderer.cpp
@@ -404,7 +404,7 @@
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 fa08e55..47bad8b 100644
--- a/src/gpu/ops/GrDrawAtlasOp.cpp
+++ b/src/gpu/ops/GrDrawAtlasOp.cpp
@@ -122,9 +122,9 @@
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 c968611..8f6ad97 100644
--- a/src/gpu/ops/GrDrawVerticesOp.cpp
+++ b/src/gpu/ops/GrDrawVerticesOp.cpp
@@ -140,10 +140,10 @@
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 5903231..7bfa72e 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -62,19 +62,19 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 20bd599..d4ebedc 100644
--- a/src/gpu/ops/GrNonAAFillRectOp.cpp
+++ b/src/gpu/ops/GrNonAAFillRectOp.cpp
@@ -181,15 +181,16 @@
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 @@
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 @@
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 5e00e55..11c2f8c 100644
--- a/src/gpu/ops/GrNonAAStrokeRectOp.cpp
+++ b/src/gpu/ops/GrNonAAStrokeRectOp.cpp
@@ -152,9 +152,9 @@
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 @@
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 7b0e462..1655b76 100644
--- a/src/gpu/ops/GrOvalOpFactory.cpp
+++ b/src/gpu/ops/GrOvalOpFactory.cpp
@@ -75,32 +75,26 @@
: 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 @@
// 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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 @@
// 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
this->emitTransforms(vertBuilder,
varyingHandler,
uniformHandler,
- diegp.fInPosition->asShaderVar(),
+ diegp.kInPosition.asShaderVar(),
args.fFPCoordTransformHandler);
// for outer curve
@@ -784,10 +795,17 @@
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 @@
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 @@
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 @@
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 @@
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 @@
// 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 @@
}
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 @@
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 @@
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 @@
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 @@
// 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 @@
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 9e81d66..9a9814e 100644
--- a/src/gpu/ops/GrRegionOp.cpp
+++ b/src/gpu/ops/GrRegionOp.cpp
@@ -115,7 +115,8 @@
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 @@
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 @@
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 f61d11d..afb084d 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -576,13 +576,12 @@
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 4ffe478..a0c9f9c 100644
--- a/src/gpu/ops/GrSmallPathRenderer.cpp
+++ b/src/gpu/ops/GrSmallPathRenderer.cpp
@@ -351,8 +351,9 @@
}
// 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 @@
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 @@
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 51dac5a..4c436c2 100644
--- a/src/gpu/ops/GrTessellatingPathRenderer.cpp
+++ b/src/gpu/ops/GrTessellatingPathRenderer.cpp
@@ -237,7 +237,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 e06d94f..a895230 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -163,16 +163,14 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 500ab96..c5b4592 100644
--- a/src/gpu/vk/GrVkPipeline.cpp
+++ b/src/gpu/vk/GrVkPipeline.cpp
@@ -59,37 +59,58 @@
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 @@
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 @@
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 4d9773b..f95dbc8 100644
--- a/tests/GrMeshTest.cpp
+++ b/tests/GrMeshTest.cpp
@@ -294,35 +294,46 @@
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 @@
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 a197650..b5bc74d 100644
--- a/tests/GrPipelineDynamicStateTest.cpp
+++ b/tests/GrPipelineDynamicStateTest.cpp
@@ -58,9 +58,9 @@
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 @@
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 @@
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 e2f6fbf..a875205 100644
--- a/tests/OnFlushCallbackTest.cpp
+++ b/tests/OnFlushCallbackTest.cpp
@@ -110,11 +110,10 @@
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 74a73a6..60b2205 100644
--- a/tests/PrimitiveProcessorTest.cpp
+++ b/tests/PrimitiveProcessorTest.cpp
@@ -59,15 +59,15 @@
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);
+ fAttribNames[i].printf("attr%d", i);
+ fAttributes[i] = {fAttribNames[i].c_str(), kFloat2_GrVertexAttribType};
}
- for (auto i = 0; i < numAttribs; ++i) {
- this->addVertexAttrib(fAttribNames[i].c_str(), kFloat2_GrVertexAttribType);
- }
+ this->setVertexAttributeCnt(numAttribs);
}
const char* name() const override { return "Dummy GP"; }
@@ -78,7 +78,7 @@
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 @@
}
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(),