// Copy Color Stages from DS to ODS
if (firstColorStageIdx < drawState.numColorStages()) {
- fColorStages.reset(&drawState.getColorStage(firstColorStageIdx),
- drawState.numColorStages() - firstColorStageIdx);
+ fFragmentStages.reset(&drawState.getColorStage(firstColorStageIdx),
+ drawState.numColorStages() - firstColorStageIdx);
} else {
- fColorStages.reset();
+ fFragmentStages.reset();
}
+ fNumColorStages = fFragmentStages.count();
+
// Copy Coverage Stages from DS to ODS
- if (firstCoverageStageIdx < drawState.numCoverageStages() && separateCoverageFromColor) {
- fCoverageStages.reset(&drawState.getCoverageStage(firstCoverageStageIdx),
- drawState.numCoverageStages() - firstCoverageStageIdx);
- } else {
- fCoverageStages.reset();
- if (firstCoverageStageIdx < drawState.numCoverageStages()) {
- // TODO: Once we have flag to know if we only multiply on stages, only push coverage
- // into color stages if everything is multiply
- fColorStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
- &drawState.getCoverageStage(firstCoverageStageIdx));
+ if (firstCoverageStageIdx < drawState.numCoverageStages()) {
+ fFragmentStages.push_back_n(drawState.numCoverageStages() - firstCoverageStageIdx,
+ &drawState.getCoverageStage(firstCoverageStageIdx));
+ if (!separateCoverageFromColor) {
+ fNumColorStages = fFragmentStages.count();
}
}
};
}
if (this->getRenderTarget() != that.getRenderTarget() ||
- this->fColorStages.count() != that.fColorStages.count() ||
- this->fCoverageStages.count() != that.fCoverageStages.count() ||
+ this->fFragmentStages.count() != that.fFragmentStages.count() ||
+ this->fNumColorStages != that.fNumColorStages ||
!this->fViewMatrix.cheapEqualTo(that.fViewMatrix) ||
this->fSrcBlend != that.fSrcBlend ||
this->fDstBlend != that.fDstBlend ||
return false;
}
- for (int i = 0; i < this->numColorStages(); i++) {
- if (!GrProcessorStage::AreCompatible(this->getColorStage(i), that.getColorStage(i),
- explicitLocalCoords)) {
- return false;
- }
- }
- for (int i = 0; i < this->numCoverageStages(); i++) {
- if (!GrProcessorStage::AreCompatible(this->getCoverageStage(i), that.getCoverageStage(i),
+ for (int i = 0; i < this->numFragmentStages(); i++) {
+ if (!GrProcessorStage::AreCompatible(this->getFragmentStage(i), that.getFragmentStage(i),
explicitLocalCoords)) {
return false;
}
/// the color / coverage distinction.
////
- int numColorStages() const { return fColorStages.count(); }
- int numCoverageStages() const { return fCoverageStages.count(); }
+ int numColorStages() const { return fNumColorStages; }
+ int numCoverageStages() const { return fFragmentStages.count() - fNumColorStages; }
+ int numFragmentStages() const { return fFragmentStages.count(); }
int numTotalStages() const {
- return this->numColorStages() + this->numCoverageStages() +
- (this->hasGeometryProcessor() ? 1 : 0);
+ return this->numFragmentStages() + (this->hasGeometryProcessor() ? 1 : 0);
}
bool hasGeometryProcessor() const { return SkToBool(fGeometryProcessor.get()); }
const GrGeometryStage* getGeometryProcessor() const { return fGeometryProcessor.get(); }
- const GrFragmentStage& getColorStage(int idx) const { return fColorStages[idx]; }
- const GrFragmentStage& getCoverageStage(int idx) const { return fCoverageStages[idx]; }
+ const GrFragmentStage& getColorStage(int idx) const {
+ SkASSERT(idx < this->numColorStages());
+ return fFragmentStages[idx];
+ }
+ const GrFragmentStage& getCoverageStage(int idx) const {
+ SkASSERT(idx < this->numCoverageStages());
+ return fFragmentStages[fNumColorStages + idx];
+ }
+ const GrFragmentStage& getFragmentStage(int idx) const { return fFragmentStages[idx]; }
/// @}
typedef SkSTArray<8, GrFragmentStage> FragmentStageArray;
SkAutoTDelete<GrGeometryStage> fGeometryProcessor;
- FragmentStageArray fColorStages;
- FragmentStageArray fCoverageStages;
+ FragmentStageArray fFragmentStages;
+
+ // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
+ int fNumColorStages;
// This is simply a different representation of info in fVertexAttribs and thus does
// not need to be compared in op==.