1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrTestUtils_DEFINED
#define GrTestUtils_DEFINED
#include "SkTypes.h"
#if GR_TEST_UTILS
#include "../private/SkTemplates.h"
#include "GrColor.h"
#include "GrFPArgs.h"
#include "GrSamplerState.h"
#include "SkPathEffect.h"
#include "SkRandom.h"
#include "SkShaderBase.h"
#include "SkStrokeRec.h"
class GrColorSpaceInfo;
class GrColorSpaceXform;
struct GrProcessorTestData;
class GrStyle;
class SkMatrix;
class SkPath;
class SkRRect;
struct SkRect;
namespace GrTest {
/**
* Helpers for use in Test functions.
*/
const SkMatrix& TestMatrix(SkRandom*);
const SkMatrix& TestMatrixPreservesRightAngles(SkRandom*);
const SkMatrix& TestMatrixRectStaysRect(SkRandom*);
const SkMatrix& TestMatrixInvertible(SkRandom*);
const SkMatrix& TestMatrixPerspective(SkRandom*);
void TestWrapModes(SkRandom*, GrSamplerState::WrapMode[2]);
const SkRect& TestRect(SkRandom*);
const SkRect& TestSquare(SkRandom*);
const SkRRect& TestRRectSimple(SkRandom*);
const SkPath& TestPath(SkRandom*);
const SkPath& TestPathConvex(SkRandom*);
SkStrokeRec TestStrokeRec(SkRandom*);
/** Creates styles with dash path effects and null path effects */
void TestStyle(SkRandom*, GrStyle*);
sk_sp<SkColorSpace> TestColorSpace(SkRandom*);
sk_sp<GrColorSpaceXform> TestColorXform(SkRandom*);
class TestAsFPArgs {
public:
TestAsFPArgs(GrProcessorTestData*);
~TestAsFPArgs();
const GrFPArgs& args() const { return fArgs; }
private:
SkMatrix fViewMatrixStorage;
std::unique_ptr<GrColorSpaceInfo> fColorSpaceInfoStorage;
GrFPArgs fArgs;
};
// We have a simplified dash path effect here to avoid relying on SkDashPathEffect which
// is in the optional build target effects.
class TestDashPathEffect : public SkPathEffect {
public:
static sk_sp<SkPathEffect> Make(const SkScalar* intervals, int count, SkScalar phase) {
return sk_sp<SkPathEffect>(new TestDashPathEffect(intervals, count, phase));
}
bool filterPath(SkPath* dst, const SkPath&, SkStrokeRec* , const SkRect*) const override;
DashType asADash(DashInfo* info) const override;
Factory getFactory() const override { return nullptr; }
void toString(SkString*) const override {}
private:
TestDashPathEffect(const SkScalar* intervals, int count, SkScalar phase);
int fCount;
SkAutoTArray<SkScalar> fIntervals;
SkScalar fPhase;
SkScalar fInitialDashLength;
int fInitialDashIndex;
SkScalar fIntervalLength;
};
} // namespace GrTest
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 SK_INIT_TO_AVOID_WARNING;
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 SK_INIT_TO_AVOID_WARNING;
switch (colorMode) {
case kZero_CoverageMode:
coverage = 0;
break;
case kAllOnes_CoverageMode:
coverage = 0xff;
break;
case kRandom_CoverageMode:
coverage = random->nextULessThan(256);
break;
}
return coverage;
}
#endif
#endif
|
