}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
GrPerlinNoise2Effect(SkPerlinNoiseShader2::Type type,
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
GrImprovedPerlinNoiseEffect(int octaves, SkScalar z,
class GrInvariantOutput {
public:
GrInvariantOutput(GrColor color, GrColorComponentFlags flags)
- : fColor(color)
- , fValidFlags(flags)
- , fNonMulStageFound(false)
- , fWillUseInputColor(true) {}
+ : fColor(color), fValidFlags(flags), fNonMulStageFound(false) {}
GrInvariantOutput(const GrPipelineInput& input)
- : fColor(input.fColor)
- , fValidFlags(input.fValidFlags)
- , fNonMulStageFound(false)
- , fWillUseInputColor(false) {}
+ : fColor(input.fColor), fValidFlags(input.fValidFlags), fNonMulStageFound(false) {}
virtual ~GrInvariantOutput() {}
- enum ReadInput {
- kWill_ReadInput,
- kWillNot_ReadInput,
- };
-
void mulByUnknownOpaqueFourComponents() {
- SkDEBUGCODE(this->validate());
if (this->isOpaque()) {
fValidFlags = kA_GrColorComponentFlag;
} else {
// multiplied is opaque.
this->mulByUnknownFourComponents();
}
- SkDEBUGCODE(this->validate());
}
void mulByUnknownFourComponents() {
- SkDEBUGCODE(this->validate());
if (this->hasZeroAlpha()) {
this->internalSetToTransparentBlack();
} else {
this->internalSetToUnknown();
}
- SkDEBUGCODE(this->validate());
}
void mulByUnknownSingleComponent() {
- SkDEBUGCODE(this->validate());
if (this->hasZeroAlpha()) {
this->internalSetToTransparentBlack();
} else {
// We don't need to change fIsSingleComponent in this case
fValidFlags = kNone_GrColorComponentFlags;
}
- SkDEBUGCODE(this->validate());
}
void mulByKnownSingleComponent(uint8_t alpha) {
- SkDEBUGCODE(this->validate());
if (this->hasZeroAlpha() || 0 == alpha) {
this->internalSetToTransparentBlack();
} else {
// We don't need to change fIsSingleComponent in this case
}
}
- SkDEBUGCODE(this->validate());
}
void mulByKnownFourComponents(GrColor color) {
- SkDEBUGCODE(this->validate());
uint32_t a;
if (GetAlphaAndCheckSingleChannel(color, &a)) {
this->mulByKnownSingleComponent(a);
SkMulDiv255Round(GrColorUnpackA(fColor), a));
}
}
- SkDEBUGCODE(this->validate());
}
// Ignores the incoming color's RGB and muls its alpha by color.
void mulAlphaByKnownFourComponents(GrColor color) {
- SkDEBUGCODE(this->validate());
uint32_t a;
if (GetAlphaAndCheckSingleChannel(color, &a)) {
this->mulAlphaByKnownSingleComponent(a);
} else {
fValidFlags = kNone_GrColorComponentFlags;
}
- SkDEBUGCODE(this->validate());
}
// Ignores the incoming color's RGB and muls its alpha by the alpha param and sets all channels
// equal to that value.
void mulAlphaByKnownSingleComponent(uint8_t alpha) {
- SkDEBUGCODE(this->validate());
if (0 == alpha || this->hasZeroAlpha()) {
this->internalSetToTransparentBlack();
} else {
fValidFlags = kNone_GrColorComponentFlags;
}
}
- SkDEBUGCODE(this->validate());
}
void premulFourChannelColor() {
- SkDEBUGCODE(this->validate());
fNonMulStageFound = true;
if (!(fValidFlags & kA_GrColorComponentFlag)) {
fValidFlags = kNone_GrColorComponentFlags;
} else {
fColor = GrPremulColor(fColor);
}
- SkDEBUGCODE(this->validate());
}
- void invalidateComponents(GrColorComponentFlags invalidateFlags, ReadInput readsInput) {
- SkDEBUGCODE(this->validate());
+ void invalidateComponents(GrColorComponentFlags invalidateFlags) {
fValidFlags = (fValidFlags & ~invalidateFlags);
fNonMulStageFound = true;
- if (kWillNot_ReadInput == readsInput) {
- fWillUseInputColor = false;
- }
- SkDEBUGCODE(this->validate());
}
- void setToOther(GrColorComponentFlags validFlags, GrColor color, ReadInput readsInput) {
- SkDEBUGCODE(this->validate());
+ void setToOther(GrColorComponentFlags validFlags, GrColor color) {
fValidFlags = validFlags;
fColor = color;
fNonMulStageFound = true;
- if (kWillNot_ReadInput == readsInput) {
- fWillUseInputColor = false;
- }
- if (kRGBA_GrColorComponentFlags == fValidFlags) {
- }
- SkDEBUGCODE(this->validate());
}
- void setToUnknown(ReadInput readsInput) {
- SkDEBUGCODE(this->validate());
+ void setToUnknown() {
this->internalSetToUnknown();
- fNonMulStageFound= true;
- if (kWillNot_ReadInput == readsInput) {
- fWillUseInputColor = false;
- }
- SkDEBUGCODE(this->validate());
+ fNonMulStageFound = true;
}
GrColor color() const { return fColor; }
GrColorComponentFlags validFlags() const { return fValidFlags; }
- bool willUseInputColor() const { return fWillUseInputColor; }
-
-#ifdef SK_DEBUG
- void validate() const {
- // If we claim that we are not using the input color we must not be modulating the input.
- SkASSERT(fNonMulStageFound || fWillUseInputColor);
- }
-#endif
private:
friend class GrProcOptInfo;
fColor = color;
fValidFlags = flags;
fNonMulStageFound = false;
- fWillUseInputColor = true;
}
void reset(const GrPipelineInput& input) {
fColor = input.fColor;
fValidFlags = input.fValidFlags;
fNonMulStageFound = false;
- fWillUseInputColor = true;
}
void internalSetToTransparentBlack() {
return (fValidFlags == kRGBA_GrColorComponentFlags && 0xFFFFFFFF == fColor);
}
- void resetWillUseInputColor() { fWillUseInputColor = true; }
-
bool allStagesMulInput() const { return !fNonMulStageFound; }
void resetNonMulStageFound() { fNonMulStageFound = false; }
GrColor fColor;
GrColorComponentFlags fValidFlags;
bool fNonMulStageFound;
- bool fWillUseInputColor;
};
#endif
// then we can't know the final result.
if (0 != fMatrix[kAlphaRowStartIdx + i]) {
if (!(inout->validFlags() & kRGBAFlags[i])) {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
return;
} else {
uint32_t component = (inout->color() >> kShifts[i]) & 0xFF;
// underflow this may deviate from the actual result. Maybe the effect should pin its
// result if the matrix could over/underflow for any component?
inout->setToOther(kA_GrColorComponentFlag,
- static_cast<uint8_t>(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A,
- GrInvariantOutput::kWill_ReadInput);
+ static_cast<uint8_t>(SkScalarPin(outputA, 0, 255)) << GrColor_SHIFT_A);
}
SkScalar fMatrix[20];
const char* name() const override { return "NormalBevelFP"; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
private:
const char* name() const override { return "NormalFlatFP"; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
private:
const char* name() const override { return "NormalMapFP"; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::ReadInput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
const SkMatrix& invCTM() const { return fInvCTM; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// TODO: optimize this
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
ArithmeticFP(float k1, float k2, float k3, float k4, bool enforcePMColor,
// and no displacement offset push any texture coordinates out of bounds OR if the constant
// alpha is 0. Since this isn't trivial to compute at this point, let's assume the output is
// not of constant color when a displacement effect is applied.
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
///////////////////////////////////////////////////////////////////////////////
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// The output is always black. The alpha value for the color passed in is arbitrary.
- inout->setToOther(kRGB_GrColorComponentFlags, GrColorPackRGBA(0, 0, 0, 0),
- GrInvariantOutput::kWill_ReadInput);
+ inout->setToOther(kRGB_GrColorComponentFlags, GrColorPackRGBA(0, 0, 0, 0));
}
};
}
void OverdrawFragmentProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
- inout->invalidateComponents(kRGBA_GrColorComponentFlags, GrInvariantOutput::kWill_ReadInput);
+ inout->invalidateComponents(kRGBA_GrColorComponentFlags);
}
GLOverdrawFragmentProcessor::GLOverdrawFragmentProcessor(const GrColor4f* colors) {
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
GrPerlinNoiseEffect(SkPerlinNoiseShader::Type type,
const char* name() const override { return "RRectsGaussianEdgeFP"; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
const SkRRect& first() const { return fFirst; }
if (fFlags & SkTable_ColorFilter::kA_Flag) {
invalidateFlags |= kA_GrColorComponentFlag;
}
- inout->invalidateComponents(invalidateFlags, GrInvariantOutput::kWill_ReadInput);
+ inout->invalidateComponents(invalidateFlags);
}
///////////////////////////////////////////////////////////////////////////////
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// TODO: Add a helper to GrInvariantOutput that handles multiplying by color with flags?
if (!(inout->validFlags() & kA_GrColorComponentFlag)) {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
return;
}
color |= SkMulDiv255Round(GrColorUnpackB(c0), GrColorUnpackB(c1)) <<
GrColor_SHIFT_B;
}
- inout->setToOther(commonFlags, color, GrInvariantOutput::kWill_ReadInput);
+ inout->setToOther(commonFlags, color);
}
};
if (!fp) {
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor(),
- GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor());
this->childProcessor(0).computeInvariantOutput(inout);
}
GrInvariantOutput childOut(0x0, kNone_GrColorComponentFlags);
fp->computeInvariantOutput(&childOut);
- if (childOut.willUseInputColor()) {
- return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
- } else {
- return fp;
- }
+ return sk_sp<GrFragmentProcessor>(new ReplaceInputFragmentProcessor(std::move(fp), color));
}
sk_sp<GrFragmentProcessor> GrFragmentProcessor::RunInSeries(sk_sp<GrFragmentProcessor>* series,
int firstIdx = info.firstEffectiveProcessorIndex();
cnt -= firstIdx;
- if (firstIdx > 0 && info.inputColorIsUsed()) {
+ if (firstIdx > 0) {
// See comment above - need to preserve 4f and color spaces during invariant processing.
sk_sp<GrFragmentProcessor> colorFP(GrConstColorProcessor::Make(
GrColor4f::FromGrColor(info.inputColorToFirstEffectiveProccesor()),
replacementSeries.emplace_back(std::move(series[firstIdx + i]));
}
series = replacementSeries.begin();
- } else {
- series += firstIdx;
- cnt -= firstIdx;
}
if (1 == cnt) {
void GrProcOptInfo::analyzeProcessors(const GrFragmentProcessor* const* processors, int cnt) {
for (int i = 0; i < cnt; ++i) {
const GrFragmentProcessor* processor = processors[i];
- fInOut.resetWillUseInputColor();
processor->computeInvariantOutput(&fInOut);
- SkDEBUGCODE(fInOut.validate());
- if (!fInOut.willUseInputColor()) {
- fFirstEffectiveProcessorIndex = i;
- fInputColorIsUsed = false;
- }
if (kRGBA_GrColorComponentFlags == fInOut.validFlags()) {
fFirstEffectiveProcessorIndex = i + 1;
fInputColor = fInOut.color();
- fInputColorIsUsed = true;
// Since we are clearing all previous color stages we are in a state where we have found
// zero stages that don't multiply the inputColor.
fInOut.resetNonMulStageFound();
int firstEffectiveProcessorIndex() const { return fFirstEffectiveProcessorIndex; }
/**
- * True if the first effective processor reads its input, false otherwise.
- */
- bool inputColorIsUsed() const { return fInputColorIsUsed; }
-
- /**
* If input color is used and per-vertex colors are not used, this is the input color to the
* first effective processor.
*/
void internalReset(GrColor color, GrColorComponentFlags colorFlags, bool isLCDCoverage) {
fInOut.reset(color, colorFlags);
fFirstEffectiveProcessorIndex = 0;
- fInputColorIsUsed = true;
fInputColor = color;
fIsLCDCoverage = isLCDCoverage;
}
GrInvariantOutput fInOut;
int fFirstEffectiveProcessorIndex = 0;
- bool fInputColorIsUsed = true;
bool fIsLCDCoverage = false;
GrColor fInputColor = 0;
};
void GrConstColorProcessor::onComputeInvariantOutput(GrInvariantOutput* inout) const {
if (kIgnore_InputMode == fMode) {
- inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor(),
- GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToOther(kRGBA_GrColorComponentFlags, fColor.toGrColor());
} else {
float r = fColor.fRGBA[0];
bool colorIsSingleChannel = r == fColor.fRGBA[1] && r == fColor.fRGBA[2] &&
};
void DitherEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
//////////////////////////////////////////////////////////////////////////////
}
void GrGammaEffect::onComputeInvariantOutput(GrInvariantOutput* inout) const {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
///////////////////////////////////////////////////////////////////////////////
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
private:
inout->color(), inout->validFlags(),
&blendColor, &blendFlags);
}
- // will the shader code reference the input color?
- GrInvariantOutput::ReadInput readsInput = GrInvariantOutput::kWillNot_ReadInput;
- if (kDst_Child == fChild) {
- if (kZero_GrBlendCoeff != srcCoeff || GrBlendCoeffRefsSrc(dstCoeff)) {
- readsInput = GrInvariantOutput::kWill_ReadInput;
- }
- } else {
- if (kZero_GrBlendCoeff != dstCoeff || GrBlendCoeffRefsDst(srcCoeff)) {
- readsInput = GrInvariantOutput::kWill_ReadInput;
- }
- }
- inout->setToOther(blendFlags, blendColor, readsInput);
+ inout->setToOther(blendFlags, blendColor);
} else {
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// YUV is opaque
- inout->setToOther(kA_GrColorComponentFlag, 0xFF << GrColor_SHIFT_A,
- GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToOther(kA_GrColorComponentFlag, 0xFF << GrColor_SHIFT_A);
}
GrCoordTransform fYTransform;
}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
GrCoordTransform fTransform;
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToOther(kRGBA_GrColorComponentFlags, GrColor_WHITE,
- GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToOther(kRGBA_GrColorComponentFlags, GrColor_WHITE);
this->childProcessor(0).computeInvariantOutput(inout);
}
void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
- inout->setToUnknown(GrInvariantOutput::kWillNot_ReadInput);
+ inout->setToUnknown();
}
bool onIsEqual(const GrFragmentProcessor& that) const override { return true; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
// We don't care about optimizing these processors.
- inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
+ inout->setToUnknown();
}
private: