OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2014 Google Inc. | 2 * Copyright 2014 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "GrDefaultGeoProcFactory.h" | 8 #include "GrDefaultGeoProcFactory.h" |
9 | 9 |
10 #include "GrInvariantOutput.h" | 10 #include "GrInvariantOutput.h" |
11 #include "gl/GrGLGeometryProcessor.h" | 11 #include "gl/GrGLGeometryProcessor.h" |
12 #include "gl/builders/GrGLProgramBuilder.h" | 12 #include "gl/builders/GrGLProgramBuilder.h" |
13 | 13 |
14 /* | 14 /* |
15 * The default Geometry Processor simply takes position and multiplies it by the
uniform view | 15 * The default Geometry Processor simply takes position and multiplies it by the
uniform view |
16 * matrix. It also leaves coverage untouched. Behind the scenes, we may add per
vertex color or | 16 * matrix. It also leaves coverage untouched. Behind the scenes, we may add per
vertex color or |
17 * local coords. | 17 * local coords. |
18 */ | 18 */ |
19 typedef GrDefaultGeoProcFactory Flag; | 19 typedef GrDefaultGeoProcFactory Flag; |
20 | 20 |
21 class DefaultGeoProc : public GrGeometryProcessor { | 21 class DefaultGeoProc : public GrGeometryProcessor { |
22 public: | 22 public: |
23 static GrGeometryProcessor* Create(uint32_t gpTypeFlags, | 23 static GrGeometryProcessor* Create(uint32_t gpTypeFlags, |
24 GrColor color, | 24 GrColor color, |
25 const SkMatrix& viewMatrix, | 25 const SkMatrix& viewMatrix, |
26 const SkMatrix& localMatrix, | 26 const SkMatrix& localMatrix, |
27 bool usesLocalCoords, | |
28 bool coverageIgnored, | |
29 uint8_t coverage) { | 27 uint8_t coverage) { |
30 return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags, | 28 return SkNEW_ARGS(DefaultGeoProc, (gpTypeFlags, |
31 color, | 29 color, |
32 viewMatrix, | 30 viewMatrix, |
33 localMatrix, | 31 localMatrix, |
34 coverage, | 32 coverage)); |
35 usesLocalCoords, | |
36 coverageIgnored)); | |
37 } | 33 } |
38 | 34 |
39 const char* name() const override { return "DefaultGeometryProcessor"; } | 35 const char* name() const override { return "DefaultGeometryProcessor"; } |
40 | 36 |
41 const Attribute* inPosition() const { return fInPosition; } | 37 const Attribute* inPosition() const { return fInPosition; } |
42 const Attribute* inColor() const { return fInColor; } | 38 const Attribute* inColor() const { return fInColor; } |
43 const Attribute* inLocalCoords() const { return fInLocalCoords; } | 39 const Attribute* inLocalCoords() const { return fInLocalCoords; } |
44 const Attribute* inCoverage() const { return fInCoverage; } | 40 const Attribute* inCoverage() const { return fInCoverage; } |
45 GrColor color() const { return fColor; } | 41 GrColor color() const { return fColor; } |
46 bool colorIgnored() const { return GrColor_ILLEGAL == fColor; } | |
47 bool hasVertexColor() const { return SkToBool(fInColor); } | |
48 const SkMatrix& viewMatrix() const { return fViewMatrix; } | 42 const SkMatrix& viewMatrix() const { return fViewMatrix; } |
49 const SkMatrix& localMatrix() const { return fLocalMatrix; } | 43 const SkMatrix& localMatrix() const { return fLocalMatrix; } |
50 bool usesLocalCoords() const { return fUsesLocalCoords; } | |
51 uint8_t coverage() const { return fCoverage; } | 44 uint8_t coverage() const { return fCoverage; } |
52 bool coverageIgnored() const { return fCoverageIgnored; } | 45 |
53 bool hasVertexCoverage() const { return SkToBool(fInCoverage); } | 46 void initBatchTracker(GrBatchTracker* bt, const GrPipelineInfo& init) const
override { |
| 47 BatchTracker* local = bt->cast<BatchTracker>(); |
| 48 local->fInputColorType = GetColorInputType(&local->fColor, this->color()
, init, |
| 49 SkToBool(fInColor)); |
| 50 |
| 51 bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored
; |
| 52 bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage(); |
| 53 if (init.fCoverageIgnored) { |
| 54 local->fInputCoverageType = kIgnored_GrGPInput; |
| 55 } else if (covIsSolidWhite) { |
| 56 local->fInputCoverageType = kAllOnes_GrGPInput; |
| 57 } else if (hasVertexCoverage) { |
| 58 SkASSERT(fInCoverage); |
| 59 local->fInputCoverageType = kAttribute_GrGPInput; |
| 60 } else { |
| 61 local->fInputCoverageType = kUniform_GrGPInput; |
| 62 local->fCoverage = this->coverage(); |
| 63 } |
| 64 local->fUsesLocalCoords = init.fUsesLocalCoords; |
| 65 } |
54 | 66 |
55 class GLProcessor : public GrGLGeometryProcessor { | 67 class GLProcessor : public GrGLGeometryProcessor { |
56 public: | 68 public: |
57 GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&) | 69 GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&) |
58 : fColor(GrColor_ILLEGAL), fCoverage(0xff) {} | 70 : fColor(GrColor_ILLEGAL), fCoverage(0xff) {} |
59 | 71 |
60 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { | 72 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { |
61 const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); | 73 const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); |
62 GrGLGPBuilder* pb = args.fPB; | 74 GrGLGPBuilder* pb = args.fPB; |
63 GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder(); | 75 GrGLVertexBuilder* vsBuilder = pb->getVertexShaderBuilder(); |
64 GrGLFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); | 76 GrGLFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); |
| 77 const BatchTracker& local = args.fBT.cast<BatchTracker>(); |
65 | 78 |
66 // emit attributes | 79 // emit attributes |
67 vsBuilder->emitAttributes(gp); | 80 vsBuilder->emitAttributes(gp); |
68 | 81 |
69 // Setup pass through color | 82 // Setup pass through color |
70 if (!gp.colorIgnored()) { | 83 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputC
olor, gp.inColor(), |
71 if (gp.hasVertexColor()) { | 84 &fColorUniform); |
72 pb->addPassThroughAttribute(gp.inColor(), args.fOutputColor)
; | |
73 } else { | |
74 this->setupUniformColor(pb, args.fOutputColor, &fColorUnifor
m); | |
75 } | |
76 } | |
77 | |
78 // Setup position | 85 // Setup position |
79 this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatri
x()); | 86 this->setupPosition(pb, gpArgs, gp.inPosition()->fName, gp.viewMatri
x()); |
80 | 87 |
81 if (gp.inLocalCoords()) { | 88 if (gp.inLocalCoords()) { |
82 // emit transforms with explicit local coords | 89 // emit transforms with explicit local coords |
83 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inLocalCoords(
)->fName, | 90 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inLocalCoords(
)->fName, |
84 gp.localMatrix(), args.fTransformsIn, args.
fTransformsOut); | 91 gp.localMatrix(), args.fTransformsIn, args.
fTransformsOut); |
85 } else { | 92 } else { |
86 // emit transforms with position | 93 // emit transforms with position |
87 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->
fName, | 94 this->emitTransforms(pb, gpArgs->fPositionVar, gp.inPosition()->
fName, |
88 gp.localMatrix(), args.fTransformsIn, args.
fTransformsOut); | 95 gp.localMatrix(), args.fTransformsIn, args.
fTransformsOut); |
89 } | 96 } |
90 | 97 |
91 // Setup coverage as pass through | 98 // Setup coverage as pass through |
92 if (!gp.coverageIgnored()) { | 99 if (kUniform_GrGPInput == local.fInputCoverageType) { |
93 if (gp.hasVertexCoverage()) { | 100 const char* fragCoverage; |
94 fs->codeAppendf("float alpha = 1.0;"); | 101 fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_
Visibility, |
95 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); | 102 kFloat_GrSLType, |
96 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); | 103 kDefault_GrSLPrecision, |
97 } else if (gp.coverage() == 0xff) { | 104 "Coverage", |
98 fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); | 105 &fragCoverage); |
99 } else { | 106 fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCove
rage); |
100 const char* fragCoverage; | 107 } else if (kAttribute_GrGPInput == local.fInputCoverageType) { |
101 fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragm
ent_Visibility, | 108 SkASSERT(gp.inCoverage()); |
102 kFloat_GrSLType, | 109 fs->codeAppendf("float alpha = 1.0;"); |
103 kDefault_GrSLPrecision, | 110 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); |
104 "Coverage", | 111 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); |
105 &fragCoverage); | 112 } else if (kAllOnes_GrGPInput == local.fInputCoverageType) { |
106 fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, frag
Coverage); | 113 fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); |
107 } | |
108 } | 114 } |
109 } | 115 } |
110 | 116 |
111 static inline void GenKey(const GrGeometryProcessor& gp, | 117 static inline void GenKey(const GrGeometryProcessor& gp, |
112 const GrBatchTracker& bt, | 118 const GrBatchTracker& bt, |
113 const GrGLSLCaps&, | 119 const GrGLSLCaps&, |
114 GrProcessorKeyBuilder* b) { | 120 GrProcessorKeyBuilder* b) { |
115 const DefaultGeoProc& def = gp.cast<DefaultGeoProc>(); | 121 const DefaultGeoProc& def = gp.cast<DefaultGeoProc>(); |
| 122 const BatchTracker& local = bt.cast<BatchTracker>(); |
116 uint32_t key = def.fFlags; | 123 uint32_t key = def.fFlags; |
117 key |= def.colorIgnored() << 8; | 124 key |= local.fInputColorType << 8 | local.fInputCoverageType << 16; |
118 key |= def.coverageIgnored() << 9; | 125 key |= local.fUsesLocalCoords && def.localMatrix().hasPerspective()
? 0x1 << 24 : 0x0; |
119 key |= def.hasVertexColor() << 10; | |
120 key |= def.hasVertexCoverage() << 11; | |
121 key |= def.coverage() == 0xff ? 0x1 << 12 : 0; | |
122 key |= def.usesLocalCoords() && def.localMatrix().hasPerspective() ?
0x1 << 24 : 0x0; | |
123 key |= ComputePosKey(def.viewMatrix()) << 25; | 126 key |= ComputePosKey(def.viewMatrix()) << 25; |
124 b->add32(key); | 127 b->add32(key); |
125 } | 128 } |
126 | 129 |
127 virtual void setData(const GrGLProgramDataManager& pdman, | 130 virtual void setData(const GrGLProgramDataManager& pdman, |
128 const GrPrimitiveProcessor& gp, | 131 const GrPrimitiveProcessor& gp, |
129 const GrBatchTracker& bt) override { | 132 const GrBatchTracker& bt) override { |
130 const DefaultGeoProc& dgp = gp.cast<DefaultGeoProc>(); | 133 const DefaultGeoProc& dgp = gp.cast<DefaultGeoProc>(); |
131 this->setUniformViewMatrix(pdman, dgp.viewMatrix()); | 134 this->setUniformViewMatrix(pdman, dgp.viewMatrix()); |
132 | 135 |
133 if (dgp.color() != fColor && !dgp.hasVertexColor()) { | 136 const BatchTracker& local = bt.cast<BatchTracker>(); |
| 137 if (kUniform_GrGPInput == local.fInputColorType && local.fColor != f
Color) { |
134 GrGLfloat c[4]; | 138 GrGLfloat c[4]; |
135 GrColorToRGBAFloat(dgp.color(), c); | 139 GrColorToRGBAFloat(local.fColor, c); |
136 pdman.set4fv(fColorUniform, 1, c); | 140 pdman.set4fv(fColorUniform, 1, c); |
137 fColor = dgp.color(); | 141 fColor = local.fColor; |
138 } | 142 } |
139 | 143 if (kUniform_GrGPInput == local.fInputCoverageType && local.fCoverag
e != fCoverage) { |
140 if (dgp.coverage() != fCoverage && !dgp.hasVertexCoverage()) { | 144 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCove
rage)); |
141 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(dgp.coverag
e())); | 145 fCoverage = local.fCoverage; |
142 fCoverage = dgp.coverage(); | |
143 } | 146 } |
144 } | 147 } |
145 | 148 |
146 void setTransformData(const GrPrimitiveProcessor& primProc, | 149 void setTransformData(const GrPrimitiveProcessor& primProc, |
147 const GrGLProgramDataManager& pdman, | 150 const GrGLProgramDataManager& pdman, |
148 int index, | 151 int index, |
149 const SkTArray<const GrCoordTransform*, true>& tra
nsforms) override { | 152 const SkTArray<const GrCoordTransform*, true>& tra
nsforms) override { |
150 this->setTransformDataHelper<DefaultGeoProc>(primProc, pdman, index,
transforms); | 153 this->setTransformDataHelper<DefaultGeoProc>(primProc, pdman, index,
transforms); |
151 } | 154 } |
152 | 155 |
(...skipping 15 matching lines...) Expand all Loading... |
168 virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, | 171 virtual GrGLPrimitiveProcessor* createGLInstance(const GrBatchTracker& bt, |
169 const GrGLSLCaps&) const ov
erride { | 172 const GrGLSLCaps&) const ov
erride { |
170 return SkNEW_ARGS(GLProcessor, (*this, bt)); | 173 return SkNEW_ARGS(GLProcessor, (*this, bt)); |
171 } | 174 } |
172 | 175 |
173 private: | 176 private: |
174 DefaultGeoProc(uint32_t gpTypeFlags, | 177 DefaultGeoProc(uint32_t gpTypeFlags, |
175 GrColor color, | 178 GrColor color, |
176 const SkMatrix& viewMatrix, | 179 const SkMatrix& viewMatrix, |
177 const SkMatrix& localMatrix, | 180 const SkMatrix& localMatrix, |
178 uint8_t coverage, | 181 uint8_t coverage) |
179 bool usesLocalCoords, | |
180 bool coverageIgnored) | |
181 : fInPosition(NULL) | 182 : fInPosition(NULL) |
182 , fInColor(NULL) | 183 , fInColor(NULL) |
183 , fInLocalCoords(NULL) | 184 , fInLocalCoords(NULL) |
184 , fInCoverage(NULL) | 185 , fInCoverage(NULL) |
185 , fColor(color) | 186 , fColor(color) |
186 , fViewMatrix(viewMatrix) | 187 , fViewMatrix(viewMatrix) |
187 , fLocalMatrix(localMatrix) | 188 , fLocalMatrix(localMatrix) |
188 , fCoverage(coverage) | 189 , fCoverage(coverage) |
189 , fFlags(gpTypeFlags) | 190 , fFlags(gpTypeFlags) { |
190 , fUsesLocalCoords(usesLocalCoords) | |
191 , fCoverageIgnored(coverageIgnored) { | |
192 this->initClassID<DefaultGeoProc>(); | 191 this->initClassID<DefaultGeoProc>(); |
193 bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_G
PType); | 192 bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_G
PType); |
194 bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLo
calCoord_GPType); | 193 bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLo
calCoord_GPType); |
195 bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCove
rage_GPType); | 194 bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCove
rage_GPType); |
196 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVe
rtexAttribType)); | 195 fInPosition = &this->addVertexAttrib(Attribute("inPosition", kVec2f_GrVe
rtexAttribType)); |
197 if (hasColor) { | 196 if (hasColor) { |
198 fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVer
texAttribType)); | 197 fInColor = &this->addVertexAttrib(Attribute("inColor", kVec4ub_GrVer
texAttribType)); |
199 } | 198 } |
200 if (hasLocalCoord) { | 199 if (hasLocalCoord) { |
201 fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord", | 200 fInLocalCoords = &this->addVertexAttrib(Attribute("inLocalCoord", |
202 kVec2f_GrVertexAtt
ribType)); | 201 kVec2f_GrVertexA
ttribType)); |
203 this->setHasLocalCoords(); | 202 this->setHasLocalCoords(); |
204 } | 203 } |
205 if (hasCoverage) { | 204 if (hasCoverage) { |
206 fInCoverage = &this->addVertexAttrib(Attribute("inCoverage", | 205 fInCoverage = &this->addVertexAttrib(Attribute("inCoverage", |
207 kFloat_GrVertexAttr
ibType)); | 206 kFloat_GrVertexAttr
ibType)); |
208 } | 207 } |
209 } | 208 } |
210 | 209 |
| 210 struct BatchTracker { |
| 211 GrGPInput fInputColorType; |
| 212 GrGPInput fInputCoverageType; |
| 213 GrColor fColor; |
| 214 GrColor fCoverage; |
| 215 bool fUsesLocalCoords; |
| 216 }; |
| 217 |
211 const Attribute* fInPosition; | 218 const Attribute* fInPosition; |
212 const Attribute* fInColor; | 219 const Attribute* fInColor; |
213 const Attribute* fInLocalCoords; | 220 const Attribute* fInLocalCoords; |
214 const Attribute* fInCoverage; | 221 const Attribute* fInCoverage; |
215 GrColor fColor; | 222 GrColor fColor; |
216 SkMatrix fViewMatrix; | 223 SkMatrix fViewMatrix; |
217 SkMatrix fLocalMatrix; | 224 SkMatrix fLocalMatrix; |
218 uint8_t fCoverage; | 225 uint8_t fCoverage; |
219 uint32_t fFlags; | 226 uint32_t fFlags; |
220 bool fUsesLocalCoords; | |
221 bool fCoverageIgnored; | |
222 | 227 |
223 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 228 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
224 | 229 |
225 typedef GrGeometryProcessor INHERITED; | 230 typedef GrGeometryProcessor INHERITED; |
226 }; | 231 }; |
227 | 232 |
228 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); | 233 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); |
229 | 234 |
230 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, | 235 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, |
231 GrContext*, | 236 GrContext*, |
232 const GrDrawTargetCaps& caps, | 237 const GrDrawTargetCaps& caps, |
233 GrTexture*[]) { | 238 GrTexture*[]) { |
234 uint32_t flags = 0; | 239 uint32_t flags = 0; |
235 if (random->nextBool()) { | 240 if (random->nextBool()) { |
236 flags |= GrDefaultGeoProcFactory::kColor_GPType; | 241 flags |= GrDefaultGeoProcFactory::kColor_GPType; |
237 } | 242 } |
238 if (random->nextBool()) { | 243 if (random->nextBool()) { |
239 flags |= GrDefaultGeoProcFactory::kCoverage_GPType; | 244 flags |= GrDefaultGeoProcFactory::kCoverage_GPType; |
240 } | 245 } |
241 if (random->nextBool()) { | 246 if (random->nextBool()) { |
242 flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType; | 247 flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType; |
243 } | 248 } |
244 | 249 |
245 return DefaultGeoProc::Create(flags, | 250 return DefaultGeoProc::Create(flags, |
246 GrRandomColor(random), | 251 GrRandomColor(random), |
247 GrTest::TestMatrix(random), | 252 GrTest::TestMatrix(random), |
248 GrTest::TestMatrix(random), | 253 GrTest::TestMatrix(random), |
249 random->nextBool(), | |
250 random->nextBool(), | |
251 GrRandomCoverage(random)); | 254 GrRandomCoverage(random)); |
252 } | 255 } |
253 | 256 |
254 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags, | 257 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags, |
255 GrColor color, | 258 GrColor color, |
256 bool usesLocalCoords, | |
257 bool coverageIgnored, | |
258 const SkMatrix& viewM
atrix, | 259 const SkMatrix& viewM
atrix, |
259 const SkMatrix& local
Matrix, | 260 const SkMatrix& local
Matrix, |
260 uint8_t coverage) { | 261 uint8_t coverage) { |
261 return DefaultGeoProc::Create(gpTypeFlags, | 262 return DefaultGeoProc::Create(gpTypeFlags, |
262 color, | 263 color, |
263 viewMatrix, | 264 viewMatrix, |
264 localMatrix, | 265 localMatrix, |
265 usesLocalCoords, | |
266 coverageIgnored, | |
267 coverage); | 266 coverage); |
268 } | 267 } |
OLD | NEW |