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
getShaderDfxInfo() const51 SkString getShaderDfxInfo() const override {
52 SkString format;
53 format.printf("ShaderDfx_DefaultGeoProc_%d_%d_%d_%d_%d_%d_%d_%d_%d_%d",
54 fFlags, fCoverage, fLocalCoordsWillBeRead, fInLocalCoords.isInitialized(),
55 fViewMatrix.isIdentity(), fViewMatrix.isScaleTranslate(), fViewMatrix.hasPerspective(),
56 fLocalMatrix.isIdentity(), fLocalMatrix.isScaleTranslate(), fLocalMatrix.hasPerspective());
57 return format;
58 }
59
addToKey(const GrShaderCaps & caps,GrProcessorKeyBuilder * b) const60 void addToKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
61 uint32_t key = fFlags;
62 key |= fCoverage == 0xff ? 0x80 : 0;
63 key |= fLocalCoordsWillBeRead ? 0x100 : 0;
64
65 bool usesLocalMatrix = fLocalCoordsWillBeRead && !fInLocalCoords.isInitialized();
66 key = ProgramImpl::AddMatrixKeys(caps,
67 key,
68 fViewMatrix,
69 usesLocalMatrix ? fLocalMatrix : SkMatrix::I());
70 b->add32(key);
71 }
72
makeProgramImpl(const GrShaderCaps &) const73 std::unique_ptr<ProgramImpl> makeProgramImpl(const GrShaderCaps&) const override {
74 return std::make_unique<Impl>();
75 }
76
77 private:
78 class Impl : public ProgramImpl {
79 public:
setData(const GrGLSLProgramDataManager & pdman,const GrShaderCaps & shaderCaps,const GrGeometryProcessor & geomProc)80 void setData(const GrGLSLProgramDataManager& pdman,
81 const GrShaderCaps& shaderCaps,
82 const GrGeometryProcessor& geomProc) override {
83 const DefaultGeoProc& dgp = geomProc.cast<DefaultGeoProc>();
84
85 SetTransform(pdman, shaderCaps, fViewMatrixUniform, dgp.fViewMatrix, &fViewMatrixPrev);
86 SetTransform(pdman,
87 shaderCaps,
88 fLocalMatrixUniform,
89 dgp.fLocalMatrix,
90 &fLocalMatrixPrev);
91
92 if (!dgp.hasVertexColor() && dgp.fColor != fColor) {
93 pdman.set4fv(fColorUniform, 1, dgp.fColor.vec());
94 fColor = dgp.fColor;
95 }
96
97 if (dgp.fCoverage != fCoverage && !dgp.hasVertexCoverage()) {
98 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.fCoverage));
99 fCoverage = dgp.fCoverage;
100 }
101 }
102
103 private:
onEmitCode(EmitArgs & args,GrGPArgs * gpArgs)104 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
105 const DefaultGeoProc& gp = args.fGeomProc.cast<DefaultGeoProc>();
106 GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
107 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
108 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
109 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
110
111 // emit attributes
112 varyingHandler->emitAttributes(gp);
113
114 bool tweakAlpha = SkToBool(gp.fFlags & kCoverageAttributeTweak_GPFlag);
115 bool coverageNeedsSaturate = SkToBool(gp.fFlags & kCoverageAttributeUnclamped_GPFlag);
116 SkASSERT(!tweakAlpha || gp.hasVertexCoverage());
117 SkASSERT(!tweakAlpha || !coverageNeedsSaturate);
118
119 // Setup pass through color
120 fragBuilder->codeAppendf("half4 %s;", args.fOutputColor);
121 if (gp.hasVertexColor() || tweakAlpha) {
122 GrGLSLVarying varying(kHalf4_GrSLType);
123 varyingHandler->addVarying("color", &varying);
124
125 // Start with the attribute or with uniform color
126 if (gp.hasVertexColor()) {
127 vertBuilder->codeAppendf("half4 color = %s;", gp.fInColor.name());
128 } else {
129 const char* colorUniformName;
130 fColorUniform = uniformHandler->addUniform(nullptr,
131 kVertex_GrShaderFlag,
132 kHalf4_GrSLType,
133 "Color",
134 &colorUniformName);
135 vertBuilder->codeAppendf("half4 color = %s;", colorUniformName);
136 }
137
138 // Optionally fold coverage into alpha (color).
139 if (tweakAlpha) {
140 vertBuilder->codeAppendf("color = color * %s;", gp.fInCoverage.name());
141 }
142 vertBuilder->codeAppendf("%s = color;\n", varying.vsOut());
143 fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn());
144 } else {
145 this->setupUniformColor(fragBuilder, uniformHandler, args.fOutputColor,
146 &fColorUniform);
147 }
148
149 // Setup position
150 WriteOutputPosition(vertBuilder,
151 uniformHandler,
152 *args.fShaderCaps,
153 gpArgs,
154 gp.fInPosition.name(),
155 gp.fViewMatrix,
156 &fViewMatrixUniform);
157
158 // emit transforms using either explicit local coords or positions
159 if (gp.fInLocalCoords.isInitialized()) {
160 SkASSERT(gp.fLocalMatrix.isIdentity());
161 gpArgs->fLocalCoordVar = gp.fInLocalCoords.asShaderVar();
162 } else if (gp.fLocalCoordsWillBeRead) {
163 WriteLocalCoord(vertBuilder,
164 uniformHandler,
165 *args.fShaderCaps,
166 gpArgs,
167 gp.fInPosition.asShaderVar(),
168 gp.fLocalMatrix,
169 &fLocalMatrixUniform);
170 }
171
172 // Setup coverage as pass through
173 if (gp.hasVertexCoverage() && !tweakAlpha) {
174 fragBuilder->codeAppendf("half alpha = 1.0;");
175 varyingHandler->addPassThroughAttribute(gp.fInCoverage.asShaderVar(), "alpha");
176 if (coverageNeedsSaturate) {
177 fragBuilder->codeAppendf("half4 %s = half4(saturate(alpha));",
178 args.fOutputCoverage);
179 } else {
180 fragBuilder->codeAppendf("half4 %s = half4(alpha);", args.fOutputCoverage);
181 }
182 } else if (gp.fCoverage == 0xff) {
183 fragBuilder->codeAppendf("const half4 %s = half4(1);", args.fOutputCoverage);
184 } else {
185 const char* fragCoverage;
186 fCoverageUniform = uniformHandler->addUniform(nullptr,
187 kFragment_GrShaderFlag,
188 kHalf_GrSLType,
189 "Coverage",
190 &fragCoverage);
191 fragBuilder->codeAppendf("half4 %s = half4(%s);",
192 args.fOutputCoverage, fragCoverage);
193 }
194 }
195
196 SkMatrix fViewMatrixPrev = SkMatrix::InvalidMatrix();
197 SkMatrix fLocalMatrixPrev = SkMatrix::InvalidMatrix();
198 SkPMColor4f fColor = SK_PMColor4fILLEGAL;
199 uint8_t fCoverage = 0xFF;
200
201 UniformHandle fViewMatrixUniform;
202 UniformHandle fLocalMatrixUniform;
203 UniformHandle fColorUniform;
204 UniformHandle fCoverageUniform;
205 };
206
hasVertexColor() const207 bool hasVertexColor() const { return fInColor.isInitialized(); }
hasVertexCoverage() const208 bool hasVertexCoverage() const { return fInCoverage.isInitialized(); }
209
DefaultGeoProc(uint32_t gpTypeFlags,const SkPMColor4f & color,const SkMatrix & viewMatrix,const SkMatrix & localMatrix,uint8_t coverage,bool localCoordsWillBeRead)210 DefaultGeoProc(uint32_t gpTypeFlags,
211 const SkPMColor4f& color,
212 const SkMatrix& viewMatrix,
213 const SkMatrix& localMatrix,
214 uint8_t coverage,
215 bool localCoordsWillBeRead)
216 : INHERITED(kDefaultGeoProc_ClassID)
217 , fColor(color)
218 , fViewMatrix(viewMatrix)
219 , fLocalMatrix(localMatrix)
220 , fCoverage(coverage)
221 , fFlags(gpTypeFlags)
222 , fLocalCoordsWillBeRead(localCoordsWillBeRead) {
223 fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
224 if (fFlags & kColorAttribute_GPFlag) {
225 fInColor = MakeColorAttribute("inColor",
226 SkToBool(fFlags & kColorAttributeIsWide_GPFlag));
227 }
228 if (fFlags & kLocalCoordAttribute_GPFlag) {
229 fInLocalCoords = {"inLocalCoord", kFloat2_GrVertexAttribType,
230 kFloat2_GrSLType};
231 }
232 if (fFlags & kCoverageAttribute_GPFlag) {
233 fInCoverage = {"inCoverage", kFloat_GrVertexAttribType, kHalf_GrSLType};
234 }
235 this->setVertexAttributes(&fInPosition, 4);
236 }
237
238 Attribute fInPosition;
239 Attribute fInColor;
240 Attribute fInLocalCoords;
241 Attribute fInCoverage;
242 SkPMColor4f fColor;
243 SkMatrix fViewMatrix;
244 SkMatrix fLocalMatrix;
245 uint8_t fCoverage;
246 uint32_t fFlags;
247 bool fLocalCoordsWillBeRead;
248
249 GR_DECLARE_GEOMETRY_PROCESSOR_TEST
250
251 using INHERITED = GrGeometryProcessor;
252 };
253
254 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc);
255
256 #if GR_TEST_UTILS
TestCreate(GrProcessorTestData * d)257 GrGeometryProcessor* DefaultGeoProc::TestCreate(GrProcessorTestData* d) {
258 uint32_t flags = 0;
259 if (d->fRandom->nextBool()) {
260 flags |= kColorAttribute_GPFlag;
261 }
262 if (d->fRandom->nextBool()) {
263 flags |= kColorAttributeIsWide_GPFlag;
264 }
265 if (d->fRandom->nextBool()) {
266 flags |= kCoverageAttribute_GPFlag;
267 if (d->fRandom->nextBool()) {
268 flags |= (d->fRandom->nextBool()) ? kCoverageAttributeTweak_GPFlag
269 : kCoverageAttributeUnclamped_GPFlag;
270 }
271 }
272 if (d->fRandom->nextBool()) {
273 flags |= kLocalCoordAttribute_GPFlag;
274 }
275
276 GrColor color = GrTest::RandomColor(d->fRandom);
277 SkMatrix viewMtx = GrTest::TestMatrix(d->fRandom);
278 SkMatrix localMtx = GrTest::TestMatrix(d->fRandom);
279 bool readsLocalCoords = d->fRandom->nextBool();
280 uint8_t coverage = GrTest::RandomCoverage(d->fRandom);
281 return DefaultGeoProc::Make(d->allocator(),
282 flags,
283 SkPMColor4f::FromBytes_RGBA(color),
284 viewMtx,
285 localMtx,
286 readsLocalCoords,
287 coverage);
288 }
289 #endif
290
Make(SkArenaAlloc * arena,const Color & color,const Coverage & coverage,const LocalCoords & localCoords,const SkMatrix & viewMatrix)291 GrGeometryProcessor* GrDefaultGeoProcFactory::Make(SkArenaAlloc* arena,
292 const Color& color,
293 const Coverage& coverage,
294 const LocalCoords& localCoords,
295 const SkMatrix& viewMatrix) {
296 uint32_t flags = 0;
297 if (Color::kPremulGrColorAttribute_Type == color.fType) {
298 flags |= kColorAttribute_GPFlag;
299 } else if (Color::kPremulWideColorAttribute_Type == color.fType) {
300 flags |= kColorAttribute_GPFlag | kColorAttributeIsWide_GPFlag;
301 }
302 if (Coverage::kAttribute_Type == coverage.fType) {
303 flags |= kCoverageAttribute_GPFlag;
304 } else if (Coverage::kAttributeTweakAlpha_Type == coverage.fType) {
305 flags |= kCoverageAttribute_GPFlag | kCoverageAttributeTweak_GPFlag;
306 } else if (Coverage::kAttributeUnclamped_Type == coverage.fType) {
307 flags |= kCoverageAttribute_GPFlag | kCoverageAttributeUnclamped_GPFlag;
308 }
309 flags |= localCoords.fType == LocalCoords::kHasExplicit_Type ? kLocalCoordAttribute_GPFlag : 0;
310
311 uint8_t inCoverage = coverage.fCoverage;
312 bool localCoordsWillBeRead = localCoords.fType != LocalCoords::kUnused_Type;
313
314 return DefaultGeoProc::Make(arena,
315 flags,
316 color.fColor,
317 viewMatrix,
318 localCoords.fMatrix ? *localCoords.fMatrix : SkMatrix::I(),
319 localCoordsWillBeRead,
320 inCoverage);
321 }
322
MakeForDeviceSpace(SkArenaAlloc * arena,const Color & color,const Coverage & coverage,const LocalCoords & localCoords,const SkMatrix & viewMatrix)323 GrGeometryProcessor* GrDefaultGeoProcFactory::MakeForDeviceSpace(SkArenaAlloc* arena,
324 const Color& color,
325 const Coverage& coverage,
326 const LocalCoords& localCoords,
327 const SkMatrix& viewMatrix) {
328 SkMatrix invert = SkMatrix::I();
329 if (LocalCoords::kUnused_Type != localCoords.fType) {
330 SkASSERT(LocalCoords::kUsePosition_Type == localCoords.fType);
331 if (!viewMatrix.isIdentity() && !viewMatrix.invert(&invert)) {
332 return nullptr;
333 }
334
335 if (localCoords.hasLocalMatrix()) {
336 invert.postConcat(*localCoords.fMatrix);
337 }
338 }
339
340 LocalCoords inverted(LocalCoords::kUsePosition_Type, &invert);
341 return Make(arena, color, coverage, inverted, SkMatrix::I());
342 }
343