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