blob: dd731e07732a86904386bc30ed1220690fe26657 [file] [log] [blame]
/*
* Copyright 2011 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
// This is a GPU-backend specific test. It relies on static intializers to work
#include "SkTypes.h"
#if SK_SUPPORT_GPU && SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
#include "GrContextFactory.h"
#include "GrInvariantOutput.h"
#include "GrOptDrawState.h"
#include "GrTBackendProcessorFactory.h"
#include "GrTest.h"
#include "SkChecksum.h"
#include "SkRandom.h"
#include "Test.h"
#include "effects/GrConfigConversionEffect.h"
#include "gl/GrGLPathRendering.h"
#include "gl/GrGpuGL.h"
#include "gl/builders/GrGLProgramBuilder.h"
/*
* A dummy processor which just tries to insert a massive key and verify that it can retrieve the
* whole thing correctly
*/
static const uint32_t kMaxKeySize = 1024;
class GLBigKeyProcessor;
class BigKeyProcessor : public GrFragmentProcessor {
public:
static GrFragmentProcessor* Create() {
GR_CREATE_STATIC_PROCESSOR(gBigKeyProcessor, BigKeyProcessor, ())
return SkRef(gBigKeyProcessor);
}
static const char* Name() { return "Big ol' Key"; }
virtual const GrBackendFragmentProcessorFactory& getFactory() const SK_OVERRIDE {
return GrTBackendFragmentProcessorFactory<BigKeyProcessor>::getInstance();
}
typedef GLBigKeyProcessor GLProcessor;
private:
BigKeyProcessor() { }
virtual bool onIsEqual(const GrFragmentProcessor&) const SK_OVERRIDE { return true; }
virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVERRIDE { }
GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
typedef GrFragmentProcessor INHERITED;
};
GR_DEFINE_FRAGMENT_PROCESSOR_TEST(BigKeyProcessor);
GrFragmentProcessor* BigKeyProcessor::TestCreate(SkRandom*,
GrContext*,
const GrDrawTargetCaps&,
GrTexture*[]) {
return BigKeyProcessor::Create();
}
class GLBigKeyProcessor : public GrGLFragmentProcessor {
public:
GLBigKeyProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&)
: INHERITED(factory) {}
virtual void emitCode(GrGLFPBuilder* builder,
const GrFragmentProcessor& fp,
const GrProcessorKey& key,
const char* outputColor,
const char* inputColor,
const TransformedCoordsArray&,
const TextureSamplerArray&) {
for (uint32_t i = 0; i < kMaxKeySize; i++) {
SkASSERT(key.get32(i) == i);
}
}
static void GenKey(const GrProcessor& processor, const GrGLCaps&, GrProcessorKeyBuilder* b) {
for (uint32_t i = 0; i < kMaxKeySize; i++) {
b->add32(i);
}
}
private:
typedef GrGLFragmentProcessor INHERITED;
};
/*
* Begin test code
*/
static const int kRenderTargetHeight = 1;
static const int kRenderTargetWidth = 1;
static GrRenderTarget* random_render_target(GrContext* context,
const GrCacheID& cacheId,
SkRandom* random) {
// setup render target
GrTextureParams params;
GrSurfaceDesc texDesc;
texDesc.fWidth = kRenderTargetWidth;
texDesc.fHeight = kRenderTargetHeight;
texDesc.fFlags = kRenderTarget_GrSurfaceFlag;
texDesc.fConfig = kRGBA_8888_GrPixelConfig;
texDesc.fOrigin = random->nextBool() == true ? kTopLeft_GrSurfaceOrigin :
kBottomLeft_GrSurfaceOrigin;
SkAutoTUnref<GrTexture> texture(context->findAndRefTexture(texDesc, cacheId, &params));
if (!texture) {
texture.reset(context->createTexture(&params, texDesc, cacheId, 0, 0));
if (!texture) {
return NULL;
}
}
return SkRef(texture->asRenderTarget());
}
// TODO clean this up, we have to do this to test geometry processors but there has got to be
// a better way. In the mean time, we actually fill out these generic vertex attribs below with
// the correct vertex attribs from the GP. We have to ensure, however, we don't try to add more
// than two attributes. In addition, we 'pad' the below array with GPs up to 6 entries, 4 fixed
// function vertex attributes and 2 GP custom attributes.
GrVertexAttrib kGenericVertexAttribs[] = {
{ kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBinding },
{ kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding },
{ kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding },
{ kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding },
{ kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding },
{ kVec2f_GrVertexAttribType, 0, kGeometryProcessor_GrVertexAttribBinding }
};
/*
* convert sl type to vertexattrib type, not a complete implementation, only use for debugging
*/
static GrVertexAttribType convert_sltype_to_attribtype(GrSLType type) {
switch (type) {
case kFloat_GrSLType:
return kFloat_GrVertexAttribType;
case kVec2f_GrSLType:
return kVec2f_GrVertexAttribType;
case kVec3f_GrSLType:
return kVec3f_GrVertexAttribType;
case kVec4f_GrSLType:
return kVec4f_GrVertexAttribType;
default:
SkFAIL("Type isn't convertible");
return kFloat_GrVertexAttribType;
}
}
// end test hack
static void setup_random_ff_attribute(GrVertexAttribBinding binding, GrVertexAttribType type,
SkRandom* random, int* attribIndex, int* runningStride) {
if (random->nextBool()) {
kGenericVertexAttribs[*attribIndex].fType = type;
kGenericVertexAttribs[*attribIndex].fOffset = *runningStride;
kGenericVertexAttribs[*attribIndex].fBinding = binding;
*runningStride += GrVertexAttribTypeSize(kGenericVertexAttribs[(*attribIndex)++].fType);
}
}
static void set_random_gp(GrContext* context,
const GrDrawTargetCaps& caps,
GrDrawState* ds,
SkRandom* random,
GrTexture* dummyTextures[]) {
GrProgramElementRef<const GrGeometryProcessor> gp(
GrProcessorTestFactory<GrGeometryProcessor>::CreateStage(random,
context,
caps,
dummyTextures));
SkASSERT(gp);
// we have to set dummy vertex attributes, first we setup the fixed function attributes
// always leave the position attribute untouched in the array
int attribIndex = 1;
int runningStride = GrVertexAttribTypeSize(kGenericVertexAttribs[0].fType);
// local coords
setup_random_ff_attribute(kLocalCoord_GrVertexAttribBinding, kVec2f_GrVertexAttribType,
random, &attribIndex, &runningStride);
// color
setup_random_ff_attribute(kColor_GrVertexAttribBinding, kVec4f_GrVertexAttribType,
random, &attribIndex, &runningStride);
// coverage
setup_random_ff_attribute(kCoverage_GrVertexAttribBinding, kUByte_GrVertexAttribType,
random, &attribIndex, &runningStride);
// Update the geometry processor attributes
const GrGeometryProcessor::VertexAttribArray& v = gp->getVertexAttribs();
int numGPAttribs = v.count();
SkASSERT(numGPAttribs <= GrGeometryProcessor::kMaxVertexAttribs &&
GrGeometryProcessor::kMaxVertexAttribs == 2);
// we actually can't overflow if kMaxVertexAttribs == 2, but GCC 4.8 wants more proof
int maxIndex = SK_ARRAY_COUNT(kGenericVertexAttribs);
for (int i = 0; i < numGPAttribs && i + attribIndex < maxIndex; i++) {
kGenericVertexAttribs[i + attribIndex].fType =
convert_sltype_to_attribtype(v[i].getType());
kGenericVertexAttribs[i + attribIndex].fOffset = runningStride;
kGenericVertexAttribs[i + attribIndex].fBinding = kGeometryProcessor_GrVertexAttribBinding;
runningStride += GrVertexAttribTypeSize(kGenericVertexAttribs[i + attribIndex].fType);
}
// update the vertex attributes with the ds
ds->setVertexAttribs<kGenericVertexAttribs>(attribIndex + numGPAttribs, runningStride);
ds->setGeometryProcessor(gp);
}
static void set_random_color_coverage_stages(GrGpuGL* gpu,
GrDrawState* ds,
int maxStages,
bool usePathRendering,
SkRandom* random,
GrTexture* dummyTextures[]) {
int numProcs = random->nextULessThan(maxStages + 1);
int numColorProcs = random->nextULessThan(numProcs + 1);
int currTextureCoordSet = 0;
for (int s = 0; s < numProcs;) {
GrProgramElementRef<GrFragmentProcessor> fp(
GrProcessorTestFactory<GrFragmentProcessor>::CreateStage(random,
gpu->getContext(),
*gpu->caps(),
dummyTextures));
SkASSERT(fp);
// don't add dst color reads to coverage stage
if (s >= numColorProcs && fp->willReadDstColor()) {
continue;
}
// If adding this effect would exceed the max texture coord set count then generate a
// new random effect.
if (usePathRendering && gpu->glPathRendering()->texturingMode() ==
GrGLPathRendering::FixedFunction_TexturingMode) {;
int numTransforms = fp->numTransforms();
if (currTextureCoordSet + numTransforms >
gpu->glCaps().maxFixedFunctionTextureCoords()) {
continue;
}
currTextureCoordSet += numTransforms;
}
// finally add the stage to the correct pipeline in the drawstate
if (s < numColorProcs) {
ds->addColorProcessor(fp);
} else {
ds->addCoverageProcessor(fp);
}
++s;
}
}
// There are only a few cases of random colors which interest us
enum ColorMode {
kAllOnes_ColorMode,
kAllZeros_ColorMode,
kAlphaOne_ColorMode,
kRandom_ColorMode,
kLast_ColorMode = kRandom_ColorMode
};
static void set_random_color(GrDrawState* ds, SkRandom* random) {
ColorMode colorMode = ColorMode(random->nextULessThan(kLast_ColorMode + 1));
GrColor color;
switch (colorMode) {
case kAllOnes_ColorMode:
color = GrColorPackRGBA(0xFF, 0xFF, 0xFF, 0xFF);
break;
case kAllZeros_ColorMode:
color = GrColorPackRGBA(0, 0, 0, 0);
break;
case kAlphaOne_ColorMode:
color = GrColorPackRGBA(random->nextULessThan(256),
random->nextULessThan(256),
random->nextULessThan(256),
0xFF);
break;
case kRandom_ColorMode:
uint8_t alpha = random->nextULessThan(256);
color = GrColorPackRGBA(random->nextRangeU(0, alpha),
random->nextRangeU(0, alpha),
random->nextRangeU(0, alpha),
alpha);
break;
}
GrColorIsPMAssert(color);
ds->setColor(color);
}
// There are only a few cases of random coverages which interest us
enum CoverageMode {
kZero_CoverageMode,
kFF_CoverageMode,
kRandom_CoverageMode,
kLast_CoverageMode = kRandom_CoverageMode
};
static void set_random_coverage(GrDrawState* ds, SkRandom* random) {
CoverageMode coverageMode = CoverageMode(random->nextULessThan(kLast_CoverageMode + 1));
uint8_t coverage;
switch (coverageMode) {
case kZero_CoverageMode:
coverage = 0;
break;
case kFF_CoverageMode:
coverage = 0xFF;
break;
case kRandom_CoverageMode:
coverage = uint8_t(random->nextU());
break;
}
ds->setCoverage(coverage);
}
static void set_random_hints(GrDrawState* ds, SkRandom* random) {
for (int i = 1; i <= GrDrawState::kLast_Hint; i <<= 1) {
ds->setHint(GrDrawState::Hints(i), random->nextBool());
}
}
static void set_random_state(GrDrawState* ds, SkRandom* random) {
int state = 0;
for (int i = 1; i <= GrDrawState::kLast_StateBit; i <<= 1) {
state |= random->nextBool() * i;
}
ds->enableState(state);
}
// this function will randomly pick non-self referencing blend modes
static void set_random_blend_func(GrDrawState* ds, SkRandom* random) {
GrBlendCoeff src;
do {
src = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
} while (GrBlendCoeffRefsSrc(src));
GrBlendCoeff dst;
do {
dst = GrBlendCoeff(random->nextRangeU(kFirstPublicGrBlendCoeff, kLastPublicGrBlendCoeff));
} while (GrBlendCoeffRefsDst(dst));
ds->setBlendFunc(src, dst);
}
// right now, the only thing we seem to care about in drawState's stencil is 'doesWrite()'
static void set_random_stencil(GrDrawState* ds, SkRandom* random) {
GR_STATIC_CONST_SAME_STENCIL(kDoesWriteStencil,
kReplace_StencilOp,
kReplace_StencilOp,
kAlways_StencilFunc,
0xffff,
0xffff,
0xffff);
GR_STATIC_CONST_SAME_STENCIL(kDoesNotWriteStencil,
kKeep_StencilOp,
kKeep_StencilOp,
kNever_StencilFunc,
0xffff,
0xffff,
0xffff);
if (random->nextBool()) {
ds->setStencil(kDoesWriteStencil);
} else {
ds->setStencil(kDoesNotWriteStencil);
}
}
bool GrDrawTarget::programUnitTest(int maxStages) {
GrGpuGL* gpu = static_cast<GrGpuGL*>(fContext->getGpu());
// setup dummy textures
GrSurfaceDesc dummyDesc;
dummyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
dummyDesc.fConfig = kSkia8888_GrPixelConfig;
dummyDesc.fWidth = 34;
dummyDesc.fHeight = 18;
SkAutoTUnref<GrTexture> dummyTexture1(gpu->createTexture(dummyDesc, NULL, 0));
dummyDesc.fFlags = kNone_GrSurfaceFlags;
dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
dummyDesc.fWidth = 16;
dummyDesc.fHeight = 22;
SkAutoTUnref<GrTexture> dummyTexture2(gpu->createTexture(dummyDesc, NULL, 0));
if (!dummyTexture1 || ! dummyTexture2) {
SkDebugf("Could not allocate dummy textures");
return false;
}
GrTexture* dummyTextures[] = {dummyTexture1.get(), dummyTexture2.get()};
// Setup texture cache id key
const GrCacheID::Domain glProgramsDomain = GrCacheID::GenerateDomain();
GrCacheID::Key key;
memset(&key, 0, sizeof(key));
key.fData32[0] = kRenderTargetWidth;
key.fData32[1] = kRenderTargetHeight;
GrCacheID glProgramsCacheID(glProgramsDomain, key);
// setup clip
SkRect screen = SkRect::MakeWH(SkIntToScalar(kRenderTargetWidth),
SkIntToScalar(kRenderTargetHeight));
SkClipStack stack;
stack.clipDevRect(screen, SkRegion::kReplace_Op, false);
// wrap the SkClipStack in a GrClipData
GrClipData clipData;
clipData.fClipStack = &stack;
this->setClip(&clipData);
SkRandom random;
static const int NUM_TESTS = 512;
for (int t = 0; t < NUM_TESTS;) {
// setup random render target(can fail)
SkAutoTUnref<GrRenderTarget> rt(random_render_target(fContext, glProgramsCacheID, &random));
if (!rt.get()) {
SkDebugf("Could not allocate render target");
return false;
}
GrDrawState* ds = this->drawState();
ds->setRenderTarget(rt.get());
// if path rendering we have to setup a couple of things like the draw type
bool usePathRendering = gpu->glCaps().pathRenderingSupport() && random.nextBool();
GrGpu::DrawType drawType = usePathRendering ? GrGpu::kDrawPath_DrawType :
GrGpu::kDrawPoints_DrawType;
// twiddle drawstate knobs randomly
bool hasGeometryProcessor = usePathRendering ? false : random.nextBool();
if (hasGeometryProcessor) {
set_random_gp(fContext, gpu->glCaps(), ds, &random, dummyTextures);
}
set_random_color_coverage_stages(gpu,
ds,
maxStages - hasGeometryProcessor,
usePathRendering,
&random,
dummyTextures);
set_random_color(ds, &random);
set_random_coverage(ds, &random);
set_random_hints(ds, &random);
set_random_state(ds, &random);
set_random_blend_func(ds, &random);
set_random_stencil(ds, &random);
GrDeviceCoordTexture dstCopy;
if (!this->setupDstReadIfNecessary(&dstCopy, NULL)) {
SkDebugf("Couldn't setup dst read texture");
return false;
}
// create optimized draw state, setup readDst texture if required, and build a descriptor
// and program. ODS creation can fail, so we have to check
SkAutoTUnref<GrOptDrawState> ods(GrOptDrawState::Create(this->getDrawState(),
gpu,
&dstCopy,
drawType));
if (!ods.get()) {
ds->reset();
continue;
}
SkAutoTUnref<GrGLProgram> program(GrGLProgramBuilder::CreateProgram(*ods, drawType, gpu));
if (NULL == program.get()) {
SkDebugf("Failed to create program!");
return false;
}
// We have to reset the drawstate because we might have added a gp
ds->reset();
// because occasionally optimized drawstate creation will fail for valid reasons, we only
// want to increment on success
++t;
}
return true;
}
DEF_GPUTEST(GLPrograms, reporter, factory) {
for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(type));
if (context) {
GrGpuGL* gpu = static_cast<GrGpuGL*>(context->getGpu());
/*
* For the time being, we only support the test with desktop GL or for android on
* ARM platforms
* TODO When we run ES 3.00 GLSL in more places, test again
*/
int maxStages;
if (kGL_GrGLStandard == gpu->glStandard() ||
kARM_GrGLVendor == gpu->ctxInfo().vendor()) {
maxStages = 6;
} else if (kTegra3_GrGLRenderer == gpu->ctxInfo().renderer() ||
kOther_GrGLRenderer == gpu->ctxInfo().renderer()) {
maxStages = 1;
} else {
return;
}
#if SK_ANGLE
// Some long shaders run out of temporary registers in the D3D compiler on ANGLE.
if (type == GrContextFactory::kANGLE_GLContextType) {
maxStages = 3;
}
#endif
GrTestTarget target;
context->getTestTarget(&target);
REPORTER_ASSERT(reporter, target.target()->programUnitTest(maxStages));
}
}
}
#endif