1 /*
2 * Copyright 2014 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #include "src/gpu/GrDefaultGeoProcFactory.h"
9
10 #include "include/core/SkRefCnt.h"
11 #include "src/core/SkArenaAlloc.h"
12 #include "src/gpu/GrCaps.h"
13 #include "src/gpu/GrGeometryProcessor.h"
14 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
15 #include "src/gpu/glsl/GrGLSLUniformHandler.h"
16 #include "src/gpu/glsl/GrGLSLVarying.h"
17 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
18
19 /*
20 * The default Geometry Processor simply takes position and multiplies it by the uniform view
21 * matrix. It also leaves coverage untouched. Behind the scenes, we may add per vertex color or
22 * local coords.
23 */
24
25 enum GPFlag {
26 kColorAttribute_GPFlag = 0x1,
27 kColorAttributeIsWide_GPFlag = 0x2,
28 kLocalCoordAttribute_GPFlag = 0x4,
29 kCoverageAttribute_GPFlag = 0x8,
30 kCoverageAttributeTweak_GPFlag = 0x10,
31 kCoverageAttributeUnclamped_GPFlag = 0x20,
32 };
33
34 class DefaultGeoProc : public GrGeometryProcessor {
35 public:
Make(SkArenaAlloc * arena,uint32_t gpTypeFlags,const SkPMColor4f & color,const SkMatrix & viewMatrix,const SkMatrix & localMatrix,bool localCoordsWillBeRead,uint8_t coverage)36 static GrGeometryProcessor* Make(SkArenaAlloc* arena,
37 uint32_t gpTypeFlags,
38 const SkPMColor4f& color,
39 const SkMatrix& viewMatrix,
40 const SkMatrix& localMatrix,
41 bool localCoordsWillBeRead,
42 uint8_t coverage) {
43 return arena->make([&](void* ptr) {
44 return new (ptr) DefaultGeoProc(gpTypeFlags, color, viewMatrix, localMatrix, coverage,
45 localCoordsWillBeRead);
46 });
47 }
48
name() const49 const char* name() const override { return "DefaultGeometryProcessor"; }
50
addToKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const51 void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
52 uint32_t key = fFlags;
53 key |= fCoverage == 0xff ? 0x80 : 0;
54 key |= fLocalCoordsWillBeRead ? 0x100 : 0;
55
56 bool usesLocalMatrix = fLocalCoordsWillBeRead && !fInLocalCoords.isInitialized();
57 key = ProgramImpl::AddMatrixKeys(caps,
58 key,
59 fViewMatrix,
60 usesLocalMatrix ? fLocalMatrix : SkMatrix::I());
61 b->add32(key);
62 }
63
makeProgramImpl(const GrShaderCaps &) const64 std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {
65 return std::make_unique<Impl>();
66 }
67
68 private:
69 class Impl : public ProgramImpl {
70 public:
setData(const GrGLSLProgramDataManager & pdman,const GrShaderCaps & shaderCaps,const GrGeometryProcessor & geomProc)71 void setData(const GrGLSLProgramDataManager& pdman,
72 const GrShaderCaps& shaderCaps,
73 const GrGeometryProcessor& geomProc) override {
74 const DefaultGeoProc& dgp = geomProc.cast<DefaultGeoProc>();
75
76 SetTransform(pdman, shaderCaps, fViewMatrixUniform, dgp.fViewMatrix, &fViewMatrixPrev);
77 SetTransform(pdman,
78 shaderCaps,
79 fLocalMatrixUniform,
80 dgp.fLocalMatrix,
81 &fLocalMatrixPrev);
82
83 if (!dgp.hasVertexColor() && dgp.fColor != fColor) {
84 pdman.set4fv(fColorUniform, 1, dgp.fColor.vec());
85 fColor = dgp.fColor;
86 }
87
88 if (dgp.fCoverage != fCoverage && !dgp.hasVertexCoverage()) {
89 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.fCoverage));
90 fCoverage = dgp.fCoverage;
91 }
92 }
93
94 private:
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)95 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
96 const DefaultGeoProc& gp = args.fGeomProc.cast<DefaultGeoProc>();
97 GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
98 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
99 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
100 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
101
102 // emit attributes
103 varyingHandler->emitAttributes(gp);
104
105 bool tweakAlpha = SkToBool(gp.fFlags & kCoverageAttributeTweak_GPFlag);
106 bool coverageNeedsSaturate = SkToBool(gp.fFlags & kCoverageAttributeUnclamped_GPFlag);
107 SkASSERT(!tweakAlpha || gp.hasVertexCoverage());
108 SkASSERT(!tweakAlpha || !coverageNeedsSaturate);
109
110 // Setup pass through color
111 fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);
112 if (gp.hasVertexColor() || tweakAlpha) {
113 GrGLSLVarying varying(kHalf4_GrSLType);
114 varyingHandler->addVarying("color", &varying);
115
116 // Start with the attribute or with uniform color
117 if (gp.hasVertexColor()) {
118 vertBuilder->codeAppendf("half4 color = %s;", gp.fInColor.name());
119 } else {
120 const char* colorUniformName;
121 fColorUniform = uniformHandler->addUniform(nullptr,
122 kVertex_GrShaderFlag,
123 kHalf4_GrSLType,
124 "Color",
125 &colorUniformName);
126 vertBuilder->codeAppendf("half4 color = %s;", colorUniformName);
127 }
128
129 // Optionally fold coverage into alpha (color).
130 if (tweakAlpha) {
131 vertBuilder->codeAppendf("color = color * %s;", gp.fInCoverage.name());
132 }
133 vertBuilder->codeAppendf("%s = color;\n", varying.vsOut());
134 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn());
135 } else {
136 this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
137 &fColorUniform);
138 }
139
140 // Setup position
141 WriteOutputPosition(vertBuilder,
142 uniformHandler,
143 *args.fShaderCaps,
144 gpArgs,
145 gp.fInPosition.name(),
146 gp.fViewMatrix,
147 &fViewMatrixUniform);
148
149 // emit transforms using either explicit local coords or positions
150 if (gp.fInLocalCoords.isInitialized()) {
151 SkASSERT(gp.fLocalMatrix.isIdentity());
152 gpArgs->fLocalCoordVar = gp.fInLocalCoords.asShaderVar();
153 } else if (gp.fLocalCoordsWillBeRead) {
154 WriteLocalCoord(vertBuilder,
155 uniformHandler,
156 *args.fShaderCaps,
157 gpArgs,
158 gp.fInPosition.asShaderVar(),
159 gp.fLocalMatrix,
160 &fLocalMatrixUniform);
161 }
162
163 // Setup coverage as pass through
164 if (gp.hasVertexCoverage() && !tweakAlpha) {
165 fragBuilder->codeAppendf("half alpha = 1.0;");
166 varyingHandler->addPassThroughAttribute(gp.fInCoverage.asShaderVar(), "alpha");
167 if (coverageNeedsSaturate) {
168 fragBuilder->codeAppendf("half4 %s = half4(saturate(alpha));",
169 args.fOutputCoverage);
170 } else {
171 fragBuilder->codeAppendf("half4 %s = half4(alpha);", args.fOutputCoverage);
172 }
173 } else if (gp.fCoverage == 0xff) {
174 fragBuilder->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
175 } else {
176 const char* fragCoverage;
177 fCoverageUniform = uniformHandler->addUniform(nullptr,
178 kFragment_GrShaderFlag,
179 kHalf_GrSLType,
180 "Coverage",
181 &fragCoverage);
182 fragBuilder->codeAppendf("half4 %s = half4(%s);",
183 args.fOutputCoverage, fragCoverage);
184 }
185 }
186
187 SkMatrix fViewMatrixPrev = SkMatrix::InvalidMatrix();
188 SkMatrix fLocalMatrixPrev = SkMatrix::InvalidMatrix();
189 SkPMColor4f fColor = SK_PMColor4fILLEGAL;
190 uint8_t fCoverage = 0xFF;
191
192 UniformHandle fViewMatrixUniform;
193 UniformHandle fLocalMatrixUniform;
194 UniformHandle fColorUniform;
195 UniformHandle fCoverageUniform;
196 };
197
hasVertexColor() const198 bool hasVertexColor() const { return fInColor.isInitialized(); }
hasVertexCoverage() const199 bool hasVertexCoverage() const { return fInCoverage.isInitialized(); }
200
DefaultGeoProc(uint32_t gpTypeFlags,const SkPMColor4f & color,const SkMatrix & viewMatrix,const SkMatrix & localMatrix,uint8_t coverage,bool localCoordsWillBeRead)201 DefaultGeoProc(uint32_t gpTypeFlags,
202 const SkPMColor4f& color,
203 const SkMatrix& viewMatrix,
204 const SkMatrix& localMatrix,
205 uint8_t coverage,
206 bool localCoordsWillBeRead)
207 : INHERITED(kDefaultGeoProc_ClassID)
208 , fColor(color)
209 , fViewMatrix(viewMatrix)
210 , fLocalMatrix(localMatrix)
211 , fCoverage(coverage)
212 , fFlags(gpTypeFlags)
213 , fLocalCoordsWillBeRead(localCoordsWillBeRead) {
214 fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
215 if (fFlags & kColorAttribute_GPFlag) {
216 fInColor = MakeColorAttribute("inColor",
217 SkToBool(fFlags & kColorAttributeIsWide_GPFlag));
218 }
219 if (fFlags & kLocalCoordAttribute_GPFlag) {
220 fInLocalCoords = {"inLocalCoord", kFloat2_GrVertexAttribType,
221 kFloat2_GrSLType};
222 }
223 if (fFlags & kCoverageAttribute_GPFlag) {
224 fInCoverage = {"inCoverage", kFloat_GrVertexAttribType, kHalf_GrSLType};
225 }
226 this->setVertexAttributes(&fInPosition, 4);
227 }
228
229 Attribute fInPosition;
230 Attribute fInColor;
231 Attribute fInLocalCoords;
232 Attribute fInCoverage;
233 SkPMColor4f fColor;
234 SkMatrix fViewMatrix;
235 SkMatrix fLocalMatrix;
236 uint8_t fCoverage;
237 uint32_t fFlags;
238 bool fLocalCoordsWillBeRead;
239
240 GR_DECLARE_GEOMETRY_PROCESSOR_TEST
241
242 using INHERITED = GrGeometryProcessor;
243 };
244
245 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
246
247 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)248 GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
249 uint32_t flags = 0;
250 if (d->fRandom->nextBool()) {
251 flags |= kColorAttribute_GPFlag;
252 }
253 if (d->fRandom->nextBool()) {
254 flags |= kColorAttributeIsWide_GPFlag;
255 }
256 if (d->fRandom->nextBool()) {
257 flags |= kCoverageAttribute_GPFlag;
258 if (d->fRandom->nextBool()) {
259 flags |= (d->fRandom->nextBool()) ? kCoverageAttributeTweak_GPFlag
260 : kCoverageAttributeUnclamped_GPFlag;
261 }
262 }
263 if (d->fRandom->nextBool()) {
264 flags |= kLocalCoordAttribute_GPFlag;
265 }
266
267 GrColor color = GrTest::RandomColor(d->fRandom);
268 SkMatrix viewMtx = GrTest::TestMatrix(d->fRandom);
269 SkMatrix localMtx = GrTest::TestMatrix(d->fRandom);
270 bool readsLocalCoords = d->fRandom->nextBool();
271 uint8_t coverage = GrTest::RandomCoverage(d->fRandom);
272 return DefaultGeoProc::Make(d->allocator(),
273 flags,
274 SkPMColor4f::FromBytes_RGBA(color),
275 viewMtx,
276 localMtx,
277 readsLocalCoords,
278 coverage);
279 }
280 #endif
281
Make(SkArenaAlloc * arena,const Color & color,const Coverage & coverage,const LocalCoords & localCoords,const SkMatrix & viewMatrix)282 GrGeometryProcessor* GrDefaultGeoProcFactory::Make(SkArenaAlloc* arena,
283 const Color& color,
284 const Coverage& coverage,
285 const LocalCoords& localCoords,
286 const SkMatrix& viewMatrix) {
287 uint32_t flags = 0;
288 if (Color::kPremulGrColorAttribute_Type == color.fType) {
289 flags |= kColorAttribute_GPFlag;
290 } else if (Color::kPremulWideColorAttribute_Type == color.fType) {
291 flags |= kColorAttribute_GPFlag | kColorAttributeIsWide_GPFlag;
292 }
293 if (Coverage::kAttribute_Type == coverage.fType) {
294 flags |= kCoverageAttribute_GPFlag;
295 } else if (Coverage::kAttributeTweakAlpha_Type == coverage.fType) {
296 flags |= kCoverageAttribute_GPFlag | kCoverageAttributeTweak_GPFlag;
297 } else if (Coverage::kAttributeUnclamped_Type == coverage.fType) {
298 flags |= kCoverageAttribute_GPFlag | kCoverageAttributeUnclamped_GPFlag;
299 }
300 flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoordAttribute_GPFlag : 0;
301
302 uint8_t inCoverage = coverage.fCoverage;
303 bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
304
305 return DefaultGeoProc::Make(arena,
306 flags,
307 color.fColor,
308 viewMatrix,
309 localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
310 localCoordsWillBeRead,
311 inCoverage);
312 }
313
MakeForDeviceSpace(SkArenaAlloc * arena,const Color & color,const Coverage & coverage,const LocalCoords & localCoords,const SkMatrix & viewMatrix)314 GrGeometryProcessor* GrDefaultGeoProcFactory::MakeForDeviceSpace(SkArenaAlloc* arena,
315 const Color& color,
316 const Coverage& coverage,
317 const LocalCoords& localCoords,
318 const SkMatrix& viewMatrix) {
319 SkMatrix invert = SkMatrix::I();
320 if (LocalCoords::kUnused_Type != localCoords.fType) {
321 SkASSERT(LocalCoords::kUsePosition_Type == localCoords.fType);
322 if (!viewMatrix.isIdentity() && !viewMatrix.invert(&invert)) {
323 return nullptr;
324 }
325
326 if (localCoords.hasLocalMatrix()) {
327 invert.postConcat(*localCoords.fMatrix);
328 }
329 }
330
331 LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
332 return Make(arena, color, coverage, inverted, SkMatrix::I());
333 }
334