aboutsummaryrefslogtreecommitdiffhomepage
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/core/SkImageFilter.cpp2
-rw-r--r--src/effects/SkBlurMaskFilter.cpp8
-rw-r--r--src/effects/SkDisplacementMapEffect.cpp2
-rw-r--r--src/effects/SkGpuBlurUtils.cpp6
-rw-r--r--src/effects/SkLightingImageFilter.cpp2
-rw-r--r--src/effects/SkMorphologyImageFilter.cpp22
-rw-r--r--src/effects/SkXfermodeImageFilter.cpp4
-rw-r--r--src/gpu/GrBlurUtils.cpp2
-rw-r--r--src/gpu/GrClipMaskManager.cpp6
-rwxr-xr-xsrc/gpu/GrContext.cpp4
-rw-r--r--src/gpu/GrOvalRenderer.cpp4
-rw-r--r--src/gpu/GrPaint.cpp11
-rw-r--r--src/gpu/GrPendingFragmentStage.h27
-rw-r--r--src/gpu/GrPipeline.cpp56
-rw-r--r--src/gpu/GrPipeline.h42
-rw-r--r--src/gpu/GrPipelineBuilder.cpp66
-rw-r--r--src/gpu/GrPipelineBuilder.h69
-rw-r--r--src/gpu/GrProcOptInfo.cpp44
-rw-r--r--src/gpu/GrProcOptInfo.h46
-rw-r--r--src/gpu/GrProcessor.cpp10
-rw-r--r--src/gpu/GrSWMaskHelper.cpp2
-rw-r--r--src/gpu/SkGpuDevice.cpp4
-rw-r--r--src/gpu/SkGr.cpp10
-rw-r--r--src/gpu/batches/GrDrawBatch.h8
-rw-r--r--src/gpu/effects/GrConfigConversionEffect.cpp6
-rw-r--r--src/gpu/gl/GrGLPathProgram.cpp4
-rw-r--r--src/gpu/gl/GrGLPathProgram.h2
-rw-r--r--src/gpu/gl/GrGLProgram.cpp19
-rw-r--r--src/gpu/gl/GrGLProgram.h2
-rw-r--r--src/gpu/gl/GrGLProgramDesc.cpp9
-rw-r--r--src/gpu/gl/builders/GrGLProgramBuilder.cpp35
-rw-r--r--src/gpu/gl/builders/GrGLProgramBuilder.h7
-rw-r--r--src/image/SkImage_Gpu.cpp5
33 files changed, 282 insertions, 264 deletions
diff --git a/src/core/SkImageFilter.cpp b/src/core/SkImageFilter.cpp
index e9be10967f..5157db2dc9 100644
--- a/src/core/SkImageFilter.cpp
+++ b/src/core/SkImageFilter.cpp
@@ -352,7 +352,7 @@ bool SkImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Cont
GrPaint paint;
if (this->asFragmentProcessor(&fp, paint.getProcessorDataManager(), srcTexture, matrix, bounds)) {
SkASSERT(fp);
- paint.addColorFragmentProcessor(fp)->unref();
+ paint.addColorProcessor(fp)->unref();
GrDrawContext* drawContext = context->drawContext();
if (drawContext) {
diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
index 7faf52e368..96789c2d35 100644
--- a/src/effects/SkBlurMaskFilter.cpp
+++ b/src/effects/SkBlurMaskFilter.cpp
@@ -859,7 +859,7 @@ bool SkBlurMaskFilterImpl::directFilterMaskGPU(GrTextureProvider* texProvider,
return false;
}
- grp->addCoverageFragmentProcessor(fp);
+ grp->addCoverageProcessor(fp);
SkMatrix inverse;
if (!viewMatrix.invert(&inverse)) {
@@ -1135,7 +1135,7 @@ bool SkBlurMaskFilterImpl::directFilterRRectMaskGPU(GrTextureProvider* texProvid
return false;
}
- grp->addCoverageFragmentProcessor(fp);
+ grp->addCoverageProcessor(fp);
SkMatrix inverse;
if (!viewMatrix.invert(&inverse)) {
@@ -1211,8 +1211,8 @@ bool SkBlurMaskFilterImpl::filterMaskGPU(GrTexture* src,
SkMatrix matrix;
matrix.setIDiv(src->width(), src->height());
// Blend pathTexture over blurTexture.
- paint.addCoverageFragmentProcessor(
- GrSimpleTextureEffect::Create(paint.getProcessorDataManager(), src, matrix))->unref();
+ paint.addCoverageProcessor(GrSimpleTextureEffect::Create(paint.getProcessorDataManager(),
+ src, matrix))->unref();
if (kInner_SkBlurStyle == fBlurStyle) {
// inner: dst = dst * src
paint.setCoverageSetOpXPFactory(SkRegion::kIntersect_Op);
diff --git a/src/effects/SkDisplacementMapEffect.cpp b/src/effects/SkDisplacementMapEffect.cpp
index fe52317cc8..f360fe102c 100644
--- a/src/effects/SkDisplacementMapEffect.cpp
+++ b/src/effects/SkDisplacementMapEffect.cpp
@@ -444,7 +444,7 @@ bool SkDisplacementMapEffect::filterImageGPU(Proxy* proxy, const SkBitmap& src,
offsetMatrix.preTranslate(SkIntToScalar(colorOffset.fX - displacementOffset.fX),
SkIntToScalar(colorOffset.fY - displacementOffset.fY));
- paint.addColorFragmentProcessor(
+ paint.addColorProcessor(
GrDisplacementMapEffect::Create(paint.getProcessorDataManager(),
fXChannelSelector,
fYChannelSelector,
diff --git a/src/effects/SkGpuBlurUtils.cpp b/src/effects/SkGpuBlurUtils.cpp
index 2b6b310819..7c239a1bc3 100644
--- a/src/effects/SkGpuBlurUtils.cpp
+++ b/src/effects/SkGpuBlurUtils.cpp
@@ -59,7 +59,7 @@ static void convolve_gaussian_1d(GrDrawContext* drawContext,
GrPaint paint;
SkAutoTUnref<GrFragmentProcessor> conv(GrConvolutionEffect::CreateGaussian(
paint.getProcessorDataManager(), texture, direction, radius, sigma, useBounds, bounds));
- paint.addColorFragmentProcessor(conv);
+ paint.addColorProcessor(conv);
drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), dstRect, srcRect);
}
@@ -83,7 +83,7 @@ static void convolve_gaussian_2d(GrDrawContext* drawContext,
texture, bounds, size, 1.0, 0.0, kernelOffset,
useBounds ? GrTextureDomain::kClamp_Mode : GrTextureDomain::kIgnore_Mode,
true, sigmaX, sigmaY));
- paint.addColorFragmentProcessor(conv);
+ paint.addColorProcessor(conv);
drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), dstRect, srcRect);
}
@@ -216,7 +216,7 @@ GrTexture* GaussianBlur(GrContext* context,
domain,
GrTextureDomain::kDecal_Mode,
GrTextureParams::kBilerp_FilterMode));
- paint.addColorFragmentProcessor(fp);
+ paint.addColorProcessor(fp);
} else {
GrTextureParams params(SkShader::kClamp_TileMode, GrTextureParams::kBilerp_FilterMode);
paint.addColorTextureProcessor(srcTexture, matrix, params);
diff --git a/src/effects/SkLightingImageFilter.cpp b/src/effects/SkLightingImageFilter.cpp
index 6dbe73429c..c63b2ebe50 100644
--- a/src/effects/SkLightingImageFilter.cpp
+++ b/src/effects/SkLightingImageFilter.cpp
@@ -354,7 +354,7 @@ void SkLightingImageFilterInternal::drawRect(GrDrawContext* drawContext,
GrPaint paint;
GrFragmentProcessor* fp = this->getFragmentProcessor(paint.getProcessorDataManager(), src,
matrix, bounds, boundaryMode);
- paint.addColorFragmentProcessor(fp)->unref();
+ paint.addColorProcessor(fp)->unref();
drawContext->drawNonAARectToRect(dst->asRenderTarget(), clip, paint, SkMatrix::I(),
dstRect, srcRect);
}
diff --git a/src/effects/SkMorphologyImageFilter.cpp b/src/effects/SkMorphologyImageFilter.cpp
index f1a7d09b8b..01e978e846 100644
--- a/src/effects/SkMorphologyImageFilter.cpp
+++ b/src/effects/SkMorphologyImageFilter.cpp
@@ -471,12 +471,12 @@ void apply_morphology_rect(GrDrawContext* drawContext,
float bounds[2],
Gr1DKernelEffect::Direction direction) {
GrPaint paint;
- paint.addColorFragmentProcessor(GrMorphologyEffect::Create(paint.getProcessorDataManager(),
- texture,
- direction,
- radius,
- morphType,
- bounds))->unref();
+ paint.addColorProcessor(GrMorphologyEffect::Create(paint.getProcessorDataManager(),
+ texture,
+ direction,
+ radius,
+ morphType,
+ bounds))->unref();
drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
SkRect::Make(srcRect));
}
@@ -491,11 +491,11 @@ void apply_morphology_rect_no_bounds(GrDrawContext* drawContext,
GrMorphologyEffect::MorphologyType morphType,
Gr1DKernelEffect::Direction direction) {
GrPaint paint;
- paint.addColorFragmentProcessor(GrMorphologyEffect::Create(paint.getProcessorDataManager(),
- texture,
- direction,
- radius,
- morphType))->unref();
+ paint.addColorProcessor(GrMorphologyEffect::Create(paint.getProcessorDataManager(),
+ texture,
+ direction,
+ radius,
+ morphType))->unref();
drawContext->drawNonAARectToRect(rt, clip, paint, SkMatrix::I(), SkRect::Make(dstRect),
SkRect::Make(srcRect));
}
diff --git a/src/effects/SkXfermodeImageFilter.cpp b/src/effects/SkXfermodeImageFilter.cpp
index f62773a250..e014cc0471 100644
--- a/src/effects/SkXfermodeImageFilter.cpp
+++ b/src/effects/SkXfermodeImageFilter.cpp
@@ -189,8 +189,8 @@ bool SkXfermodeImageFilter::filterImageGPU(Proxy* proxy,
GrTextureParams::kNone_FilterMode)
);
- paint.addColorFragmentProcessor(foregroundDomain.get());
- paint.addColorFragmentProcessor(xferProcessor)->unref();
+ paint.addColorProcessor(foregroundDomain.get());
+ paint.addColorProcessor(xferProcessor)->unref();
GrDrawContext* drawContext = context->drawContext();
if (!drawContext) {
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index ede386afb2..6013b58bcf 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -36,7 +36,7 @@ static bool draw_mask(GrDrawContext* drawContext,
matrix.setTranslate(-maskRect.fLeft, -maskRect.fTop);
matrix.postIDiv(mask->width(), mask->height());
- grp->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(grp->getProcessorDataManager(),
+ grp->addCoverageProcessor(GrSimpleTextureEffect::Create(grp->getProcessorDataManager(),
mask, matrix,
kDevice_GrCoordSet))->unref();
diff --git a/src/gpu/GrClipMaskManager.cpp b/src/gpu/GrClipMaskManager.cpp
index c9362fa208..b58faaad63 100644
--- a/src/gpu/GrClipMaskManager.cpp
+++ b/src/gpu/GrClipMaskManager.cpp
@@ -46,7 +46,7 @@ void setup_drawstate_aaclip(const GrPipelineBuilder& pipelineBuilder,
SkIRect domainTexels = SkIRect::MakeWH(devBound.width(), devBound.height());
// This could be a long-lived effect that is cached with the alpha-mask.
- arfps->addCoverageFragmentProcessor(
+ arfps->addCoverageProcessor(
GrTextureDomainEffect::Create(arfps->getProcessorDataManager(),
result,
mat,
@@ -200,7 +200,7 @@ bool GrClipMaskManager::installClipEffects(
break;
}
if (fp) {
- arfps->addCoverageFragmentProcessor(fp);
+ arfps->addCoverageProcessor(fp);
} else {
failed = true;
break;
@@ -488,7 +488,7 @@ void GrClipMaskManager::mergeMask(GrPipelineBuilder* pipelineBuilder,
SkMatrix sampleM;
sampleM.setIDiv(srcMask->width(), srcMask->height());
- pipelineBuilder->addCoverageFragmentProcessor(
+ pipelineBuilder->addCoverageProcessor(
GrTextureDomainEffect::Create(pipelineBuilder->getProcessorDataManager(),
srcMask,
sampleM,
diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
index 8b8528b723..2f334c6ba0 100755
--- a/src/gpu/GrContext.cpp
+++ b/src/gpu/GrContext.cpp
@@ -427,7 +427,7 @@ bool GrContext::writeSurfacePixels(GrSurface* surface,
if (!drawContext) {
return false;
}
- paint.addColorFragmentProcessor(fp);
+ paint.addColorProcessor(fp);
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
drawContext->drawRect(renderTarget, GrClip::WideOpen(), paint, matrix, rect, NULL);
@@ -532,7 +532,7 @@ bool GrContext::readSurfacePixels(GrSurface* src,
GrConfigConversionEffect::kNone_PMConversion, textureMatrix));
}
if (fp) {
- paint.addColorFragmentProcessor(fp);
+ paint.addColorProcessor(fp);
SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
GrDrawContext* drawContext = this->drawContext();
drawContext->drawRect(temp->asRenderTarget(), GrClip::WideOpen(), paint,
diff --git a/src/gpu/GrOvalRenderer.cpp b/src/gpu/GrOvalRenderer.cpp
index f4dca8bf21..2ad7e72067 100644
--- a/src/gpu/GrOvalRenderer.cpp
+++ b/src/gpu/GrOvalRenderer.cpp
@@ -1423,7 +1423,7 @@ bool GrOvalRenderer::DrawDRRect(GrDrawTarget* target,
return false;
}
arfps.set(&pipelineBuilder);
- arfps.addCoverageFragmentProcessor(fp)->unref();
+ arfps.addCoverageProcessor(fp)->unref();
}
SkStrokeRec fillRec(SkStrokeRec::kFill_InitStyle);
@@ -1453,7 +1453,7 @@ bool GrOvalRenderer::DrawDRRect(GrDrawTarget* target,
return false;
}
- arfps.addCoverageFragmentProcessor(effect)->unref();
+ arfps.addCoverageProcessor(effect)->unref();
SkRect bounds = outer->getBounds();
if (applyAA) {
bounds.outset(SK_ScalarHalf, SK_ScalarHalf);
diff --git a/src/gpu/GrPaint.cpp b/src/gpu/GrPaint.cpp
index d37ac57a08..7427785588 100644
--- a/src/gpu/GrPaint.cpp
+++ b/src/gpu/GrPaint.cpp
@@ -25,33 +25,32 @@ void GrPaint::setCoverageSetOpXPFactory(SkRegion::Op regionOp, bool invertCovera
}
void GrPaint::addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
- this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+ this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void GrPaint::addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
- this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
matrix))->unref();
}
void GrPaint::addColorTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
+ this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}
void GrPaint::addCoverageTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
params))->unref();
}
bool GrPaint::isConstantBlendedColor(GrColor* color) const {
GrProcOptInfo colorProcInfo;
- colorProcInfo.calcWithInitialValues(fColorFragmentProcessors.begin(),
- this->numColorFragmentProcessors(), fColor,
+ colorProcInfo.calcWithInitialValues(fColorStages.begin(), this->numColorStages(), fColor,
kRGBA_GrColorComponentFlags, false);
GrXPFactory::InvariantBlendedColor blendedColor;
diff --git a/src/gpu/GrPendingFragmentStage.h b/src/gpu/GrPendingFragmentStage.h
new file mode 100644
index 0000000000..dfa5688663
--- /dev/null
+++ b/src/gpu/GrPendingFragmentStage.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2014 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrPendingFragmentStage_DEFINED
+#define GrPendingFragmentStage_DEFINED
+
+#include "GrStagedProcessor.h"
+#include "GrPendingProgramElement.h"
+
+/**
+ * This a baked variant of GrFragmentStage, as recorded in GrPipeline
+ */
+class GrPendingFragmentStage : public GrStagedProcessor<GrPendingProgramElement> {
+public:
+ GrPendingFragmentStage(const GrFragmentStage& stage) {
+ INHERITED::fProc.reset(stage.processor());
+ }
+
+private:
+ typedef GrStagedProcessor<GrPendingProgramElement> INHERITED;
+};
+
+#endif
diff --git a/src/gpu/GrPipeline.cpp b/src/gpu/GrPipeline.cpp
index 5e057b089f..8f149f5c4b 100644
--- a/src/gpu/GrPipeline.cpp
+++ b/src/gpu/GrPipeline.cpp
@@ -29,8 +29,8 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
}
GrColor overrideColor = GrColor_ILLEGAL;
- if (args.fColorPOI.firstEffectiveProcessorIndex() != 0) {
- overrideColor = args.fColorPOI.inputColorToFirstEffectiveProccesor();
+ if (args.fColorPOI.firstEffectiveStageIndex() != 0) {
+ overrideColor = args.fColorPOI.inputColorToEffectiveStage();
}
GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags;
@@ -73,36 +73,31 @@ GrPipeline* GrPipeline::CreateAt(void* memory, const CreateArgs& args,
pipeline->fFlags |= kSnapVertices_Flag;
}
- int firstColorProcessorIdx = args.fColorPOI.firstEffectiveProcessorIndex();
+ int firstColorStageIdx = args.fColorPOI.firstEffectiveStageIndex();
- // TODO: Once we can handle single or four channel input into coverage GrFragmentProcessors
- // then we can use GrPipelineBuilder's coverageProcInfo (like color above) to set this initial
- // information.
- int firstCoverageProcessorIdx = 0;
+ // TODO: Once we can handle single or four channel input into coverage stages then we can use
+ // GrPipelineBuilder's coverageProcInfo (like color above) to set this initial information.
+ int firstCoverageStageIdx = 0;
pipeline->adjustProgramFromOptimizations(builder, optFlags, args.fColorPOI, args.fCoveragePOI,
- &firstColorProcessorIdx, &firstCoverageProcessorIdx);
+ &firstColorStageIdx, &firstCoverageStageIdx);
bool usesLocalCoords = false;
- // Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline
- pipeline->fNumColorProcessors = builder.numColorFragmentProcessors() - firstColorProcessorIdx;
- int numTotalProcessors = pipeline->fNumColorProcessors +
- builder.numCoverageFragmentProcessors() - firstCoverageProcessorIdx;
- pipeline->fFragmentProcessors.reset(numTotalProcessors);
- int currFPIdx = 0;
- for (int i = firstColorProcessorIdx; i < builder.numColorFragmentProcessors();
- ++i, ++currFPIdx) {
- const GrFragmentProcessor* fp = builder.getColorFragmentProcessor(i);
- pipeline->fFragmentProcessors[currFPIdx].reset(fp);
+ // Copy Stages from PipelineBuilder to Pipeline
+ for (int i = firstColorStageIdx; i < builder.numColorFragmentStages(); ++i) {
+ const GrFragmentStage& fps = builder.fColorStages[i];
+ const GrFragmentProcessor* fp = fps.processor();
+ SkNEW_APPEND_TO_TARRAY(&pipeline->fFragmentStages, GrPendingFragmentStage, (fps));
usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
fp->gatherCoordTransforms(&pipeline->fCoordTransforms);
}
- for (int i = firstCoverageProcessorIdx; i < builder.numCoverageFragmentProcessors();
- ++i, ++currFPIdx) {
- const GrFragmentProcessor* fp = builder.getCoverageFragmentProcessor(i);
- pipeline->fFragmentProcessors[currFPIdx].reset(fp);
+ pipeline->fNumColorStages = pipeline->fFragmentStages.count();
+ for (int i = firstCoverageStageIdx; i < builder.numCoverageFragmentStages(); ++i) {
+ const GrFragmentStage& fps = builder.fCoverageStages[i];
+ const GrFragmentProcessor* fp = fps.processor();
+ SkNEW_APPEND_TO_TARRAY(&pipeline->fFragmentStages, GrPendingFragmentStage, (fps));
usesLocalCoords = usesLocalCoords || fp->usesLocalCoords();
fp->gatherCoordTransforms(&pipeline->fCoordTransforms);
}
@@ -139,13 +134,13 @@ void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelin
GrXferProcessor::OptFlags flags,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- int* firstColorProcessorIdx,
- int* firstCoverageProcessorIdx) {
+ int* firstColorStageIdx,
+ int* firstCoverageStageIdx) {
fReadsFragPosition = fXferProcessor->willReadFragmentPosition();
if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) ||
(flags & GrXferProcessor::kOverrideColor_OptFlag)) {
- *firstColorProcessorIdx = pipelineBuilder.numColorFragmentProcessors();
+ *firstColorStageIdx = pipelineBuilder.numColorFragmentStages();
} else {
if (coveragePOI.readsFragPosition()) {
fReadsFragPosition = true;
@@ -153,7 +148,7 @@ void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelin
}
if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) {
- *firstCoverageProcessorIdx = pipelineBuilder.numCoverageFragmentProcessors();
+ *firstCoverageStageIdx = pipelineBuilder.numCoverageFragmentStages();
} else {
if (coveragePOI.readsFragPosition()) {
fReadsFragPosition = true;
@@ -168,8 +163,8 @@ bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b,
SkASSERT(&a != &b);
if (a.getRenderTarget() != b.getRenderTarget() ||
- a.fFragmentProcessors.count() != b.fFragmentProcessors.count() ||
- a.fNumColorProcessors != b.fNumColorProcessors ||
+ a.fFragmentStages.count() != b.fFragmentStages.count() ||
+ a.fNumColorStages != b.fNumColorStages ||
a.fScissorState != b.fScissorState ||
a.fFlags != b.fFlags ||
a.fStencilSettings != b.fStencilSettings ||
@@ -181,8 +176,9 @@ bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b,
return false;
}
- for (int i = 0; i < a.numFragmentProcessors(); i++) {
- if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignoreCoordTransforms)) {
+ for (int i = 0; i < a.numFragmentStages(); i++) {
+ if (!a.getFragmentStage(i).processor()->isEqual(*b.getFragmentStage(i).processor(),
+ ignoreCoordTransforms)) {
return false;
}
}
diff --git a/src/gpu/GrPipeline.h b/src/gpu/GrPipeline.h
index db1415524d..ea2ea855dc 100644
--- a/src/gpu/GrPipeline.h
+++ b/src/gpu/GrPipeline.h
@@ -9,10 +9,9 @@
#define GrPipeline_DEFINED
#include "GrColor.h"
-#include "GrFragmentProcessor.h"
#include "GrGpu.h"
#include "GrNonAtomicRef.h"
-#include "GrPendingProgramElement.h"
+#include "GrPendingFragmentStage.h"
#include "GrPrimitiveProcessor.h"
#include "GrProgramDesc.h"
#include "GrStencil.h"
@@ -85,26 +84,22 @@ public:
/// @name GrFragmentProcessors
- int numColorFragmentProcessors() const { return fNumColorProcessors; }
- int numCoverageFragmentProcessors() const {
- return fFragmentProcessors.count() - fNumColorProcessors;
- }
- int numFragmentProcessors() const { return fFragmentProcessors.count(); }
+ int numColorFragmentStages() const { return fNumColorStages; }
+ int numCoverageFragmentStages() const { return fFragmentStages.count() - fNumColorStages; }
+ int numFragmentStages() const { return fFragmentStages.count(); }
const GrXferProcessor* getXferProcessor() const { return fXferProcessor.get(); }
- const GrFragmentProcessor& getColorFragmentProcessor(int idx) const {
- SkASSERT(idx < this->numColorFragmentProcessors());
- return *fFragmentProcessors[idx].get();
+ const GrPendingFragmentStage& getColorStage(int idx) const {
+ SkASSERT(idx < this->numColorFragmentStages());
+ return fFragmentStages[idx];
}
-
- const GrFragmentProcessor& getCoverageFragmentProcessor(int idx) const {
- SkASSERT(idx < this->numCoverageFragmentProcessors());
- return *fFragmentProcessors[fNumColorProcessors + idx].get();
+ const GrPendingFragmentStage& getCoverageStage(int idx) const {
+ SkASSERT(idx < this->numCoverageFragmentStages());
+ return fFragmentStages[fNumColorStages + idx];
}
-
- const GrFragmentProcessor& getFragmentProcessor(int idx) const {
- return *fFragmentProcessors[idx].get();
+ const GrPendingFragmentStage& getFragmentStage(int idx) const {
+ return fFragmentStages[idx];
}
/// @}
@@ -154,8 +149,8 @@ private:
GrXferProcessor::OptFlags,
const GrProcOptInfo& colorPOI,
const GrProcOptInfo& coveragePOI,
- int* firstColorProcessorIdx,
- int* firstCoverageProcessorIdx);
+ int* firstColorStageIdx,
+ int* firstCoverageStageIdx);
/**
* Calculates the primary and secondary output types of the shader. For certain output types
@@ -172,8 +167,7 @@ private:
};
typedef GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> RenderTarget;
- typedef GrPendingProgramElement<const GrFragmentProcessor> PendingFragmentProcessor;
- typedef SkAutoSTArray<8, PendingFragmentProcessor> FragmentProcessorArray;
+ typedef SkSTArray<8, GrPendingFragmentStage> FragmentStageArray;
typedef GrPendingProgramElement<const GrXferProcessor> ProgramXferProcessor;
RenderTarget fRenderTarget;
GrScissorState fScissorState;
@@ -181,11 +175,11 @@ private:
GrPipelineBuilder::DrawFace fDrawFace;
uint32_t fFlags;
ProgramXferProcessor fXferProcessor;
- FragmentProcessorArray fFragmentProcessors;
+ FragmentStageArray fFragmentStages;
bool fReadsFragPosition;
- // This value is also the index in fFragmentProcessors where coverage processors begin.
- int fNumColorProcessors;
+ // This function is equivalent to the offset into fFragmentStages where coverage stages begin.
+ int fNumColorStages;
SkSTArray<8, const GrCoordTransform*, true> fCoordTransforms;
GrProgramDesc fDesc;
diff --git a/src/gpu/GrPipelineBuilder.cpp b/src/gpu/GrPipelineBuilder.cpp
index 0fb8ac0cca..64a1d0c428 100644
--- a/src/gpu/GrPipelineBuilder.cpp
+++ b/src/gpu/GrPipelineBuilder.cpp
@@ -22,6 +22,20 @@ GrPipelineBuilder::GrPipelineBuilder()
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
}
+GrPipelineBuilder& GrPipelineBuilder::operator=(const GrPipelineBuilder& that) {
+ fProcDataManager.reset(SkNEW_ARGS(GrProcessorDataManager, (*that.processorDataManager())));
+ fRenderTarget.reset(SkSafeRef(that.fRenderTarget.get()));
+ fFlags = that.fFlags;
+ fStencilSettings = that.fStencilSettings;
+ fDrawFace = that.fDrawFace;
+ fXPFactory.reset(SkRef(that.getXPFactory()));
+ fColorStages = that.fColorStages;
+ fCoverageStages = that.fCoverageStages;
+ fClip = that.fClip;
+
+ return *this;
+}
+
GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, const GrClip& clip) {
SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
@@ -29,12 +43,15 @@ GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, c
fProcDataManager.reset(
const_cast<GrProcessorDataManager*>(SkRef(paint.processorDataManager())));
- for (int i = 0; i < paint.numColorFragmentProcessors(); ++i) {
- fColorFragmentProcessors.push_back(SkRef(paint.getColorFragmentProcessor(i)));
+ fColorStages.reset();
+ fCoverageStages.reset();
+
+ for (int i = 0; i < paint.numColorStages(); ++i) {
+ fColorStages.push_back(paint.getColorStage(i));
}
- for (int i = 0; i < paint.numCoverageFragmentProcessors(); ++i) {
- fCoverageFragmentProcessors.push_back(SkRef(paint.getCoverageFragmentProcessor(i)));
+ for (int i = 0; i < paint.numCoverageStages(); ++i) {
+ fCoverageStages.push_back(paint.getCoverageStage(i));
}
fXPFactory.reset(SkRef(paint.getXPFactory()));
@@ -65,26 +82,21 @@ bool GrPipelineBuilder::willXPNeedDstTexture(const GrCaps& caps,
void GrPipelineBuilder::AutoRestoreFragmentProcessorState::set(
const GrPipelineBuilder* pipelineBuilder) {
if (fPipelineBuilder) {
- int m = fPipelineBuilder->numColorFragmentProcessors() - fColorEffectCnt;
+ int m = fPipelineBuilder->numColorFragmentStages() - fColorEffectCnt;
SkASSERT(m >= 0);
- for (int i = 0; i < m; ++i) {
- fPipelineBuilder->fColorFragmentProcessors.fromBack(i)->unref();
- }
- fPipelineBuilder->fColorFragmentProcessors.pop_back_n(m);
+ fPipelineBuilder->fColorStages.pop_back_n(m);
- int n = fPipelineBuilder->numCoverageFragmentProcessors() - fCoverageEffectCnt;
+ int n = fPipelineBuilder->numCoverageFragmentStages() - fCoverageEffectCnt;
SkASSERT(n >= 0);
- for (int i = 0; i < n; ++i) {
- fPipelineBuilder->fCoverageFragmentProcessors.fromBack(i)->unref();
- }
- fPipelineBuilder->fCoverageFragmentProcessors.pop_back_n(n);
+ fPipelineBuilder->fCoverageStages.pop_back_n(n);
+
SkDEBUGCODE(--fPipelineBuilder->fBlockEffectRemovalCnt;)
fPipelineBuilder->getProcessorDataManager()->restoreToSaveMarker(/*fSaveMarker*/);
}
fPipelineBuilder = const_cast<GrPipelineBuilder*>(pipelineBuilder);
if (NULL != pipelineBuilder) {
- fColorEffectCnt = pipelineBuilder->numColorFragmentProcessors();
- fCoverageEffectCnt = pipelineBuilder->numCoverageFragmentProcessors();
+ fColorEffectCnt = pipelineBuilder->numColorFragmentStages();
+ fCoverageEffectCnt = pipelineBuilder->numCoverageFragmentStages();
SkDEBUGCODE(++pipelineBuilder->fBlockEffectRemovalCnt;)
fSaveMarker = pipelineBuilder->processorDataManager()->currentSaveMarker();
}
@@ -94,33 +106,25 @@ void GrPipelineBuilder::AutoRestoreFragmentProcessorState::set(
GrPipelineBuilder::~GrPipelineBuilder() {
SkASSERT(0 == fBlockEffectRemovalCnt);
- for (int i = 0; i < fColorFragmentProcessors.count(); ++i) {
- fColorFragmentProcessors[i]->unref();
- }
- for (int i = 0; i < fCoverageFragmentProcessors.count(); ++i) {
- fCoverageFragmentProcessors[i]->unref();
- }
}
////////////////////////////////////////////////////////////////////////////////
void GrPipelineBuilder::calcColorInvariantOutput(const GrPrimitiveProcessor* pp) const {
- fColorProcInfo.calcColorWithPrimProc(pp, fColorFragmentProcessors.begin(),
- this->numColorFragmentProcessors());
-
+ fColorProcInfo.calcColorWithPrimProc(pp, fColorStages.begin(), this->numColorFragmentStages());
}
void GrPipelineBuilder::calcCoverageInvariantOutput(const GrPrimitiveProcessor* pp) const {
- fCoverageProcInfo.calcCoverageWithPrimProc(pp, fCoverageFragmentProcessors.begin(),
- this->numCoverageFragmentProcessors());
+ fCoverageProcInfo.calcCoverageWithPrimProc(pp, fCoverageStages.begin(),
+ this->numCoverageFragmentStages());
}
void GrPipelineBuilder::calcColorInvariantOutput(const GrDrawBatch* batch) const {
- fColorProcInfo.calcColorWithBatch(batch, fColorFragmentProcessors.begin(),
- this->numColorFragmentProcessors());
+ fColorProcInfo.calcColorWithBatch(batch, fColorStages.begin(), this->numColorFragmentStages());
}
void GrPipelineBuilder::calcCoverageInvariantOutput(const GrDrawBatch* batch) const {
- fCoverageProcInfo.calcCoverageWithBatch(batch, fCoverageFragmentProcessors.begin(),
- this->numCoverageFragmentProcessors());
+ fCoverageProcInfo.calcCoverageWithBatch(batch, fCoverageStages.begin(),
+ this->numCoverageFragmentStages());
}
+
diff --git a/src/gpu/GrPipelineBuilder.h b/src/gpu/GrPipelineBuilder.h
index 47b996ad3d..1c6eb5f022 100644
--- a/src/gpu/GrPipelineBuilder.h
+++ b/src/gpu/GrPipelineBuilder.h
@@ -12,6 +12,7 @@
#include "GrCaps.h"
#include "GrClip.h"
#include "GrGpuResourceRef.h"
+#include "GrStagedProcessor.h"
#include "GrProcOptInfo.h"
#include "GrProcessorDataManager.h"
#include "GrRenderTarget.h"
@@ -28,10 +29,15 @@ class GrCaps;
class GrPaint;
class GrTexture;
-class GrPipelineBuilder : public SkNoncopyable {
+class GrPipelineBuilder {
public:
GrPipelineBuilder();
+ GrPipelineBuilder(const GrPipelineBuilder& pipelineBuilder) {
+ SkDEBUGCODE(fBlockEffectRemovalCnt = 0;)
+ *this = pipelineBuilder;
+ }
+
/**
* Initializes the GrPipelineBuilder based on a GrPaint, render target, and clip. Note
* that GrPipelineBuilder encompasses more than GrPaint. Aspects of GrPipelineBuilder that have
@@ -52,56 +58,51 @@ public:
/// feed their output to the GrXferProcessor which controls blending.
////
- int numColorFragmentProcessors() const { return fColorFragmentProcessors.count(); }
- int numCoverageFragmentProcessors() const { return fCoverageFragmentProcessors.count(); }
- int numFragmentProcessors() const { return this->numColorFragmentProcessors() +
- this->numCoverageFragmentProcessors(); }
+ int numColorFragmentStages() const { return fColorStages.count(); }
+ int numCoverageFragmentStages() const { return fCoverageStages.count(); }
+ int numFragmentStages() const { return this->numColorFragmentStages() +
+ this->numCoverageFragmentStages(); }
- const GrFragmentProcessor* getColorFragmentProcessor(int idx) const {
- return fColorFragmentProcessors[idx];
- }
- const GrFragmentProcessor* getCoverageFragmentProcessor(int idx) const {
- return fCoverageFragmentProcessors[idx];
- }
+ const GrFragmentStage& getColorFragmentStage(int idx) const { return fColorStages[idx]; }
+ const GrFragmentStage& getCoverageFragmentStage(int idx) const { return fCoverageStages[idx]; }
- const GrFragmentProcessor* addColorFragmentProcessor(const GrFragmentProcessor* processor) {
- SkASSERT(processor);
- fColorFragmentProcessors.push_back(SkRef(processor));
- return processor;
+ const GrFragmentProcessor* addColorProcessor(const GrFragmentProcessor* effect) {
+ SkASSERT(effect);
+ SkNEW_APPEND_TO_TARRAY(&fColorStages, GrFragmentStage, (effect));
+ return effect;
}
- const GrFragmentProcessor* addCoverageFragmentProcessor(const GrFragmentProcessor* processor) {
- SkASSERT(processor);
- fCoverageFragmentProcessors.push_back(SkRef(processor));
- return processor;
+ const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* effect) {
+ SkASSERT(effect);
+ SkNEW_APPEND_TO_TARRAY(&fCoverageStages, GrFragmentStage, (effect));
+ return effect;
}
/**
* Creates a GrSimpleTextureEffect that uses local coords as texture coordinates.
*/
void addColorTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
- this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
- matrix))->unref();
+ this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+ matrix))->unref();
}
void addCoverageTextureProcessor(GrTexture* texture, const SkMatrix& matrix) {
- this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
- matrix))->unref();
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
+ matrix))->unref();
}
void addColorTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- this->addColorFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
- matrix,
- params))->unref();
+ this->addColorProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
+ params))->unref();
}
void addCoverageTextureProcessor(GrTexture* texture,
const SkMatrix& matrix,
const GrTextureParams& params) {
- this->addCoverageFragmentProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture,
- matrix, params))->unref();
+ this->addCoverageProcessor(GrSimpleTextureEffect::Create(fProcDataManager, texture, matrix,
+ params))->unref();
}
/**
@@ -138,9 +139,9 @@ public:
return fPipelineBuilder->getProcessorDataManager();
}
- const GrFragmentProcessor* addCoverageFragmentProcessor(const GrFragmentProcessor* processor) {
+ const GrFragmentProcessor* addCoverageProcessor(const GrFragmentProcessor* processor) {
SkASSERT(this->isSet());
- return fPipelineBuilder->addCoverageFragmentProcessor(processor);
+ return fPipelineBuilder->addCoverageProcessor(processor);
}
private:
@@ -384,6 +385,8 @@ public:
///////////////////////////////////////////////////////////////////////////
+ GrPipelineBuilder& operator=(const GrPipelineBuilder& that);
+
// TODO delete when we have Batch
const GrProcOptInfo& colorProcInfo(const GrPrimitiveProcessor* pp) const {
this->calcColorInvariantOutput(pp);
@@ -436,7 +439,7 @@ private:
// This is used to assert that this condition holds.
SkDEBUGCODE(mutable int fBlockEffectRemovalCnt;)
- typedef SkSTArray<4, const GrFragmentProcessor*, true> FragmentProcessorArray;
+ typedef SkSTArray<4, GrFragmentStage> FragmentStageArray;
SkAutoTUnref<GrProcessorDataManager> fProcDataManager;
SkAutoTUnref<GrRenderTarget> fRenderTarget;
@@ -444,8 +447,8 @@ private:
GrStencilSettings fStencilSettings;
DrawFace fDrawFace;
mutable SkAutoTUnref<const GrXPFactory> fXPFactory;
- FragmentProcessorArray fColorFragmentProcessors;
- FragmentProcessorArray fCoverageFragmentProcessors;
+ FragmentStageArray fColorStages;
+ FragmentStageArray fCoverageStages;
GrClip fClip;
mutable GrProcOptInfo fColorProcInfo;
diff --git a/src/gpu/GrProcOptInfo.cpp b/src/gpu/GrProcOptInfo.cpp
index 19302cc475..af6b81e0d6 100644
--- a/src/gpu/GrProcOptInfo.cpp
+++ b/src/gpu/GrProcOptInfo.cpp
@@ -12,43 +12,43 @@
#include "batches/GrDrawBatch.h"
void GrProcOptInfo::calcColorWithBatch(const GrDrawBatch* batch,
- const GrFragmentProcessor* const processors[],
- int cnt) {
+ const GrFragmentStage* stages,
+ int stageCount) {
GrInitInvariantOutput out;
batch->getInvariantOutputColor(&out);
fInOut.reset(out);
- this->internalCalc(processors, cnt, batch->willReadFragmentPosition());
+ this->internalCalc(stages, stageCount, batch->willReadFragmentPosition());
}
void GrProcOptInfo::calcCoverageWithBatch(const GrDrawBatch* batch,
- const GrFragmentProcessor* const processors[],
- int cnt) {
+ const GrFragmentStage* stages,
+ int stageCount) {
GrInitInvariantOutput out;
batch->getInvariantOutputCoverage(&out);
fInOut.reset(out);
- this->internalCalc(processors, cnt, batch->willReadFragmentPosition());
+ this->internalCalc(stages, stageCount, batch->willReadFragmentPosition());
}
void GrProcOptInfo::calcColorWithPrimProc(const GrPrimitiveProcessor* primProc,
- const GrFragmentProcessor * const processors[],
- int cnt) {
+ const GrFragmentStage* stages,
+ int stageCount) {
GrInitInvariantOutput out;
primProc->getInvariantOutputColor(&out);
fInOut.reset(out);
- this->internalCalc(processors, cnt, primProc->willReadFragmentPosition());
+ this->internalCalc(stages, stageCount, primProc->willReadFragmentPosition());
}
void GrProcOptInfo::calcCoverageWithPrimProc(const GrPrimitiveProcessor* primProc,
- const GrFragmentProcessor * const processors[],
- int cnt) {
+ const GrFragmentStage* stages,
+ int stageCount) {
GrInitInvariantOutput out;
primProc->getInvariantOutputCoverage(&out);
fInOut.reset(out);
- this->internalCalc(processors, cnt, primProc->willReadFragmentPosition());
+ this->internalCalc(stages, stageCount, primProc->willReadFragmentPosition());
}
-void GrProcOptInfo::calcWithInitialValues(const GrFragmentProcessor * const processors[],
- int cnt,
+void GrProcOptInfo::calcWithInitialValues(const GrFragmentStage* stages,
+ int stageCount,
GrColor startColor,
GrColorComponentFlags flags,
bool areCoverageStages) {
@@ -57,24 +57,24 @@ void GrProcOptInfo::calcWithInitialValues(const GrFragmentProcessor * const proc
out.fColor = startColor;
out.fValidFlags = flags;
fInOut.reset(out);
- this->internalCalc(processors, cnt, false);
+ this->internalCalc(stages, stageCount, false);
}
-void GrProcOptInfo::internalCalc(const GrFragmentProcessor* const processors[],
- int cnt,
+void GrProcOptInfo::internalCalc(const GrFragmentStage* stages,
+ int stageCount,
bool initWillReadFragmentPosition) {
- fFirstEffectiveProcessorIndex = 0;
+ fFirstEffectStageIndex = 0;
fInputColorIsUsed = true;
fInputColor = fInOut.color();
fReadsFragPosition = initWillReadFragmentPosition;
- for (int i = 0; i < cnt; ++i) {
- const GrFragmentProcessor* processor = processors[i];
+ for (int i = 0; i < stageCount; ++i) {
+ const GrFragmentProcessor* processor = stages[i].processor();
fInOut.resetWillUseInputColor();
processor->computeInvariantOutput(&fInOut);
SkDEBUGCODE(fInOut.validate());
if (!fInOut.willUseInputColor()) {
- fFirstEffectiveProcessorIndex = i;
+ fFirstEffectStageIndex = i;
fInputColorIsUsed = false;
// Reset these since we don't care if previous stages read these values
fReadsFragPosition = initWillReadFragmentPosition;
@@ -83,7 +83,7 @@ void GrProcOptInfo::internalCalc(const GrFragmentProcessor* const processors[],
fReadsFragPosition = true;
}
if (kRGBA_GrColorComponentFlags == fInOut.validFlags()) {
- fFirstEffectiveProcessorIndex = i + 1;
+ fFirstEffectStageIndex = i + 1;
fInputColor = fInOut.color();
fInputColorIsUsed = true;
// Since we are clearing all previous color stages we are in a state where we have found
diff --git a/src/gpu/GrProcOptInfo.h b/src/gpu/GrProcOptInfo.h
index ad23614d81..cf7e3503b9 100644
--- a/src/gpu/GrProcOptInfo.h
+++ b/src/gpu/GrProcOptInfo.h
@@ -10,6 +10,7 @@
#include "GrColor.h"
#include "GrInvariantOutput.h"
+#include "GrStagedProcessor.h"
class GrDrawBatch;
class GrFragmentProcessor;
@@ -25,22 +26,21 @@ class GrProcOptInfo {
public:
GrProcOptInfo()
: fInOut(0, static_cast<GrColorComponentFlags>(0), false)
- , fFirstEffectiveProcessorIndex(0)
+ , fFirstEffectStageIndex(0)
, fInputColorIsUsed(true)
, fInputColor(0)
, fReadsFragPosition(false) {}
- void calcWithInitialValues(const GrFragmentProcessor* const *, int cnt, GrColor startColor,
- GrColorComponentFlags, bool areCoverageStages);
+ void calcWithInitialValues(const GrFragmentStage*, int stageCount, GrColor startColor,
+ GrColorComponentFlags flags, bool areCoverageStages);
- void calcColorWithBatch(const GrDrawBatch*, const GrFragmentProcessor* const[], int cnt);
- void calcCoverageWithBatch(const GrDrawBatch*, const GrFragmentProcessor* const[], int cnt);
+ void calcColorWithBatch(const GrDrawBatch*, const GrFragmentStage*, int stagecount);
+ void calcCoverageWithBatch(const GrDrawBatch*, const GrFragmentStage*, int stagecount);
// TODO delete these when batch is everywhere
- void calcColorWithPrimProc(const GrPrimitiveProcessor*, const GrFragmentProcessor* const[],
- int cnt);
- void calcCoverageWithPrimProc(const GrPrimitiveProcessor*, const GrFragmentProcessor* const[],
- int cnt);
+ void calcColorWithPrimProc(const GrPrimitiveProcessor*, const GrFragmentStage*, int stagecount);
+ void calcCoverageWithPrimProc(const GrPrimitiveProcessor*, const GrFragmentStage*,
+ int stagecount);
bool isSolidWhite() const { return fInOut.isSolidWhite(); }
bool isOpaque() const { return fInOut.isOpaque(); }
@@ -60,38 +60,38 @@ public:
}
/**
- * Returns the index of the first effective color processor. If an intermediate processor
- * doesn't read its input or has a known output, then we can ignore all earlier processors
- * since they will not affect the final output. Thus the first effective processors index is
- * the index to the first processor that will have an effect on the final output.
+ * Returns the index of the first effective color stage. If an intermediate stage doesn't read
+ * its input or has a known output, then we can ignore all earlier stages since they will not
+ * affect the final output. Thus the first effective stage index is the index to the first stage
+ * that will have an effect on the final output.
*
- * If processors before the firstEffectiveProcessorIndex() are removed, corresponding values
- * from inputColorIsUsed(), inputColorToEffectiveProcessor(), removeVertexAttribs(), and
- * readsDst() must be used when setting up the draw to ensure correct drawing.
+ * If stages before the firstEffectiveStageIndex are removed, corresponding values from
+ * inputColorIsUsed(), inputColorToEffectiveStage(), removeVertexAttribs(), and readsDst() must
+ * be used when setting up the draw to ensure correct drawing.
*/
- int firstEffectiveProcessorIndex() const { return fFirstEffectiveProcessorIndex; }
+ int firstEffectiveStageIndex() const { return fFirstEffectStageIndex; }
/**
- * True if the first effective processor reads its input, false otherwise.
+ * True if the first effective stage 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.
+ * first effective stage.
*/
- GrColor inputColorToFirstEffectiveProccesor() const { return fInputColor; }
+ GrColor inputColorToEffectiveStage() const { return fInputColor; }
/**
- * Returns true if any of the processor preserved by GrProcOptInfo read the frag position.
+ * Returns true if any of the stages preserved by GrProcOptInfo read the frag position.
*/
bool readsFragPosition() const { return fReadsFragPosition; }
private:
- void internalCalc(const GrFragmentProcessor* const[], int cnt, bool initWillReadFragPosition);
+ void internalCalc(const GrFragmentStage*, int stagecount, bool initWillReadFragPosition);
GrInvariantOutput fInOut;
- int fFirstEffectiveProcessorIndex;
+ int fFirstEffectStageIndex;
bool fInputColorIsUsed;
GrColor fInputColor;
bool fReadsFragPosition;
diff --git a/src/gpu/GrProcessor.cpp b/src/gpu/GrProcessor.cpp
index 3cbf777253..db1e2d9f61 100644
--- a/src/gpu/GrProcessor.cpp
+++ b/src/gpu/GrProcessor.cpp
@@ -130,12 +130,6 @@ bool GrProcessor::hasSameTextureAccesses(const GrProcessor& that) const {
///////////////////////////////////////////////////////////////////////////////////////////////////
-GrFragmentProcessor::~GrFragmentProcessor() {
- for (int i = 0; i < fChildProcessors.count(); ++i) {
- fChildProcessors[i]->unref();
- }
-}
-
bool GrFragmentProcessor::isEqual(const GrFragmentProcessor& that,
bool ignoreCoordTransforms) const {
if (this->classID() != that.classID() ||
@@ -167,7 +161,7 @@ GrGLFragmentProcessor* GrFragmentProcessor::createGLInstance() const {
GrGLFragmentProcessor* glFragProc = this->onCreateGLInstance();
glFragProc->fChildProcessors.push_back_n(fChildProcessors.count());
for (int i = 0; i < fChildProcessors.count(); ++i) {
- glFragProc->fChildProcessors[i] = fChildProcessors[i]->createGLInstance();
+ glFragProc->fChildProcessors[i] = fChildProcessors[i].processor()->createGLInstance();
}
return glFragProc;
}
@@ -205,7 +199,7 @@ int GrFragmentProcessor::registerChildProcessor(const GrFragmentProcessor* child
}
int index = fChildProcessors.count();
- fChildProcessors.push_back(SkRef(child));
+ fChildProcessors.push_back(GrFragmentStage(child));
if (child->willReadFragmentPosition()) {
this->setWillReadFragmentPosition();
diff --git a/src/gpu/GrSWMaskHelper.cpp b/src/gpu/GrSWMaskHelper.cpp
index ce00ad93e3..f421b81f7d 100644
--- a/src/gpu/GrSWMaskHelper.cpp
+++ b/src/gpu/GrSWMaskHelper.cpp
@@ -366,7 +366,7 @@ void GrSWMaskHelper::DrawToTargetWithPathMask(GrTexture* texture,
maskMatrix.setIDiv(texture->width(), texture->height());
maskMatrix.preTranslate(SkIntToScalar(-rect.fLeft), SkIntToScalar(-rect.fTop));
- pipelineBuilder->addCoverageFragmentProcessor(
+ pipelineBuilder->addCoverageProcessor(
GrSimpleTextureEffect::Create(pipelineBuilder->getProcessorDataManager(),
texture,
maskMatrix,
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index cb2221c924..23151d4833 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -963,7 +963,7 @@ static void draw_aa_bitmap(GrDrawContext* drawContext, GrContext* context,
}
// The bitmap read has to be first
- grPaint.addColorFragmentProcessor(fp);
+ grPaint.addColorProcessor(fp);
if (!SkPaint2GrPaintNoShader(context, renderTarget, paint, SkColor2GrColor(paint.getColor()),
false, &grPaint)) {
return;
@@ -1305,7 +1305,7 @@ void SkGpuDevice::internalDrawBitmap(const SkBitmap& bitmap,
SkMatrix::I(), params));
}
- grPaint.addColorFragmentProcessor(fp);
+ grPaint.addColorProcessor(fp);
bool alphaOnly = !(kAlpha_8_SkColorType == bitmap.colorType());
GrColor paintColor = (alphaOnly) ? SkColor2GrColorJustAlpha(paint.getColor()) :
SkColor2GrColor(paint.getColor());
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index 0c29dd8894..6c1ec4bed0 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -469,7 +469,7 @@ static GrTexture* load_yuv_texture(GrContext* ctx, const GrUniqueKey& optionalKe
yuvToRgbProcessor(GrYUVtoRGBEffect::Create(paint.getProcessorDataManager(), yuvTextures[0],
yuvTextures[1], yuvTextures[2],
yuvInfo.fSize, yuvInfo.fColorSpace));
- paint.addColorFragmentProcessor(yuvToRgbProcessor);
+ paint.addColorProcessor(yuvToRgbProcessor);
SkRect r = SkRect::MakeWH(SkIntToScalar(yuvInfo.fSize[0].fWidth),
SkIntToScalar(yuvInfo.fSize[0].fHeight));
@@ -810,7 +810,7 @@ bool SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget* rt, const SkPai
if (colorFilter->asFragmentProcessors(context, grPaint->getProcessorDataManager(),
&array)) {
for (int i = 0; i < array.count(); ++i) {
- grPaint->addColorFragmentProcessor(array[i]);
+ grPaint->addColorProcessor(array[i]);
array[i]->unref();
}
}
@@ -820,7 +820,7 @@ bool SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget* rt, const SkPai
#ifndef SK_IGNORE_GPU_DITHER
// If the dither flag is set, then we need to see if the underlying context
// supports it. If not, then install a dither effect.
- if (skPaint.isDither() && grPaint->numColorFragmentProcessors() > 0) {
+ if (skPaint.isDither() && grPaint->numColorStages() > 0) {
// What are we rendering into?
SkASSERT(rt);
@@ -832,7 +832,7 @@ bool SkPaint2GrPaintNoShader(GrContext* context, GrRenderTarget* rt, const SkPai
// not going to be dithered by the GPU.
SkAutoTUnref<GrFragmentProcessor> fp(GrDitherEffect::Create());
if (fp.get()) {
- grPaint->addColorFragmentProcessor(fp);
+ grPaint->addColorProcessor(fp);
grPaint->setDither(false);
}
}
@@ -863,7 +863,7 @@ bool SkPaint2GrPaint(GrContext* context, GrRenderTarget* rt, const SkPaint& skPa
return false;
}
if (fp) {
- grPaint->addColorFragmentProcessor(fp)->unref();
+ grPaint->addColorProcessor(fp)->unref();
constantColor = false;
}
}
diff --git a/src/gpu/batches/GrDrawBatch.h b/src/gpu/batches/GrDrawBatch.h
index f7c206d124..ed33816603 100644
--- a/src/gpu/batches/GrDrawBatch.h
+++ b/src/gpu/batches/GrDrawBatch.h
@@ -64,12 +64,12 @@ public:
SkString dumpInfo() const override {
SkString string;
string.append("ColorStages:\n");
- for (int i = 0; i < this->pipeline()->numColorFragmentProcessors(); i++) {
- string.appendf("\t\t%s\n", this->pipeline()->getColorFragmentProcessor(i).name());
+ for (int i = 0; i < this->pipeline()->numColorFragmentStages(); i++) {
+ string.appendf("\t\t%s\n", this->pipeline()->getColorStage(i).processor()->name());
}
string.append("CoverageStages:\n");
- for (int i = 0; i < this->pipeline()->numCoverageFragmentProcessors(); i++) {
- string.appendf("\t%s\n", this->pipeline()->getCoverageFragmentProcessor(i).name());
+ for (int i = 0; i < this->pipeline()->numCoverageFragmentStages(); i++) {
+ string.appendf("\t%s\n", this->pipeline()->getCoverageStage(i).processor()->name());
}
string.appendf("XP: %s\n", this->pipeline()->getXferProcessor()->name());
return string;
diff --git a/src/gpu/effects/GrConfigConversionEffect.cpp b/src/gpu/effects/GrConfigConversionEffect.cpp
index 2581510218..4c8813d415 100644
--- a/src/gpu/effects/GrConfigConversionEffect.cpp
+++ b/src/gpu/effects/GrConfigConversionEffect.cpp
@@ -232,7 +232,7 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
(paint3.getProcessorDataManager(), tempTex, false, *pmToUPMRule,
SkMatrix::I())));
- paint1.addColorFragmentProcessor(pmToUPM1);
+ paint1.addColorProcessor(pmToUPM1);
GrDrawContext* readDrawContext = context->drawContext();
@@ -250,7 +250,7 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
readTex->readPixels(0, 0, 256, 256, kRGBA_8888_GrPixelConfig, firstRead);
- paint2.addColorFragmentProcessor(upmToPM);
+ paint2.addColorProcessor(upmToPM);
GrDrawContext* tempDrawContext = context->drawContext();
if (!tempDrawContext) {
@@ -264,7 +264,7 @@ void GrConfigConversionEffect::TestForPreservingPMConversions(GrContext* context
kDstRect,
kSrcRect);
- paint3.addColorFragmentProcessor(pmToUPM2);
+ paint3.addColorProcessor(pmToUPM2);
readDrawContext = context->drawContext();
if (!readDrawContext) {
diff --git a/src/gpu/gl/GrGLPathProgram.cpp b/src/gpu/gl/GrGLPathProgram.cpp
index 5bcadfe4d0..4b31f02dac 100644
--- a/src/gpu/gl/GrGLPathProgram.cpp
+++ b/src/gpu/gl/GrGLPathProgram.cpp
@@ -31,13 +31,13 @@ void GrGLPathProgram::didSetData() {
}
void GrGLPathProgram::setTransformData(const GrPrimitiveProcessor& primProc,
- const GrFragmentProcessor& processor,
+ const GrPendingFragmentStage& proc,
int index,
GrGLInstalledFragProc* ip) {
GrGLPathProcessor* pathProc =
static_cast<GrGLPathProcessor*>(fGeometryProcessor.get()->fGLProc.get());
pathProc->setTransformData(primProc, fPathProgramDataManager, index,
- processor.coordTransforms());
+ proc.processor()->coordTransforms());
}
void GrGLPathProgram::onSetRenderTargetState(const GrPrimitiveProcessor& primProc,
diff --git a/src/gpu/gl/GrGLPathProgram.h b/src/gpu/gl/GrGLPathProgram.h
index 74f43e56df..c7ca3dc226 100644
--- a/src/gpu/gl/GrGLPathProgram.h
+++ b/src/gpu/gl/GrGLPathProgram.h
@@ -34,7 +34,7 @@ protected:
private:
void didSetData() override;
virtual void setTransformData(const GrPrimitiveProcessor&,
- const GrFragmentProcessor&,
+ const GrPendingFragmentStage&,
int index,
GrGLInstalledFragProc*) override;
void onSetRenderTargetState(const GrPrimitiveProcessor&, const GrPipeline&) override;
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index 3aaa7ea8ce..5af84e0c13 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -105,24 +105,25 @@ void GrGLProgram::setFragmentData(const GrPrimitiveProcessor& primProc,
const GrPipeline& pipeline,
SkTArray<const GrTextureAccess*>* textureBindings) {
int numProcessors = fFragmentProcessors->fProcs.count();
- for (int i = 0; i < numProcessors; ++i) {
- const GrFragmentProcessor& processor = pipeline.getFragmentProcessor(i);
- fFragmentProcessors->fProcs[i]->fGLProc->setData(fProgramDataManager, processor);
+ for (int e = 0; e < numProcessors; ++e) {
+ const GrPendingFragmentStage& stage = pipeline.getFragmentStage(e);
+ const GrFragmentProcessor& processor = *stage.processor();
+ fFragmentProcessors->fProcs[e]->fGLProc->setData(fProgramDataManager, processor);
this->setTransformData(primProc,
- processor,
- i,
- fFragmentProcessors->fProcs[i]);
- append_texture_bindings(fFragmentProcessors->fProcs[i], processor, textureBindings);
+ stage,
+ e,
+ fFragmentProcessors->fProcs[e]);
+ append_texture_bindings(fFragmentProcessors->fProcs[e], processor, textureBindings);
}
}
void GrGLProgram::setTransformData(const GrPrimitiveProcessor& primProc,
- const GrFragmentProcessor& processor,
+ const GrPendingFragmentStage& processor,
int index,
GrGLInstalledFragProc* ip) {
GrGLGeometryProcessor* gp =
static_cast<GrGLGeometryProcessor*>(fGeometryProcessor.get()->fGLProc.get());
gp->setTransformData(primProc, fProgramDataManager, index,
- processor.coordTransforms());
+ processor.processor()->coordTransforms());
}
void GrGLProgram::setRenderTargetState(const GrPrimitiveProcessor& primProc,
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index fee6277ed8..c8fa1b1fec 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -115,7 +115,7 @@ protected:
void setFragmentData(const GrPrimitiveProcessor&, const GrPipeline&,
SkTArray<const GrTextureAccess*>* textureBindings);
virtual void setTransformData(const GrPrimitiveProcessor&,
- const GrFragmentProcessor&,
+ const GrPendingFragmentStage&,
int index,
GrGLInstalledFragProc*);
diff --git a/src/gpu/gl/GrGLProgramDesc.cpp b/src/gpu/gl/GrGLProgramDesc.cpp
index 6b38cc6d93..5365ffbf04 100644
--- a/src/gpu/gl/GrGLProgramDesc.cpp
+++ b/src/gpu/gl/GrGLProgramDesc.cpp
@@ -134,8 +134,9 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc,
return false;
}
- for (int i = 0; i < pipeline.numFragmentProcessors(); ++i) {
- const GrFragmentProcessor& fp = pipeline.getFragmentProcessor(i);
+ for (int s = 0; s < pipeline.numFragmentStages(); ++s) {
+ const GrPendingFragmentStage& fps = pipeline.getFragmentStage(s);
+ const GrFragmentProcessor& fp = *fps.processor();
if (!get_frag_proc_and_meta_keys(primProc, fp, gpu->glCaps(), &b)) {
glDesc->key().reset();
return false;
@@ -166,8 +167,8 @@ bool GrGLProgramDescBuilder::Build(GrProgramDesc* desc,
header->fFragPosKey = 0;
}
header->fSnapVerticesToPixelCenters = pipeline.snapVerticesToPixelCenters();
- header->fColorEffectCnt = pipeline.numColorFragmentProcessors();
- header->fCoverageEffectCnt = pipeline.numCoverageFragmentProcessors();
+ header->fColorEffectCnt = pipeline.numColorFragmentStages();
+ header->fCoverageEffectCnt = pipeline.numCoverageFragmentStages();
glDesc->finalize();
return true;
}
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index 547bd381d8..2db568693d 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -186,15 +186,15 @@ bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr
int totalTextures = primProc.numTextures();
const int maxTextureUnits = fGpu->glCaps().maxFragmentTextureUnits();
- for (int i = 0; i < this->pipeline().numFragmentProcessors(); i++) {
- const GrFragmentProcessor& processor = this->pipeline().getFragmentProcessor(i);
+ for (int i = 0; i < this->pipeline().numFragmentStages(); i++) {
+ const GrFragmentProcessor* processor = this->pipeline().getFragmentStage(i).processor();
if (!primProc.hasTransformedLocalCoords()) {
- SkTArray<const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
- processor.gatherCoordTransforms(&procCoords);
+ SkSTArray<2, const GrCoordTransform*, true>& procCoords = fCoordTransforms.push_back();
+ processor->gatherCoordTransforms(&procCoords);
}
- totalTextures += processor.numTextures();
+ totalTextures += processor->numTextures();
if (totalTextures >= maxTextureUnits) {
GrCapsDebugf(fGpu->caps(), "Program would use too many texture units\n");
return false;
@@ -204,9 +204,9 @@ bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr
this->emitAndInstallProc(primProc, inputColor, inputCoverage);
fFragmentProcessors.reset(SkNEW(GrGLInstalledFragProcs));
- int numProcs = this->pipeline().numFragmentProcessors();
- this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentProcessors(), inputColor);
- this->emitAndInstallFragProcs(this->pipeline().numColorFragmentProcessors(), numProcs,
+ int numProcs = this->pipeline().numFragmentStages();
+ this->emitAndInstallFragProcs(0, this->pipeline().numColorFragmentStages(), inputColor);
+ this->emitAndInstallFragProcs(this->pipeline().numColorFragmentStages(), numProcs,
inputCoverage);
this->emitAndInstallXferProc(*this->pipeline().getXferProcessor(), *inputColor, *inputCoverage);
return true;
@@ -215,10 +215,10 @@ bool GrGLProgramBuilder::emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr
void GrGLProgramBuilder::emitAndInstallFragProcs(int procOffset,
int numProcs,
GrGLSLExpr4* inOut) {
- for (int i = procOffset; i < numProcs; ++i) {
+ for (int e = procOffset; e < numProcs; ++e) {
GrGLSLExpr4 output;
- const GrFragmentProcessor& fp = this->pipeline().getFragmentProcessor(i);
- this->emitAndInstallProc(fp, i, *inOut, &output);
+ const GrPendingFragmentStage& stage = this->pipeline().getFragmentStage(e);
+ this->emitAndInstallProc(stage, e, *inOut, &output);
*inOut = output;
}
}
@@ -239,7 +239,7 @@ void GrGLProgramBuilder::nameExpression(GrGLSLExpr4* output, const char* baseNam
// TODO Processors cannot output zeros because an empty string is all 1s
// the fix is to allow effects to take the GrGLSLExpr4 directly
-void GrGLProgramBuilder::emitAndInstallProc(const GrFragmentProcessor& fp,
+void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& proc,
int index,
const GrGLSLExpr4& input,
GrGLSLExpr4* output) {
@@ -249,10 +249,10 @@ void GrGLProgramBuilder::emitAndInstallProc(const GrFragmentProcessor& fp,
// Enclose custom code in a block to avoid namespace conflicts
SkString openBrace;
- openBrace.printf("{ // Stage %d, %s\n", fStageIndex, fp.name());
+ openBrace.printf("{ // Stage %d, %s\n", fStageIndex, proc.name());
fFS.codeAppend(openBrace.c_str());
- this->emitAndInstallProc(fp, index, output->c_str(), input.isOnes() ? NULL : input.c_str());
+ this->emitAndInstallProc(proc, index, output->c_str(), input.isOnes() ? NULL : input.c_str());
fFS.codeAppend("}");
}
@@ -276,12 +276,13 @@ void GrGLProgramBuilder::emitAndInstallProc(const GrPrimitiveProcessor& proc,
fFS.codeAppend("}");
}
-void GrGLProgramBuilder::emitAndInstallProc(const GrFragmentProcessor& fp,
+void GrGLProgramBuilder::emitAndInstallProc(const GrPendingFragmentStage& fs,
int index,
const char* outColor,
const char* inColor) {
GrGLInstalledFragProc* ifp = SkNEW(GrGLInstalledFragProc);
+ const GrFragmentProcessor& fp = *fs.processor();
ifp->fGLProc.reset(fp.createGLInstance());
SkSTArray<4, GrGLProcessor::TextureSampler> samplers(fp.numTextures());
@@ -500,7 +501,7 @@ GrGLProgram* GrGLProgramBuilder::createProgram(GrGLuint programID) {
GrGLInstalledFragProcs::~GrGLInstalledFragProcs() {
int numProcs = fProcs.count();
- for (int i = 0; i < numProcs; ++i) {
- SkDELETE(fProcs[i]);
+ for (int e = 0; e < numProcs; ++e) {
+ SkDELETE(fProcs[e]);
}
}
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.h b/src/gpu/gl/builders/GrGLProgramBuilder.h
index 06d0fa0744..bdd96d212e 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.h
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.h
@@ -16,10 +16,9 @@
#include "../GrGLUniformHandle.h"
#include "../GrGLPrimitiveProcessor.h"
#include "../GrGLXferProcessor.h"
+#include "../../GrPendingFragmentStage.h"
#include "../../GrPipeline.h"
-class GrFragmentProcessor;
-
// Enough precision to represent 1 / 2048 accurately in printf
#define GR_SIGNIFICANT_POW2_DECIMAL_DIG 11
@@ -302,7 +301,7 @@ protected:
void nameExpression(GrGLSLExpr4*, const char* baseName);
bool emitAndInstallProcs(GrGLSLExpr4* inputColor, GrGLSLExpr4* inputCoverage);
void emitAndInstallFragProcs(int procOffset, int numProcs, GrGLSLExpr4* inOut);
- void emitAndInstallProc(const GrFragmentProcessor&,
+ void emitAndInstallProc(const GrPendingFragmentStage&,
int index,
const GrGLSLExpr4& input,
GrGLSLExpr4* output);
@@ -312,7 +311,7 @@ protected:
GrGLSLExpr4* outputCoverage);
// these emit functions help to keep the createAndEmitProcessors template general
- void emitAndInstallProc(const GrFragmentProcessor&,
+ void emitAndInstallProc(const GrPendingFragmentStage&,
int index,
const char* outColor,
const char* inColor);
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index a6edd98813..d172df829e 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -250,9 +250,8 @@ SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorS
GrPaint paint;
paint.setPorterDuffXPFactory(SkXfermode::kSrc_Mode);
- paint.addColorFragmentProcessor(GrYUVtoRGBEffect::Create(paint.getProcessorDataManager(),
- yTex, uTex, vTex, yuvSizes,
- colorSpace))->unref();
+ paint.addColorProcessor(GrYUVtoRGBEffect::Create(paint.getProcessorDataManager(), yTex, uTex,
+ vTex, yuvSizes, colorSpace))->unref();
const SkRect rect = SkRect::MakeWH(SkIntToScalar(dstDesc.fWidth),
SkIntToScalar(dstDesc.fHeight));
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-08 06:32:06 +0000