AuroraMiddleware/skia2
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Revert of Test that GrFragmentProcessors work without input colors. (patchset #2 id:20001 of https://codereview.chromium.org/1341853002/ )

Browse Source 
Reason for revert:
Need to fix up more processor subclasses.

Original issue's description:
> Test that GrFragmentProcessors work without input colors.
>
> Committed: https://skia.googlesource.com/skia/+/72c58e7052af2a0855412ce4b249f977069db751

TBR=joshualitt@google.com
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true

Review URL: https://codereview.chromium.org/1338403003
This commit is contained in:
bsalomon 2015-09-14 12:01:42 -07:00 committed by Commit bot
parent 72c58e7052
commit 59ce45fe79
4 changed files with 17 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
include/gpu/GrProcessorUnitTest.h
View File

@ -68,19 +68,10 @@ public:
GetFactories()->push_back(this);
}
/** Pick a random factory function and create a processor. */
static const Processor* Create(GrProcessorTestData* data) {
static const Processor* CreateStage(GrProcessorTestData* data) {
VerifyFactoryCount();
SkASSERT(GetFactories()->count());
uint32_t idx = data->fRandom->nextRangeU(0, GetFactories()->count() - 1);
return CreateIdx(idx, data);
}
/** Number of registered factory functions */
static int Count() { return GetFactories()->count(); }
/** Use factory function at Index idx to create a processor. */
static const Processor* CreateIdx(int idx, GrProcessorTestData* data) {
GrProcessorTestFactory<Processor>* factory = (*GetFactories())[idx];
return factory->fCreateProc(data);
}

10
src/gpu/effects/GrExtractAlphaFragmentProcessor.cpp
View File

@ -14,13 +14,9 @@ public:
GLExtractAlphaFragmentProcessor() {}
void emitCode(EmitArgs& args) override {
if (args.fInputColor) {
GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
fsBuilder->codeAppendf("vec4 alpha4 = %s.aaaa;", args.fInputColor);
this->emitChild(0, "alpha4", args.fOutputColor, args);
} else {
this->emitChild(0, nullptr, args.fOutputColor, args);
}
GrGLFragmentBuilder* fsBuilder = args.fBuilder->getFragmentShaderBuilder();
fsBuilder->codeAppendf("vec4 alpha4 = %s.aaaa;", args.fInputColor);
this->emitChild(0, "alpha4", args.fOutputColor, args);
}
private:

25
src/gpu/effects/GrXfermodeFragmentProcessor.cpp
View File

@ -78,12 +78,12 @@ const GrFragmentProcessor* GrComposeTwoFragmentProcessor::TestCreate(GrProcessor
// possibility of an arbitrarily large tree of procs.
SkAutoTUnref<const GrFragmentProcessor> fpA;
do {
fpA.reset(GrProcessorTestFactory<GrFragmentProcessor>::Create(d));
fpA.reset(GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
SkASSERT(fpA);
} while (fpA->numChildProcessors() != 0);
SkAutoTUnref<const GrFragmentProcessor> fpB;
do {
fpB.reset(GrProcessorTestFactory<GrFragmentProcessor>::Create(d));
fpB.reset(GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
SkASSERT(fpB);
} while (fpB->numChildProcessors() != 0);
@ -112,26 +112,20 @@ void GrGLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
// This is because we don't want the paint's alpha to affect either child proc's output
// before the blend; we want to apply the paint's alpha AFTER the blend. This mirrors the
// software implementation of SkComposeShader.
const char* opaqueInput = nullptr;
const char* inputAlpha = nullptr;
if (args.fInputColor) {
inputAlpha = "inputAlpha";
opaqueInput = "opaqueInput";
fsBuilder->codeAppendf("float inputAlpha = %s.a;", args.fInputColor);
fsBuilder->codeAppendf("vec4 opaqueInput = vec4(%s.rgb / inputAlpha, 1);",
args.fInputColor);
}
SkString inputAlpha("inputAlpha");
fsBuilder->codeAppendf("float %s = %s.a;", inputAlpha.c_str(), args.fInputColor);
fsBuilder->codeAppendf("%s /= %s.a;", args.fInputColor, args.fInputColor);
// declare outputColor and emit the code for each of the two children
SkString outputColorSrc(args.fOutputColor);
outputColorSrc.append("_src");
fsBuilder->codeAppendf("vec4 %s;\n", outputColorSrc.c_str());
this->emitChild(0, opaqueInput, outputColorSrc.c_str(), args);
this->emitChild(0, args.fInputColor, outputColorSrc.c_str(), args);
SkString outputColorDst(args.fOutputColor);
outputColorDst.append("_dst");
fsBuilder->codeAppendf("vec4 %s;\n", outputColorDst.c_str());
this->emitChild(1, opaqueInput, outputColorDst.c_str(), args);
this->emitChild(1, args.fInputColor, outputColorDst.c_str(), args);
// emit blend code
SkXfermode::Mode mode = cs.getMode();
@ -142,11 +136,10 @@ void GrGLComposeTwoFragmentProcessor::emitCode(EmitArgs& args) {
fsBuilder->codeAppend("}");
// re-multiply the output color by the input color's alpha
if (inputAlpha) {
fsBuilder->codeAppendf("%s *= %s;", args.fOutputColor, inputAlpha);
}
fsBuilder->codeAppendf("%s *= %s;", args.fOutputColor, inputAlpha.c_str());
}
const GrFragmentProcessor* GrXfermodeFragmentProcessor::CreateFromTwoProcessors(
const GrFragmentProcessor* src, const GrFragmentProcessor* dst, SkXfermode::Mode mode) {
if (SkXfermode::kLastCoeffMode < mode) {

84
tests/GLProgramsTest.cpp
View File

@ -95,49 +95,6 @@ const GrFragmentProcessor* BigKeyProcessor::TestCreate(GrProcessorTestData*) {
return BigKeyProcessor::Create();
}
//////////////////////////////////////////////////////////////////////////////
class BlockInputFragmentProcessor : public GrFragmentProcessor {
public:
static GrFragmentProcessor* Create(const GrFragmentProcessor* fp) {
return new BlockInputFragmentProcessor(fp);
}
const char* name() const override { return "Block Input"; }
GrGLFragmentProcessor* onCreateGLInstance() const override { return new GLFP; }
private:
class GLFP : public GrGLFragmentProcessor {
public:
void emitCode(EmitArgs& args) override {
this->emitChild(0, nullptr, args.fOutputColor, args);
}
private:
typedef GrGLFragmentProcessor INHERITED;
};
BlockInputFragmentProcessor(const GrFragmentProcessor* child) {
this->initClassID<BlockInputFragmentProcessor>();
this->registerChildProcessor(child);
}
void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override {}
bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
inout->setToOther(kRGBA_GrColorComponentFlags, GrColor_WHITE,
GrInvariantOutput::kWillNot_ReadInput);
this->childProcessor(0).computeInvariantOutput(inout);
}
typedef GrFragmentProcessor INHERITED;
};
//////////////////////////////////////////////////////////////////////////////
/*
* Begin test code
*/
@ -175,7 +132,7 @@ static GrRenderTarget* random_render_target(GrTextureProvider* textureProvider,
}
static void set_random_xpf(GrPipelineBuilder* pipelineBuilder, GrProcessorTestData* d) {
SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::Create(d));
SkAutoTUnref<const GrXPFactory> xpf(GrProcessorTestFactory<GrXPFactory>::CreateStage(d));
SkASSERT(xpf);
pipelineBuilder->setXPFactory(xpf.get());
}
@ -194,7 +151,7 @@ static const GrFragmentProcessor* create_random_proc_tree(GrProcessorTestData* d
if (terminate) {
const GrFragmentProcessor* fp;
while (true) {
fp = GrProcessorTestFactory<GrFragmentProcessor>::Create(d);
fp = GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d);
SkASSERT(fp);
if (0 == fp->numChildProcessors()) {
break;
@ -244,7 +201,7 @@ static void set_random_color_coverage_stages(GrPipelineBuilder* pipelineBuilder,
for (int s = 0; s < numProcs;) {
SkAutoTUnref<const GrFragmentProcessor> fp(
GrProcessorTestFactory<GrFragmentProcessor>::Create(d));
GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(d));
SkASSERT(fp);
// finally add the stage to the correct pipeline in the drawstate
@ -352,42 +309,9 @@ bool GrDrawTarget::programUnitTest(GrContext* context, int maxStages) {
this->drawBatch(pipelineBuilder, batch);
}
// Flush everything, test passes if flush is successful(ie, no asserts are hit, no crashes)
this->flush();
// Validate that GrFPs work correctly without an input.
GrSurfaceDesc rtDesc;
rtDesc.fWidth = kRenderTargetWidth;
rtDesc.fHeight = kRenderTargetHeight;
rtDesc.fFlags = kRenderTarget_GrSurfaceFlag;
rtDesc.fConfig = kRGBA_8888_GrPixelConfig;
SkAutoTUnref<GrRenderTarget> rt(
fContext->textureProvider()->createTexture(rtDesc, false)->asRenderTarget());
int fpFactoryCnt = GrProcessorTestFactory<GrFragmentProcessor>::Count();
for (int i = 0; i < fpFactoryCnt; ++i) {
// Since FP factories internally randomize, call each 10 times.
for (int j = 0; j < 10; ++j) {
SkAutoTUnref<GrDrawBatch> batch(GrRandomDrawBatch(&random, context));
SkASSERT(batch);
GrProcessorDataManager procDataManager;
GrProcessorTestData ptd(&random, context, &procDataManager, this->caps(),
dummyTextures);
GrPipelineBuilder builder;
builder.setXPFactory(GrPorterDuffXPFactory::Create(SkXfermode::kSrc_Mode))->unref();
builder.setRenderTarget(rt);
builder.setClip(clip);
SkAutoTUnref<const GrFragmentProcessor> fp(
GrProcessorTestFactory<GrFragmentProcessor>::CreateIdx(i, &ptd));
SkAutoTUnref<const GrFragmentProcessor> blockFP(
BlockInputFragmentProcessor::Create(fp));
builder.addColorFragmentProcessor(blockFP);
this->drawBatch(builder, batch);
this->flush();
}
}
return true;
}