skia2/include/gpu/GrProcessorUnitTest.h
egdaniel c230414861 Create xfer processor backend.
This includes:
-Having an actual XP stage at the end of the gl pipeline.
-All Blending work is handled by XP until actually setting GL blend states
-GLPrograms test to test XP

BUG=skia:

Committed: https://skia.googlesource.com/skia/+/4dffc940c430eec66d4707490eace19c9b3f7904

Review URL: https://codereview.chromium.org/764643004
2014-12-11 13:15:14 -08:00

211 lines
8.8 KiB
C++

/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrProcessorUnitTest_DEFINED
#define GrProcessorUnitTest_DEFINED
#include "GrColor.h"
#include "SkRandom.h"
#include "SkTArray.h"
#include "SkTypes.h"
class SkMatrix;
class GrDrawTargetCaps;
namespace GrProcessorUnitTest {
// Used to access the dummy textures in TestCreate procs.
enum {
kSkiaPMTextureIdx = 0,
kAlphaTextureIdx = 1,
};
/**
* A helper for use in GrProcessor::TestCreate functions.
*/
const SkMatrix& TestMatrix(SkRandom*);
}
static inline GrColor GrRandomColor(SkRandom* random) {
// 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
};
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);
return color;
}
static inline uint8_t GrRandomCoverage(SkRandom* random) {
enum CoverageMode {
kZero_CoverageMode,
kAllOnes_CoverageMode,
kRandom_CoverageMode,
kLast_CoverageMode = kRandom_CoverageMode
};
CoverageMode colorMode = CoverageMode(random->nextULessThan(kLast_CoverageMode + 1));
uint8_t coverage;
switch (colorMode) {
case kZero_CoverageMode:
coverage = 0;
case kAllOnes_CoverageMode:
coverage = 0xff;
break;
case kRandom_CoverageMode:
coverage = random->nextULessThan(256);
break;
}
return coverage;
}
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
class GrContext;
class GrProcessor;
class GrTexture;
template <class Processor>
class GrProcessorTestFactory : SkNoncopyable {
public:
typedef Processor* (*CreateProc)(SkRandom*,
GrContext*,
const GrDrawTargetCaps& caps,
GrTexture* dummyTextures[]);
GrProcessorTestFactory(CreateProc createProc) {
fCreateProc = createProc;
GetFactories()->push_back(this);
}
static Processor* CreateStage(SkRandom* random,
GrContext* context,
const GrDrawTargetCaps& caps,
GrTexture* dummyTextures[]) {
VerifyFactoryCount();
SkASSERT(GetFactories()->count());
uint32_t idx = random->nextRangeU(0, GetFactories()->count() - 1);
GrProcessorTestFactory<Processor>* factory = (*GetFactories())[idx];
return factory->fCreateProc(random, context, caps, dummyTextures);
}
/*
* A test function which verifies the count of factories.
*/
static void VerifyFactoryCount();
private:
CreateProc fCreateProc;
static SkTArray<GrProcessorTestFactory<Processor>*, true>* GetFactories();
};
/** GrProcessor subclasses should insert this macro in their declaration to be included in the
* program generation unit test.
*/
#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
static GrProcessorTestFactory<GrGeometryProcessor> gTestFactory SK_UNUSED; \
static GrGeometryProcessor* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
static GrProcessorTestFactory<GrFragmentProcessor> gTestFactory SK_UNUSED; \
static GrFragmentProcessor* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
#define GR_DECLARE_XP_FACTORY_TEST \
static GrProcessorTestFactory<GrXPFactory> gTestFactory SK_UNUSED; \
static GrXPFactory* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
/** GrProcessor subclasses should insert this macro in their implementation file. They must then
* also implement this static function:
* GrProcessor* TestCreate(SkRandom*,
* GrContext*,
* const GrDrawTargetCaps&,
* GrTexture* dummyTextures[2]);
* dummyTextures[] are valid textures that can optionally be used to construct GrTextureAccesses.
* The first texture has config kSkia8888_GrPixelConfig and the second has
* kAlpha_8_GrPixelConfig. TestCreate functions are also free to create additional textures using
* the GrContext.
*/
#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(Effect) \
GrProcessorTestFactory<GrFragmentProcessor> Effect :: gTestFactory(Effect :: TestCreate)
#define GR_DEFINE_XP_FACTORY_TEST(Factory) \
GrProcessorTestFactory<GrXPFactory> Factory :: gTestFactory(Factory :: TestCreate)
#define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(Effect) \
GrProcessorTestFactory<GrGeometryProcessor> Effect :: gTestFactory(Effect :: TestCreate)
#else // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_FRAGMENT_PROCESSOR_TEST \
static GrFragmentProcessor* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
#define GR_DEFINE_FRAGMENT_PROCESSOR_TEST(X)
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_XP_FACTORY_TEST \
static GrXPFactory* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
#define GR_DEFINE_XP_FACTORY_TEST(X)
// The unit test relies on static initializers. Just declare the TestCreate function so that
// its definitions will compile.
#define GR_DECLARE_GEOMETRY_PROCESSOR_TEST \
static GrGeometryProcessor* TestCreate(SkRandom*, \
GrContext*, \
const GrDrawTargetCaps&, \
GrTexture* dummyTextures[2])
#define GR_DEFINE_GEOMETRY_PROCESSOR_TEST(X)
#endif // !SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
#endif