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 "gl/builders/GrGLProgramBuilder.h" | |
11 #include "gl/GrGLGeometryProcessor.h" | |
12 #include "GrDrawState.h" | 10 #include "GrDrawState.h" |
13 #include "GrInvariantOutput.h" | 11 #include "GrInvariantOutput.h" |
14 #include "GrTBackendProcessorFactory.h" | 12 #include "GrTBackendProcessorFactory.h" |
| 13 #include "gl/GrGLGeometryProcessor.h" |
| 14 #include "gl/builders/GrGLProgramBuilder.h" |
15 | 15 |
16 /* | 16 /* |
17 * The default Geometry Processor simply takes position and multiplies it by the
uniform view | 17 * The default Geometry Processor simply takes position and multiplies it by the
uniform view |
18 * matrix. It also leaves coverage untouched. Behind the scenes, we may add per
vertex color or | 18 * matrix. It also leaves coverage untouched. Behind the scenes, we may add per
vertex color or |
19 * local coords. | 19 * local coords. |
20 */ | 20 */ |
| 21 typedef GrDefaultGeoProcFactory Flag; |
| 22 |
21 class DefaultGeoProc : public GrGeometryProcessor { | 23 class DefaultGeoProc : public GrGeometryProcessor { |
22 public: | 24 public: |
23 static GrGeometryProcessor* Create(bool hasCoverage) { | 25 static GrGeometryProcessor* Create(uint32_t gpTypeFlags) { |
24 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProc, DefaultGeoProc, (hasCoverage
)); | 26 switch (gpTypeFlags) { |
25 return SkRef(gDefaultGeoProc); | 27 case Flag::kColor_GPType | Flag::kCoverage_GPType | Flag::kLocalCoor
d_GPType: { |
| 28 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcColLocCov, DefaultGeoP
roc, (gpTypeFlags)); |
| 29 return SkRef(gDefaultGeoProcColLocCov); |
| 30 } |
| 31 case Flag::kColor_GPType | Flag::kLocalCoord_GPType: { |
| 32 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcColLoc, DefaultGeoProc
, (gpTypeFlags)); |
| 33 return SkRef(gDefaultGeoProcColLoc); |
| 34 } |
| 35 case Flag::kColor_GPType | Flag::kCoverage_GPType: { |
| 36 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcColCov, DefaultGeoProc
, (gpTypeFlags)); |
| 37 return SkRef(gDefaultGeoProcColCov); |
| 38 } |
| 39 case Flag::kColor_GPType: { |
| 40 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcCol, DefaultGeoProc, (
gpTypeFlags)); |
| 41 return SkRef(gDefaultGeoProcCol); |
| 42 } |
| 43 case Flag::kLocalCoord_GPType | Flag::kCoverage_GPType: { |
| 44 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcLocCov, DefaultGeoProc
, (gpTypeFlags)); |
| 45 return SkRef(gDefaultGeoProcLocCov); |
| 46 } |
| 47 case Flag::kLocalCoord_GPType: { |
| 48 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcLoc, DefaultGeoProc, (
gpTypeFlags)); |
| 49 return SkRef(gDefaultGeoProcLoc); |
| 50 } |
| 51 case Flag::kCoverage_GPType: { |
| 52 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProcCov, DefaultGeoProc, (
gpTypeFlags)); |
| 53 return SkRef(gDefaultGeoProcCov); |
| 54 } |
| 55 case Flag::kPosition_GPType: { |
| 56 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProc, DefaultGeoProc, (gpT
ypeFlags)); |
| 57 return SkRef(gDefaultGeoProc); |
| 58 } |
| 59 default: |
| 60 SkFAIL("Incomplete Switch"); |
| 61 return NULL; |
| 62 } |
26 } | 63 } |
27 | 64 |
28 static const char* Name() { return "DefaultGeometryProcessor"; } | 65 static const char* Name() { return "DefaultGeometryProcessor"; } |
29 | 66 |
30 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE { | 67 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE { |
31 return GrTBackendGeometryProcessorFactory<DefaultGeoProc>::getInstance()
; | 68 return GrTBackendGeometryProcessorFactory<DefaultGeoProc>::getInstance()
; |
32 } | 69 } |
33 | 70 |
| 71 const GrAttribute* inPosition() const { return fInPosition; } |
| 72 const GrAttribute* inColor() const { return fInColor; } |
| 73 const GrAttribute* inLocalCoords() const { return fInLocalCoords; } |
| 74 const GrAttribute* inCoverage() const { return fInCoverage; } |
| 75 |
34 class GLProcessor : public GrGLGeometryProcessor { | 76 class GLProcessor : public GrGLGeometryProcessor { |
35 public: | 77 public: |
36 GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&
) | 78 GLProcessor(const GrBackendProcessorFactory& factory, const GrProcessor&
) |
37 : INHERITED (factory) {} | 79 : INHERITED (factory) {} |
38 | 80 |
39 virtual void emitCode(const EmitArgs& args) SK_OVERRIDE { | 81 virtual void emitCode(const EmitArgs& args) SK_OVERRIDE { |
| 82 const DefaultGeoProc& gp = args.fGP.cast<DefaultGeoProc>(); |
40 GrGLVertexBuilder* vs = args.fPB->getVertexShaderBuilder(); | 83 GrGLVertexBuilder* vs = args.fPB->getVertexShaderBuilder(); |
41 | 84 |
| 85 vs->codeAppendf("%s = %s;", vs->positionCoords(), gp.inPosition()->f
Name); |
| 86 |
| 87 // Setup pass through color |
| 88 if (gp.inColor()) { |
| 89 args.fPB->addPassThroughAttribute(gp.inColor(), args.fOutputColo
r); |
| 90 } |
| 91 |
| 92 // Setup local coords if needed |
| 93 if (gp.inLocalCoords()) { |
| 94 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inLocalCoords(
)->fName); |
| 95 } else { |
| 96 vs->codeAppendf("%s = %s;", vs->localCoords(), gp.inPosition()->
fName); |
| 97 } |
| 98 |
42 // setup position varying | 99 // setup position varying |
43 vs->codeAppendf("%s = %s * vec3(%s, 1);", vs->glPosition(), vs->uVie
wM(), | 100 vs->codeAppendf("%s = %s * vec3(%s, 1);", vs->glPosition(), vs->uVie
wM(), |
44 vs->inPosition()); | 101 gp.inPosition()->fName); |
45 | 102 |
46 // output coverage in FS(pass through) | 103 // Setup coverage as pass through |
47 GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); | 104 GrGLGPFragmentBuilder* fs = args.fPB->getFragmentShaderBuilder(); |
48 fs->codeAppendf("%s = %s;", args.fOutput, GrGLSLExpr4(args.fInput).c
_str()); | 105 fs->codeAppendf("float alpha = 1.0;"); |
| 106 if (gp.inCoverage()) { |
| 107 args.fPB->addPassThroughAttribute(gp.inCoverage(), "alpha"); |
| 108 } |
| 109 fs->codeAppendf("%s = vec4(alpha);", args.fOutputCoverage); |
49 } | 110 } |
50 | 111 |
51 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcess
orKeyBuilder*) {} | 112 static inline void GenKey(const GrProcessor& gp, const GrGLCaps&, GrProc
essorKeyBuilder* b) { |
| 113 const DefaultGeoProc& def = gp.cast<DefaultGeoProc>(); |
| 114 b->add32(def.fFlags); |
| 115 } |
52 | 116 |
53 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&)
SK_OVERRIDE {} | 117 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&)
SK_OVERRIDE {} |
54 | 118 |
55 private: | 119 private: |
56 typedef GrGLGeometryProcessor INHERITED; | 120 typedef GrGLGeometryProcessor INHERITED; |
57 }; | 121 }; |
58 | 122 |
59 private: | 123 private: |
60 DefaultGeoProc(bool hasCoverageAttribute) : fHasCoverageAttribute(hasCoverag
eAttribute) {} | 124 DefaultGeoProc(uint32_t gpTypeFlags) |
| 125 : fInPosition(NULL) |
| 126 , fInColor(NULL) |
| 127 , fInLocalCoords(NULL) |
| 128 , fInCoverage(NULL) |
| 129 , fFlags(gpTypeFlags) { |
| 130 bool hasColor = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kColor_G
PType); |
| 131 bool hasLocalCoord = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kLo
calCoord_GPType); |
| 132 bool hasCoverage = SkToBool(gpTypeFlags & GrDefaultGeoProcFactory::kCove
rage_GPType); |
| 133 fInPosition = &this->addVertexAttrib(GrAttribute("inPosition", kVec2f_Gr
VertexAttribType)); |
| 134 if (hasColor) { |
| 135 fInColor = &this->addVertexAttrib(GrAttribute("inColor", kVec4ub_GrV
ertexAttribType)); |
| 136 this->setHasVertexColor(); |
| 137 } |
| 138 if (hasLocalCoord) { |
| 139 fInLocalCoords = &this->addVertexAttrib(GrAttribute("inLocalCoord", |
| 140 kVec2f_GrVertexA
ttribType)); |
| 141 this->setHasLocalCoords(); |
| 142 } |
| 143 if (hasCoverage) { |
| 144 fInCoverage = &this->addVertexAttrib(GrAttribute("inCoverage", |
| 145 kFloat_GrVertexAttr
ibType)); |
| 146 this->setHasVertexCoverage(); |
| 147 } |
| 148 } |
61 | 149 |
62 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { | 150 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { |
63 return true; | 151 const DefaultGeoProc& gp = other.cast<DefaultGeoProc>(); |
| 152 return gp.fFlags == this->fFlags; |
64 } | 153 } |
65 | 154 |
66 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE { | 155 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE { |
67 if (fHasCoverageAttribute) { | 156 if (fInCoverage) { |
68 inout->mulByUnknownAlpha(); | 157 inout->mulByUnknownAlpha(); |
69 } else { | 158 } else { |
70 inout->mulByKnownAlpha(255); | 159 inout->mulByKnownAlpha(255); |
71 } | 160 } |
72 } | 161 } |
73 | 162 |
| 163 const GrAttribute* fInPosition; |
| 164 const GrAttribute* fInColor; |
| 165 const GrAttribute* fInLocalCoords; |
| 166 const GrAttribute* fInCoverage; |
| 167 uint32_t fFlags; |
| 168 |
74 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 169 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
75 | 170 |
76 bool fHasCoverageAttribute; | |
77 | |
78 typedef GrFragmentProcessor INHERITED; | 171 typedef GrFragmentProcessor INHERITED; |
79 }; | 172 }; |
80 | 173 |
81 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); | 174 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); |
82 | 175 |
83 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, | 176 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, |
84 GrContext*, | 177 GrContext*, |
85 const GrDrawTargetCaps& caps, | 178 const GrDrawTargetCaps& caps, |
86 GrTexture*[]) { | 179 GrTexture*[]) { |
87 return DefaultGeoProc::Create(random->nextBool()); | 180 uint32_t flags = 0; |
| 181 if (random->nextBool()) { |
| 182 flags |= GrDefaultGeoProcFactory::kColor_GPType; |
| 183 } |
| 184 if (random->nextBool()) { |
| 185 flags |= GrDefaultGeoProcFactory::kCoverage_GPType; |
| 186 } |
| 187 if (random->nextBool()) { |
| 188 flags |= GrDefaultGeoProcFactory::kLocalCoord_GPType; |
| 189 } |
| 190 |
| 191 return DefaultGeoProc::Create(flags); |
88 } | 192 } |
89 | 193 |
90 // We use these arrays to customize our default GP. We only need 4 because we o
mit coverage if | 194 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(uint32_t gpTypeFlags)
{ |
91 // coverage is not requested in the flags to the create function. | 195 return DefaultGeoProc::Create(gpTypeFlags); |
92 GrVertexAttrib kDefaultPositionGeoProc[] = { | |
93 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBindin
g }, | |
94 { kFloat_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBindin
g }, | |
95 }; | |
96 | |
97 GrVertexAttrib kDefaultPosColorGeoProc[] = { | |
98 { kVec2f_GrVertexAttribType, 0, kPosition_Gr
VertexAttribBinding }, | |
99 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVer
texAttribBinding }, | |
100 { kFloat_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kCoverage_Gr
VertexAttribBinding }, | |
101 }; | |
102 | |
103 GrVertexAttrib kDefaultPosLocalCoordGeoProc[] = { | |
104 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBi
nding }, | |
105 { kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttrib
Binding }, | |
106 { kFloat_GrVertexAttribType, 2 * sizeof(SkPoint), kCoverage_GrVertexAttribBi
nding }, | |
107 }; | |
108 | |
109 GrVertexAttrib kDefaultPosColLocalCoordGeoProc[] = { | |
110 { kVec2f_GrVertexAttribType, 0, kPositio
n_GrVertexAttribBinding }, | |
111 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_G
rVertexAttribBinding }, | |
112 { kVec2f_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kLocalCo
ord_GrVertexAttribBinding }, | |
113 { kFloat_GrVertexAttribType, 2 * sizeof(SkPoint) + sizeof(GrColor), kCoverag
e_GrVertexAttribBinding }, | |
114 }; | |
115 | |
116 static size_t get_size(GrDefaultGeoProcFactory::GPType flag) { | |
117 switch (flag) { | |
118 case GrDefaultGeoProcFactory::kPosition_GPType: | |
119 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); | |
120 case GrDefaultGeoProcFactory::kColor_GPType: | |
121 return GrVertexAttribTypeSize(kVec4ub_GrVertexAttribType); | |
122 case GrDefaultGeoProcFactory::kLocalCoord_GPType: | |
123 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); | |
124 case GrDefaultGeoProcFactory::kCoverage_GPType: | |
125 return GrVertexAttribTypeSize(kFloat_GrVertexAttribType); | |
126 default: | |
127 SkFAIL("Should never get here"); | |
128 return 0; | |
129 } | |
130 } | 196 } |
131 | |
132 void GrDefaultGeoProcFactory::SetAttribs(GrDrawState* ds, uint32_t gpTypeFlags)
{ | |
133 SkASSERT(ds); | |
134 // always atleast position in the GP | |
135 size_t size = get_size(kPosition_GPType); | |
136 int count = 1; | |
137 | |
138 bool hasColor = SkToBool(gpTypeFlags & kColor_GPType); | |
139 bool hasLocalCoord = SkToBool(gpTypeFlags & kLocalCoord_GPType); | |
140 bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPType); | |
141 | |
142 if (hasColor) { | |
143 size += get_size(kColor_GPType); | |
144 count++; | |
145 if (hasLocalCoord) { | |
146 size += get_size(kLocalCoord_GPType); | |
147 count++; | |
148 if (hasCoverage) { | |
149 size += get_size(kCoverage_GPType); | |
150 count++; | |
151 ds->setVertexAttribs<kDefaultPosColLocalCoordGeoProc>(count, siz
e); | |
152 } else { | |
153 ds->setVertexAttribs<kDefaultPosColLocalCoordGeoProc>(count, siz
e); | |
154 | |
155 } | |
156 } else { | |
157 if (hasCoverage) { | |
158 size += get_size(kCoverage_GPType); | |
159 count++; | |
160 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); | |
161 } else { | |
162 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); | |
163 } | |
164 } | |
165 } else if (hasLocalCoord) { | |
166 size += get_size(kLocalCoord_GPType); | |
167 count++; | |
168 if (hasCoverage) { | |
169 size += get_size(kCoverage_GPType); | |
170 count++; | |
171 ds->setVertexAttribs<kDefaultPosLocalCoordGeoProc>(count, size); | |
172 } else { | |
173 ds->setVertexAttribs<kDefaultPosLocalCoordGeoProc>(count, size); | |
174 } | |
175 } else if (hasCoverage) { | |
176 size += get_size(kCoverage_GPType); | |
177 count++; | |
178 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); | |
179 } else { | |
180 // Just position | |
181 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); | |
182 } | |
183 } | |
184 | |
185 const GrGeometryProcessor* | |
186 GrDefaultGeoProcFactory::CreateAndSetAttribs(GrDrawState* ds, uint32_t gpTypeFla
gs) { | |
187 SetAttribs(ds, gpTypeFlags); | |
188 | |
189 bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPType); | |
190 return DefaultGeoProc::Create(hasCoverage); | |
191 } | |
192 | |
193 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(bool hasAttributeCove
rage) { | |
194 return DefaultGeoProc::Create(hasAttributeCoverage); | |
195 } | |
OLD | NEW |