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 "GrDrawState.h" | 10 #include "GrDrawState.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 bool opaqueVertexColors) { | 25 bool opaqueVertexColors) { |
26 return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags, opaqueV
ertexColors)); | 26 return SkNEW_ARGS(DefaultGeoProc, (color, coverage, gpTypeFlags, opaqueV
ertexColors)); |
27 } | 27 } |
28 | 28 |
29 virtual const char* name() const SK_OVERRIDE { return "DefaultGeometryProces
sor"; } | 29 virtual const char* name() const SK_OVERRIDE { return "DefaultGeometryProces
sor"; } |
30 | 30 |
31 const GrAttribute* inPosition() const { return fInPosition; } | 31 const GrAttribute* inPosition() const { return fInPosition; } |
32 const GrAttribute* inColor() const { return fInColor; } | 32 const GrAttribute* inColor() const { return fInColor; } |
33 const GrAttribute* inLocalCoords() const { return fInLocalCoords; } | 33 const GrAttribute* inLocalCoords() const { return fInLocalCoords; } |
34 const GrAttribute* inCoverage() const { return fInCoverage; } | 34 const GrAttribute* inCoverage() const { return fInCoverage; } |
| 35 uint8_t coverage() const { return fCoverage; } |
| 36 |
| 37 void initBatchTracker(GrBatchTracker* bt, const InitBT& init) const SK_OVERR
IDE { |
| 38 BatchTracker* local = bt->cast<BatchTracker>(); |
| 39 local->fInputColorType = GetColorInputType(&local->fColor, this->color()
, init, |
| 40 SkToBool(fInColor)); |
| 41 |
| 42 bool hasVertexCoverage = SkToBool(fInCoverage) && !init.fCoverageIgnored
; |
| 43 bool covIsSolidWhite = !hasVertexCoverage && 0xff == this->coverage(); |
| 44 if (covIsSolidWhite) { |
| 45 local->fInputCoverageType = kAllOnes_GrGPInput; |
| 46 } else if (!hasVertexCoverage) { |
| 47 local->fInputCoverageType = kUniform_GrGPInput; |
| 48 local->fCoverage = this->coverage(); |
| 49 } else if (hasVertexCoverage) { |
| 50 SkASSERT(fInCoverage); |
| 51 local->fInputCoverageType = kAttribute_GrGPInput; |
| 52 } else { |
| 53 local->fInputCoverageType = kIgnored_GrGPInput; |
| 54 } |
| 55 } |
| 56 |
| 57 bool onCanMakeEqual(const GrBatchTracker& m, const GrBatchTracker& t) const
SK_OVERRIDE { |
| 58 const BatchTracker& mine = m.cast<BatchTracker>(); |
| 59 const BatchTracker& theirs = t.cast<BatchTracker>(); |
| 60 return CanCombineOutput(mine.fInputColorType, mine.fColor, |
| 61 theirs.fInputColorType, theirs.fColor) && |
| 62 CanCombineOutput(mine.fInputCoverageType, mine.fCoverage, |
| 63 theirs.fInputCoverageType, theirs.fCoverage); |
| 64 } |
35 | 65 |
36 class GLProcessor : public GrGLGeometryProcessor { | 66 class GLProcessor : public GrGLGeometryProcessor { |
37 public: | 67 public: |
38 GLProcessor(const GrGeometryProcessor&, | 68 GLProcessor(const GrGeometryProcessor& gp, const GrBatchTracker&) |
39 const GrBatchTracker&) {} | 69 : fColor(GrColor_ILLEGAL), fCoverage(0xff) {} |
40 | 70 |
41 virtual void emitCode(const EmitArgs& args) SK_OVERRIDE { | 71 virtual void emitCode(const EmitArgs& args) SK_OVERRIDE { |
42 const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); | 72 const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); |
43 GrGLVertexBuilder* vs = args.fPB->getVertexShaderBuilder(); | 73 GrGLGPBuilder* pb = args.fPB; |
| 74 GrGLVertexBuilder* vs = pb->getVertexShaderBuilder(); |
| 75 GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); |
| 76 const BatchTracker& local = args.fBT.cast<BatchTracker>(); |
44 | 77 |
45 vs->codeAppendf("%s = %s;", vs->positionCoords(), gp.inPosition()->f
Name); | 78 vs->codeAppendf("%s = %s;", vs->positionCoords(), gp.inPosition()->f
Name); |
46 | 79 |
47 // Setup pass through color | 80 // Setup pass through color |
48 if (gp.inColor()) { | 81 this->setupColorPassThrough(pb, local.fInputColorType, args.fOutputC
olor, gp.inColor(), |
49 args.fPB->addPassThroughAttribute(gp.inColor(), args.fOutputColo
r); | 82 &fColorUniform); |
50 } | |
51 | 83 |
52 // Setup local coords if needed | 84 // Setup local coords if needed |
53 if (gp.inLocalCoords()) { | 85 if (gp.inLocalCoords()) { |
54 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inLocalCoords(
)->fName); | 86 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inLocalCoords(
)->fName); |
55 } else { | 87 } else { |
56 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inPosition()->
fName); | 88 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inPosition()->
fName); |
57 } | 89 } |
58 | 90 |
59 // setup position varying | 91 // setup position varying |
60 vs->codeAppendf("%s = %s * vec3(%s, 1);", vs->glPosition(), vs->uVie
wM(), | 92 vs->codeAppendf("%s = %s * vec3(%s, 1);", vs->glPosition(), vs->uVie
wM(), |
61 gp.inPosition()->fName); | 93 gp.inPosition()->fName); |
62 | 94 |
63 // Setup coverage as pass through | 95 // Setup coverage as pass through |
64 GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); | 96 if (kUniform_GrGPInput == local.fInputCoverageType) { |
65 fs->codeAppendf("float alpha = 1.0;"); | 97 const char* fragCoverage; |
66 if (gp.inCoverage()) { | 98 fCoverageUniform = pb->addUniform(GrGLProgramBuilder::kFragment_
Visibility, |
| 99 kFloat_GrSLType, |
| 100 kDefault_GrSLPrecision, |
| 101 "Coverage", |
| 102 &fragCoverage); |
| 103 fs->codeAppendf("%s = vec4(%s);", args.fOutputCoverage, fragCove
rage); |
| 104 } else if (kAttribute_GrGPInput == local.fInputCoverageType) { |
| 105 SkASSERT(gp.inCoverage()); |
| 106 fs->codeAppendf("float alpha = 1.0;"); |
67 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); | 107 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); |
| 108 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); |
| 109 } else if (kAllOnes_GrGPInput == local.fInputCoverageType) { |
| 110 fs->codeAppendf("%s = vec4(1);", args.fOutputCoverage); |
68 } | 111 } |
69 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); | |
70 } | 112 } |
71 | 113 |
72 static inline void GenKey(const GrGeometryProcessor& gp, | 114 static inline void GenKey(const GrGeometryProcessor& gp, |
73 const GrBatchTracker&, | 115 const GrBatchTracker& bt, |
74 const GrGLCaps&, | 116 const GrGLCaps&, |
75 GrProcessorKeyBuilder* b) { | 117 GrProcessorKeyBuilder* b) { |
76 const DefaultGeoProc& def = gp.cast<DefaultGeoProc>(); | 118 const DefaultGeoProc& def = gp.cast<DefaultGeoProc>(); |
77 b->add32(def.fFlags); | 119 b->add32(def.fFlags); |
| 120 |
| 121 const BatchTracker& local = bt.cast<BatchTracker>(); |
| 122 b->add32(local.fInputColorType | local.fInputCoverageType << 16); |
78 } | 123 } |
79 | 124 |
80 virtual void setData(const GrGLProgramDataManager&, | 125 virtual void setData(const GrGLProgramDataManager& pdman, |
81 const GrGeometryProcessor&, | 126 const GrPrimitiveProcessor& gp, |
82 const GrBatchTracker&) SK_OVERRIDE {} | 127 const GrBatchTracker& bt) SK_OVERRIDE { |
| 128 const BatchTracker& local = bt.cast<BatchTracker>(); |
| 129 if (kUniform_GrGPInput == local.fInputColorType && local.fColor != f
Color) { |
| 130 GrGLfloat c[4]; |
| 131 GrColorToRGBAFloat(local.fColor, c); |
| 132 pdman.set4fv(fColorUniform, 1, c); |
| 133 fColor = local.fColor; |
| 134 } |
| 135 if (kUniform_GrGPInput == local.fInputCoverageType && local.fCoverag
e != fCoverage) { |
| 136 pdman.set1f(fCoverageUniform, GrNormalizeByteToFloat(local.fCove
rage)); |
| 137 fCoverage = local.fCoverage; |
| 138 } |
| 139 } |
83 | 140 |
84 private: | 141 private: |
| 142 GrColor fColor; |
| 143 uint8_t fCoverage; |
| 144 UniformHandle fColorUniform; |
| 145 UniformHandle fCoverageUniform; |
| 146 |
85 typedef GrGLGeometryProcessor INHERITED; | 147 typedef GrGLGeometryProcessor INHERITED; |
86 }; | 148 }; |
87 | 149 |
88 virtual void getGLProcessorKey(const GrBatchTracker& bt, | 150 virtual void getGLProcessorKey(const GrBatchTracker& bt, |
89 const GrGLCaps& caps, | 151 const GrGLCaps& caps, |
90 GrProcessorKeyBuilder* b) const SK_OVERRIDE { | 152 GrProcessorKeyBuilder* b) const SK_OVERRIDE { |
91 GLProcessor::GenKey(*this, bt, caps, b); | 153 GLProcessor::GenKey(*this, bt, caps, b); |
92 } | 154 } |
93 | 155 |
94 virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) co
nst SK_OVERRIDE { | 156 virtual GrGLGeometryProcessor* createGLInstance(const GrBatchTracker& bt) co
nst SK_OVERRIDE { |
95 return SkNEW_ARGS(GLProcessor, (*this, bt)); | 157 return SkNEW_ARGS(GLProcessor, (*this, bt)); |
96 } | 158 } |
97 | 159 |
98 private: | 160 private: |
99 DefaultGeoProc(GrColor color, uint8_t coverage, uint32_t gpTypeFlags, bool o
paqueVertexColors) | 161 DefaultGeoProc(GrColor color, uint8_t coverage, uint32_t gpTypeFlags, bool o
paqueVertexColors) |
100 : INHERITED(color, opaqueVertexColors, coverage) | 162 : INHERITED(color, opaqueVertexColors) |
101 , fInPosition(NULL) | 163 , fInPosition(NULL) |
102 , fInColor(NULL) | 164 , fInColor(NULL) |
103 , fInLocalCoords(NULL) | 165 , fInLocalCoords(NULL) |
104 , fInCoverage(NULL) | 166 , fInCoverage(NULL) |
| 167 , fCoverage(coverage) |
105 , fFlags(gpTypeFlags) { | 168 , fFlags(gpTypeFlags) { |
106 this->initClassID<DefaultGeoProc>(); | 169 this->initClassID<DefaultGeoProc>(); |
107 bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_G
PType); | 170 bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_G
PType); |
108 bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLo
calCoord_GPType); | 171 bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLo
calCoord_GPType); |
109 bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCove
rage_GPType); | 172 bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCove
rage_GPType); |
110 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_Gr
VertexAttribType)); | 173 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_Gr
VertexAttribType)); |
111 if (hasColor) { | 174 if (hasColor) { |
112 fInColor = &this->addVertexAttrib(GrAttribute("inColor", kVec4ub_GrV
ertexAttribType)); | 175 fInColor = &this->addVertexAttrib(GrAttribute("inColor", kVec4ub_GrV
ertexAttribType)); |
113 this->setHasVertexColor(); | 176 this->setHasVertexColor(); |
114 } | 177 } |
115 if (hasLocalCoord) { | 178 if (hasLocalCoord) { |
116 fInLocalCoords = &this->addVertexAttrib(GrAttribute("inLocalCoord", | 179 fInLocalCoords = &this->addVertexAttrib(GrAttribute("inLocalCoord", |
117 kVec2f_GrVertexA
ttribType)); | 180 kVec2f_GrVertexA
ttribType)); |
118 this->setHasLocalCoords(); | 181 this->setHasLocalCoords(); |
119 } | 182 } |
120 if (hasCoverage) { | 183 if (hasCoverage) { |
121 fInCoverage = &this->addVertexAttrib(GrAttribute("inCoverage", | 184 fInCoverage = &this->addVertexAttrib(GrAttribute("inCoverage", |
122 kFloat_GrVertexAttr
ibType)); | 185 kFloat_GrVertexAttr
ibType)); |
123 this->setHasVertexCoverage(); | |
124 } | 186 } |
125 } | 187 } |
126 | 188 |
127 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { | 189 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { |
128 const DefaultGeoProc& gp = other.cast<DefaultGeoProc>(); | 190 const DefaultGeoProc& gp = other.cast<DefaultGeoProc>(); |
129 return gp.fFlags == this->fFlags; | 191 return gp.fFlags == this->fFlags; |
130 } | 192 } |
131 | 193 |
132 virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const
SK_OVERRIDE { | 194 virtual void onGetInvariantOutputCoverage(GrInitInvariantOutput* out) const
SK_OVERRIDE { |
133 if (fInCoverage) { | 195 if (fInCoverage) { |
134 out->setUnknownSingleComponent(); | 196 out->setUnknownSingleComponent(); |
135 } else { | 197 } else { |
136 // uniform coverage | 198 // uniform coverage |
137 out->setKnownSingleComponent(this->coverage()); | 199 out->setKnownSingleComponent(this->coverage()); |
138 } | 200 } |
139 } | 201 } |
140 | 202 |
| 203 struct BatchTracker { |
| 204 GrGPInput fInputColorType; |
| 205 GrGPInput fInputCoverageType; |
| 206 GrColor fColor; |
| 207 GrColor fCoverage; |
| 208 }; |
| 209 |
141 const GrAttribute* fInPosition; | 210 const GrAttribute* fInPosition; |
142 const GrAttribute* fInColor; | 211 const GrAttribute* fInColor; |
143 const GrAttribute* fInLocalCoords; | 212 const GrAttribute* fInLocalCoords; |
144 const GrAttribute* fInCoverage; | 213 const GrAttribute* fInCoverage; |
| 214 uint8_t fCoverage; |
145 uint32_t fFlags; | 215 uint32_t fFlags; |
146 | 216 |
147 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 217 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
148 | 218 |
149 typedef GrGeometryProcessor INHERITED; | 219 typedef GrGeometryProcessor INHERITED; |
150 }; | 220 }; |
151 | 221 |
152 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); | 222 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); |
153 | 223 |
154 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, | 224 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, |
(...skipping 14 matching lines...) Expand all Loading... |
169 return DefaultGeoProc::Create(GrRandomColor(random), GrRandomCoverage(random
), | 239 return DefaultGeoProc::Create(GrRandomColor(random), GrRandomCoverage(random
), |
170 flags, random->nextBool()); | 240 flags, random->nextBool()); |
171 } | 241 } |
172 | 242 |
173 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(GrColor color, | 243 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(GrColor color, |
174 uint32_t gpTypeFlags, | 244 uint32_t gpTypeFlags, |
175 bool opaqueVertexColo
rs, | 245 bool opaqueVertexColo
rs, |
176 uint8_t coverage) { | 246 uint8_t coverage) { |
177 return DefaultGeoProc::Create(color, coverage, gpTypeFlags, opaqueVertexColo
rs); | 247 return DefaultGeoProc::Create(color, coverage, gpTypeFlags, opaqueVertexColo
rs); |
178 } | 248 } |
OLD | NEW |