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" | 10 #include "gl/builders/GrGLProgramBuilder.h" |
11 #include "gl/GrGLGeometryProcessor.h" | 11 #include "gl/GrGLGeometryProcessor.h" |
12 #include "GrDrawState.h" | 12 #include "GrDrawState.h" |
13 #include "GrInvariantOutput.h" | 13 #include "GrInvariantOutput.h" |
14 #include "GrTBackendProcessorFactory.h" | 14 #include "GrTBackendProcessorFactory.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 class DefaultGeoProc : public GrGeometryProcessor { | 21 class DefaultGeoProc : public GrGeometryProcessor { |
22 public: | 22 public: |
23 static GrGeometryProcessor* Create() { | 23 static GrGeometryProcessor* Create(bool hasCoverage) { |
24 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProc, DefaultGeoProc, ()); | 24 GR_CREATE_STATIC_PROCESSOR(gDefaultGeoProc, DefaultGeoProc, (hasCoverage
)); |
25 return SkRef(gDefaultGeoProc); | 25 return SkRef(gDefaultGeoProc); |
26 } | 26 } |
27 | 27 |
28 static const char* Name() { return "DefaultGeometryProcessor"; } | 28 static const char* Name() { return "DefaultGeometryProcessor"; } |
29 | 29 |
30 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE { | 30 virtual const GrBackendGeometryProcessorFactory& getFactory() const SK_OVERR
IDE { |
31 return GrTBackendGeometryProcessorFactory<DefaultGeoProc>::getInstance()
; | 31 return GrTBackendGeometryProcessorFactory<DefaultGeoProc>::getInstance()
; |
32 } | 32 } |
33 | 33 |
34 class GLProcessor : public GrGLGeometryProcessor { | 34 class GLProcessor : public GrGLGeometryProcessor { |
(...skipping 15 matching lines...) Expand all Loading... |
50 | 50 |
51 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcess
orKeyBuilder*) {} | 51 static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcess
orKeyBuilder*) {} |
52 | 52 |
53 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&)
SK_OVERRIDE {} | 53 virtual void setData(const GrGLProgramDataManager&, const GrProcessor&)
SK_OVERRIDE {} |
54 | 54 |
55 private: | 55 private: |
56 typedef GrGLGeometryProcessor INHERITED; | 56 typedef GrGLGeometryProcessor INHERITED; |
57 }; | 57 }; |
58 | 58 |
59 private: | 59 private: |
60 DefaultGeoProc() {} | 60 DefaultGeoProc(bool hasCoverageAttribute) : fHasCoverageAttribute(hasCoverag
eAttribute) {} |
61 | 61 |
62 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { | 62 virtual bool onIsEqual(const GrGeometryProcessor& other) const SK_OVERRIDE { |
63 return true; | 63 return true; |
64 } | 64 } |
65 | 65 |
66 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE { | 66 virtual void onComputeInvariantOutput(GrInvariantOutput* inout) const SK_OVE
RRIDE { |
67 inout->mulByUnknownAlpha(); | 67 if (fHasCoverageAttribute) { |
| 68 inout->mulByUnknownAlpha(); |
| 69 } else { |
| 70 inout->mulByKnownAlpha(255); |
| 71 } |
68 } | 72 } |
69 | 73 |
70 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; | 74 GR_DECLARE_GEOMETRY_PROCESSOR_TEST; |
71 | 75 |
| 76 bool fHasCoverageAttribute; |
| 77 |
72 typedef GrFragmentProcessor INHERITED; | 78 typedef GrFragmentProcessor INHERITED; |
73 }; | 79 }; |
74 | 80 |
75 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); | 81 GR_DEFINE_GEOMETRY_PROCESSOR_TEST(DefaultGeoProc); |
76 | 82 |
77 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, | 83 GrGeometryProcessor* DefaultGeoProc::TestCreate(SkRandom* random, |
78 GrContext*, | 84 GrContext*, |
79 const GrDrawTargetCaps& caps, | 85 const GrDrawTargetCaps& caps, |
80 GrTexture*[]) { | 86 GrTexture*[]) { |
81 return DefaultGeoProc::Create(); | 87 return DefaultGeoProc::Create(random->nextBool()); |
82 } | 88 } |
83 | 89 |
84 // We use these arrays to customize our default GP. We only need 4 because we o
mit coverage if | 90 // We use these arrays to customize our default GP. We only need 4 because we o
mit coverage if |
85 // coverage is not requested in the flags to the create function. | 91 // coverage is not requested in the flags to the create function. |
86 GrVertexAttrib kDefaultPositionGeoProc[] = { | 92 GrVertexAttrib kDefaultPositionGeoProc[] = { |
87 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBindi
ng }, | 93 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBindin
g }, |
88 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBindi
ng }, | 94 { kFloat_GrVertexAttribType, sizeof(SkPoint), kCoverage_GrVertexAttribBindin
g }, |
89 }; | 95 }; |
90 | 96 |
91 GrVertexAttrib kDefaultPosColorGeoProc[] = { | 97 GrVertexAttrib kDefaultPosColorGeoProc[] = { |
92 { kVec2f_GrVertexAttribType, 0, kPosition_G
rVertexAttribBinding }, | 98 { kVec2f_GrVertexAttribType, 0, kPosition_Gr
VertexAttribBinding }, |
93 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVe
rtexAttribBinding }, | 99 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_GrVer
texAttribBinding }, |
94 { kVec4ub_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kCoverage_G
rVertexAttribBinding }, | 100 { kFloat_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kCoverage_Gr
VertexAttribBinding }, |
95 }; | 101 }; |
96 | 102 |
97 GrVertexAttrib kDefaultPosUVGeoProc[] = { | 103 GrVertexAttrib kDefaultPosLocalCoordGeoProc[] = { |
98 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribB
inding }, | 104 { kVec2f_GrVertexAttribType, 0, kPosition_GrVertexAttribBi
nding }, |
99 { kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttri
bBinding }, | 105 { kVec2f_GrVertexAttribType, sizeof(SkPoint), kLocalCoord_GrVertexAttrib
Binding }, |
100 { kVec4ub_GrVertexAttribType, 2 * sizeof(SkPoint), kCoverage_GrVertexAttribB
inding }, | 106 { kFloat_GrVertexAttribType, 2 * sizeof(SkPoint), kCoverage_GrVertexAttribBi
nding }, |
101 }; | 107 }; |
102 | 108 |
103 GrVertexAttrib kDefaultPosColUVGeoProc[] = { | 109 GrVertexAttrib kDefaultPosColLocalCoordGeoProc[] = { |
104 { kVec2f_GrVertexAttribType, 0, kPositi
on_GrVertexAttribBinding }, | 110 { kVec2f_GrVertexAttribType, 0, kPositio
n_GrVertexAttribBinding }, |
105 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_
GrVertexAttribBinding }, | 111 { kVec4ub_GrVertexAttribType, sizeof(SkPoint), kColor_G
rVertexAttribBinding }, |
106 { kVec2f_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kLocalC
oord_GrVertexAttribBinding }, | 112 { kVec2f_GrVertexAttribType, sizeof(SkPoint) + sizeof(GrColor), kLocalCo
ord_GrVertexAttribBinding }, |
107 { kVec4ub_GrVertexAttribType, 2 * sizeof(SkPoint) + sizeof(GrColor), kCovera
ge_GrVertexAttribBinding }, | 113 { kFloat_GrVertexAttribType, 2 * sizeof(SkPoint) + sizeof(GrColor), kCoverag
e_GrVertexAttribBinding }, |
108 }; | 114 }; |
109 | 115 |
110 static size_t get_size(GrDefaultGeoProcFactory::GPType flag) { | 116 static size_t get_size(GrDefaultGeoProcFactory::GPType flag) { |
111 switch (flag) { | 117 switch (flag) { |
112 case GrDefaultGeoProcFactory::kPosition_GPType: | 118 case GrDefaultGeoProcFactory::kPosition_GPType: |
113 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); | 119 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); |
114 case GrDefaultGeoProcFactory::kColor_GPType: | 120 case GrDefaultGeoProcFactory::kColor_GPType: |
115 return GrVertexAttribTypeSize(kVec4ub_GrVertexAttribType); | 121 return GrVertexAttribTypeSize(kVec4ub_GrVertexAttribType); |
116 case GrDefaultGeoProcFactory::kLocalCoord_GPType: | 122 case GrDefaultGeoProcFactory::kLocalCoord_GPType: |
117 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); | 123 return GrVertexAttribTypeSize(kVec2f_GrVertexAttribType); |
118 case GrDefaultGeoProcFactory::kCoverage_GPType: | 124 case GrDefaultGeoProcFactory::kCoverage_GPType: |
119 return GrVertexAttribTypeSize(kVec4ub_GrVertexAttribType); | 125 return GrVertexAttribTypeSize(kFloat_GrVertexAttribType); |
120 default: | 126 default: |
121 SkFAIL("Should never get here"); | 127 SkFAIL("Should never get here"); |
122 return 0; | 128 return 0; |
123 } | 129 } |
124 } | 130 } |
125 | 131 |
126 const GrGeometryProcessor* | 132 void GrDefaultGeoProcFactory::SetAttribs(GrDrawState* ds, uint32_t gpTypeFlags)
{ |
127 GrDefaultGeoProcFactory::CreateAndSetAttribs(GrDrawState* ds, uint32_t gpTypeFla
gs) { | |
128 SkASSERT(ds); | 133 SkASSERT(ds); |
129 // always atleast position in the GP | 134 // always atleast position in the GP |
130 size_t size = get_size(kPosition_GPType); | 135 size_t size = get_size(kPosition_GPType); |
131 int count = 1; | 136 int count = 1; |
132 | 137 |
133 bool hasColor = SkToBool(gpTypeFlags & kColor_GPType); | 138 bool hasColor = SkToBool(gpTypeFlags & kColor_GPType); |
134 bool hasLocalCoord = SkToBool(gpTypeFlags & kLocalCoord_GPType); | 139 bool hasLocalCoord = SkToBool(gpTypeFlags & kLocalCoord_GPType); |
135 bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPType); | 140 bool hasCoverage = SkToBool(gpTypeFlags & kCoverage_GPType); |
136 | 141 |
137 if (hasColor) { | 142 if (hasColor) { |
138 size += get_size(kColor_GPType); | 143 size += get_size(kColor_GPType); |
139 count++; | 144 count++; |
140 if (hasLocalCoord) { | 145 if (hasLocalCoord) { |
141 size += get_size(kLocalCoord_GPType); | 146 size += get_size(kLocalCoord_GPType); |
142 count++; | 147 count++; |
143 if (hasCoverage) { | 148 if (hasCoverage) { |
144 size += get_size(kCoverage_GPType); | 149 size += get_size(kCoverage_GPType); |
145 count++; | 150 count++; |
146 ds->setVertexAttribs<kDefaultPosColUVGeoProc>(count, size); | 151 ds->setVertexAttribs<kDefaultPosColLocalCoordGeoProc>(count, siz
e); |
147 } else { | 152 } else { |
148 ds->setVertexAttribs<kDefaultPosColUVGeoProc>(count, size); | 153 ds->setVertexAttribs<kDefaultPosColLocalCoordGeoProc>(count, siz
e); |
149 | 154 |
150 } | 155 } |
151 } else { | 156 } else { |
152 if (hasCoverage) { | 157 if (hasCoverage) { |
153 size += get_size(kCoverage_GPType); | 158 size += get_size(kCoverage_GPType); |
154 count++; | 159 count++; |
155 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); | 160 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); |
156 } else { | 161 } else { |
157 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); | 162 ds->setVertexAttribs<kDefaultPosColorGeoProc>(count, size); |
158 } | 163 } |
159 } | 164 } |
160 } else if (hasLocalCoord) { | 165 } else if (hasLocalCoord) { |
161 size += get_size(kLocalCoord_GPType); | 166 size += get_size(kLocalCoord_GPType); |
162 count++; | 167 count++; |
163 if (hasCoverage) { | 168 if (hasCoverage) { |
164 size += get_size(kCoverage_GPType); | 169 size += get_size(kCoverage_GPType); |
165 count++; | 170 count++; |
166 ds->setVertexAttribs<kDefaultPosUVGeoProc>(count, size); | 171 ds->setVertexAttribs<kDefaultPosLocalCoordGeoProc>(count, size); |
167 } else { | 172 } else { |
168 ds->setVertexAttribs<kDefaultPosUVGeoProc>(count, size); | 173 ds->setVertexAttribs<kDefaultPosLocalCoordGeoProc>(count, size); |
169 } | 174 } |
170 } else if (hasCoverage) { | 175 } else if (hasCoverage) { |
171 size += get_size(kCoverage_GPType); | 176 size += get_size(kCoverage_GPType); |
172 count++; | 177 count++; |
173 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); | 178 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); |
174 } else { | 179 } else { |
175 // Just position | 180 // Just position |
176 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); | 181 ds->setVertexAttribs<kDefaultPositionGeoProc>(count, size); |
177 } | 182 } |
178 return DefaultGeoProc::Create(); | |
179 } | 183 } |
180 | 184 |
181 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create() { | 185 const GrGeometryProcessor* |
182 return DefaultGeoProc::Create(); | 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); |
183 } | 191 } |
| 192 |
| 193 const GrGeometryProcessor* GrDefaultGeoProcFactory::Create(bool hasAttributeCove
rage) { |
| 194 return DefaultGeoProc::Create(hasAttributeCoverage); |
| 195 } |
OLD | NEW |