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 "GrOptDrawState.h" | 8 #include "GrOptDrawState.h" |
9 | 9 |
10 #include "GrDrawState.h" | 10 #include "GrDrawState.h" |
(...skipping 17 matching lines...) Expand all Loading... |
28 fStencilSettings = drawState.getStencil(); | 28 fStencilSettings = drawState.getStencil(); |
29 fDrawFace = (DrawFace)drawState.getDrawFace(); | 29 fDrawFace = (DrawFace)drawState.getDrawFace(); |
30 fBlendOptFlags = blendOptFlags; | 30 fBlendOptFlags = blendOptFlags; |
31 fSrcBlend = optSrcCoeff; | 31 fSrcBlend = optSrcCoeff; |
32 fDstBlend = optDstCoeff; | 32 fDstBlend = optDstCoeff; |
33 | 33 |
34 memcpy(fFixedFunctionVertexAttribIndices, | 34 memcpy(fFixedFunctionVertexAttribIndices, |
35 drawState.getFixedFunctionVertexAttribIndices(), | 35 drawState.getFixedFunctionVertexAttribIndices(), |
36 sizeof(fFixedFunctionVertexAttribIndices)); | 36 sizeof(fFixedFunctionVertexAttribIndices)); |
37 | 37 |
38 | |
39 fInputColorIsUsed = true; | 38 fInputColorIsUsed = true; |
40 fInputCoverageIsUsed = true; | 39 fInputCoverageIsUsed = true; |
41 | 40 |
| 41 int firstColorStageIdx = 0; |
| 42 int firstCoverageStageIdx = 0; |
| 43 bool separateCoverageFromColor; |
| 44 |
| 45 uint8_t fixedFunctionVAToRemove = 0; |
| 46 |
| 47 this->computeEffectiveColorStages(drawState, &firstColorStageIdx, &fixedFunc
tionVAToRemove); |
| 48 this->computeEffectiveCoverageStages(drawState, &firstCoverageStageIdx); |
| 49 this->adjustFromBlendOpts(drawState, &firstColorStageIdx, &firstCoverageStag
eIdx, |
| 50 &fixedFunctionVAToRemove); |
| 51 // Should not be setting any more FFVA to be removed at this point |
| 52 this->removeFixedFunctionVertexAttribs(fixedFunctionVAToRemove); |
| 53 this->getStageStats(drawState, firstColorStageIdx, firstCoverageStageIdx); |
| 54 this->setOutputStateInfo(drawState, caps, firstCoverageStageIdx, &separateCo
verageFromColor); |
| 55 |
| 56 // Copy GeometryProcesssor from DS or ODS |
42 if (drawState.hasGeometryProcessor()) { | 57 if (drawState.hasGeometryProcessor()) { |
43 fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeom
etryProcessor()))); | 58 fGeometryProcessor.reset(SkNEW_ARGS(GrGeometryStage, (*drawState.getGeom
etryProcessor()))); |
44 } else { | 59 } else { |
45 fGeometryProcessor.reset(NULL); | 60 fGeometryProcessor.reset(NULL); |
46 } | 61 } |
47 | 62 |
48 this->copyEffectiveColorStages(drawState); | 63 // Copy Color Stages from DS to ODS |
49 this->copyEffectiveCoverageStages(drawState); | 64 if (firstColorStageIdx < drawState.numColorStages()) { |
50 this->adjustFromBlendOpts(); | 65 fColorStages.reset(&drawState.getColorStage(firstColorStageIdx), |
51 this->getStageStats(); | 66 drawState.numColorStages() - firstColorStageIdx); |
52 this->setOutputStateInfo(caps); | 67 } else { |
| 68 fColorStages.reset(); |
| 69 } |
| 70 |
| 71 // Copy Coverage Stages from DS to ODS |
| 72 if (drawState.numCoverageStages() > 0 && separateCoverageFromColor) { |
| 73 fCoverageStages.reset(&drawState.getCoverageStage(firstCoverageStageIdx)
, |
| 74 drawState.numCoverageStages() - firstCoverageStage
Idx); |
| 75 } else { |
| 76 fCoverageStages.reset(); |
| 77 if (drawState.numCoverageStages() > 0) { |
| 78 // TODO: Once we have flag to know if we only multiply on stages, on
ly push coverage |
| 79 // into color stages if everything is multiply |
| 80 fColorStages.push_back_n(drawState.numCoverageStages() - firstCovera
geStageIdx, |
| 81 &drawState.getCoverageStage(firstCoverageSt
ageIdx)); |
| 82 } |
| 83 } |
53 }; | 84 }; |
54 | 85 |
55 GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState, const GrDra
wTargetCaps& caps, | 86 GrOptDrawState* GrOptDrawState::Create(const GrDrawState& drawState, const GrDra
wTargetCaps& caps, |
56 GrGpu::DrawType drawType) { | 87 GrGpu::DrawType drawType) { |
57 if (NULL == drawState.fCachedOptState || caps.getUniqueID() != drawState.fCa
chedCapsID) { | 88 if (NULL == drawState.fCachedOptState || caps.getUniqueID() != drawState.fCa
chedCapsID) { |
58 GrBlendCoeff srcCoeff; | 89 GrBlendCoeff srcCoeff; |
59 GrBlendCoeff dstCoeff; | 90 GrBlendCoeff dstCoeff; |
60 BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false, | 91 BlendOptFlags blendFlags = (BlendOptFlags) drawState.getBlendOpts(false, |
61 &srcCo
eff, | 92 &srcCo
eff, |
62 &dstCo
eff); | 93 &dstCo
eff); |
(...skipping 18 matching lines...) Expand all Loading... |
81 &srcCo
eff, | 112 &srcCo
eff, |
82 &dstCo
eff); | 113 &dstCo
eff); |
83 SkASSERT(GrOptDrawState(drawState, blendFlags, srcCoeff, dstCoeff, caps)
== | 114 SkASSERT(GrOptDrawState(drawState, blendFlags, srcCoeff, dstCoeff, caps)
== |
84 *drawState.fCachedOptState); | 115 *drawState.fCachedOptState); |
85 #endif | 116 #endif |
86 } | 117 } |
87 drawState.fCachedOptState->ref(); | 118 drawState.fCachedOptState->ref(); |
88 return drawState.fCachedOptState; | 119 return drawState.fCachedOptState; |
89 } | 120 } |
90 | 121 |
91 void GrOptDrawState::setOutputStateInfo(const GrDrawTargetCaps& caps) { | 122 void GrOptDrawState::setOutputStateInfo(const GrDrawState& ds, |
| 123 const GrDrawTargetCaps& caps, |
| 124 int firstCoverageStageIdx, |
| 125 bool* separateCoverageFromColor) { |
92 // Set this default and then possibly change our mind if there is coverage. | 126 // Set this default and then possibly change our mind if there is coverage. |
93 fPrimaryOutputType = kModulate_PrimaryOutputType; | 127 fPrimaryOutputType = kModulate_PrimaryOutputType; |
94 fSecondaryOutputType = kNone_SecondaryOutputType; | 128 fSecondaryOutputType = kNone_SecondaryOutputType; |
95 | 129 |
96 // If we do have coverage determine whether it matters. | 130 // If we do have coverage determine whether it matters. |
97 bool separateCoverageFromColor = this->hasGeometryProcessor(); | 131 *separateCoverageFromColor = this->hasGeometryProcessor(); |
98 if (!this->isCoverageDrawing() && | 132 if (!this->isCoverageDrawing() && |
99 (this->numCoverageStages() > 0 || | 133 (ds.numCoverageStages() - firstCoverageStageIdx > 0 || |
100 this->hasGeometryProcessor() || | 134 ds.hasGeometryProcessor() || |
101 this->hasCoverageVertexAttribute())) { | 135 this->hasCoverageVertexAttribute())) { |
102 | 136 |
103 if (caps.dualSourceBlendingSupport()) { | 137 if (caps.dualSourceBlendingSupport()) { |
104 if (kZero_GrBlendCoeff == fDstBlend) { | 138 if (kZero_GrBlendCoeff == fDstBlend) { |
105 // write the coverage value to second color | 139 // write the coverage value to second color |
106 fSecondaryOutputType = kCoverage_SecondaryOutputType; | 140 fSecondaryOutputType = kCoverage_SecondaryOutputType; |
107 separateCoverageFromColor = true; | 141 *separateCoverageFromColor = true; |
108 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; | 142 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; |
109 } else if (kSA_GrBlendCoeff == fDstBlend) { | 143 } else if (kSA_GrBlendCoeff == fDstBlend) { |
110 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
covered. | 144 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
covered. |
111 fSecondaryOutputType = kCoverageISA_SecondaryOutputType; | 145 fSecondaryOutputType = kCoverageISA_SecondaryOutputType; |
112 separateCoverageFromColor = true; | 146 *separateCoverageFromColor = true; |
113 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; | 147 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; |
114 } else if (kSC_GrBlendCoeff == fDstBlend) { | 148 } else if (kSC_GrBlendCoeff == fDstBlend) { |
115 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
covered. | 149 // SA dst coeff becomes 1-(1-SA)*coverage when dst is partially
covered. |
116 fSecondaryOutputType = kCoverageISC_SecondaryOutputType; | 150 fSecondaryOutputType = kCoverageISC_SecondaryOutputType; |
117 separateCoverageFromColor = true; | 151 *separateCoverageFromColor = true; |
118 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; | 152 fDstBlend = (GrBlendCoeff)GrGpu::kIS2C_GrBlendCoeff; |
119 } | 153 } |
120 } else if (fReadsDst && | 154 } else if (fReadsDst && |
121 kOne_GrBlendCoeff == fSrcBlend && | 155 kOne_GrBlendCoeff == fSrcBlend && |
122 kZero_GrBlendCoeff == fDstBlend) { | 156 kZero_GrBlendCoeff == fDstBlend) { |
123 fPrimaryOutputType = kCombineWithDst_PrimaryOutputType; | 157 fPrimaryOutputType = kCombineWithDst_PrimaryOutputType; |
124 separateCoverageFromColor = true; | 158 *separateCoverageFromColor = true; |
125 } | 159 } |
126 } | 160 } |
127 | |
128 // TODO: Once we have flag to know if we only multiply on stages, only push
coverage into color | |
129 // stages if everything is multipy | |
130 if (!separateCoverageFromColor) { | |
131 for (int s = 0; s < this->numCoverageStages(); ++s) { | |
132 fColorStages.push_back(this->getCoverageStage(s)); | |
133 } | |
134 fCoverageStages.reset(); | |
135 } | |
136 } | 161 } |
137 | 162 |
138 void GrOptDrawState::adjustFromBlendOpts() { | 163 void GrOptDrawState::adjustFromBlendOpts(const GrDrawState& ds, |
139 | 164 int* firstColorStageIdx, |
| 165 int* firstCoverageStageIdx, |
| 166 uint8_t* fixedFunctionVAToRemove) { |
140 switch (fBlendOptFlags) { | 167 switch (fBlendOptFlags) { |
141 case kNone_BlendOpt: | 168 case kNone_BlendOpt: |
142 case kSkipDraw_BlendOptFlag: | 169 case kSkipDraw_BlendOptFlag: |
143 break; | 170 break; |
144 case kCoverageAsAlpha_BlendOptFlag: | 171 case kCoverageAsAlpha_BlendOptFlag: |
145 fFlagBits |= kCoverageDrawing_StateBit; | 172 fFlagBits |= kCoverageDrawing_StateBit; |
146 break; | 173 break; |
147 case kEmitCoverage_BlendOptFlag: | 174 case kEmitCoverage_BlendOptFlag: |
148 fColor = 0xffffffff; | 175 fColor = 0xffffffff; |
149 fInputColorIsUsed = true; | 176 fInputColorIsUsed = true; |
150 fColorStages.reset(); | 177 *firstColorStageIdx = ds.numColorStages(); |
151 this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribB
inding); | 178 *fixedFunctionVAToRemove |= 0x1 << kColor_GrVertexAttribBinding; |
152 break; | 179 break; |
153 case kEmitTransBlack_BlendOptFlag: | 180 case kEmitTransBlack_BlendOptFlag: |
154 fColor = 0; | 181 fColor = 0; |
155 fCoverage = 0xff; | 182 fCoverage = 0xff; |
156 fInputColorIsUsed = true; | 183 fInputColorIsUsed = true; |
157 fInputCoverageIsUsed = true; | 184 fInputCoverageIsUsed = true; |
158 fColorStages.reset(); | 185 *firstColorStageIdx = ds.numColorStages(); |
159 fCoverageStages.reset(); | 186 *firstCoverageStageIdx = ds.numCoverageStages(); |
160 this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribB
inding | | 187 *fixedFunctionVAToRemove |= (0x1 << kColor_GrVertexAttribBinding | |
161 0x1 << kCoverage_GrVertexAttr
ibBinding); | 188 0x1 << kCoverage_GrVertexAttribBinding)
; |
162 break; | 189 break; |
163 default: | 190 default: |
164 SkFAIL("Unknown BlendOptFlag"); | 191 SkFAIL("Unknown BlendOptFlag"); |
165 | |
166 } | 192 } |
167 } | 193 } |
168 | 194 |
169 void GrOptDrawState::removeFixedFunctionVertexAttribs(uint8_t removeVAFlag) { | 195 void GrOptDrawState::removeFixedFunctionVertexAttribs(uint8_t removeVAFlag) { |
170 int numToRemove = 0; | 196 int numToRemove = 0; |
171 uint8_t maskCheck = 0x1; | 197 uint8_t maskCheck = 0x1; |
172 // Count the number of vertex attributes that we will actually remove | 198 // Count the number of vertex attributes that we will actually remove |
173 for (int i = 0; i < kGrFixedFunctionVertexAttribBindingCnt; ++i) { | 199 for (int i = 0; i < kGrFixedFunctionVertexAttribBindingCnt; ++i) { |
174 if ((maskCheck & removeVAFlag) && -1 != fFixedFunctionVertexAttribIndice
s[i]) { | 200 if ((maskCheck & removeVAFlag) && -1 != fFixedFunctionVertexAttribIndice
s[i]) { |
175 ++numToRemove; | 201 ++numToRemove; |
(...skipping 18 matching lines...) Expand all Loading... |
194 fFixedFunctionVertexAttribIndices[currAttrib.fBinding] = newIdx; | 220 fFixedFunctionVertexAttribIndices[currAttrib.fBinding] = newIdx; |
195 } | 221 } |
196 memcpy(dst, src, sizeof(GrVertexAttrib)); | 222 memcpy(dst, src, sizeof(GrVertexAttrib)); |
197 ++newIdx; | 223 ++newIdx; |
198 ++dst; | 224 ++dst; |
199 } | 225 } |
200 fVACount -= numToRemove; | 226 fVACount -= numToRemove; |
201 fVAPtr = fOptVA.get(); | 227 fVAPtr = fOptVA.get(); |
202 } | 228 } |
203 | 229 |
204 void GrOptDrawState::copyEffectiveColorStages(const GrDrawState& ds) { | 230 void GrOptDrawState::computeEffectiveColorStages(const GrDrawState& ds, int* fir
stColorStageIdx, |
205 int firstColorStage = 0; | 231 uint8_t* fixedFunctionVAToRemov
e) { |
206 | |
207 // Set up color and flags for ConstantColorComponent checks | 232 // Set up color and flags for ConstantColorComponent checks |
208 GrProcessor::InvariantOutput inout; | 233 GrProcessor::InvariantOutput inout; |
209 inout.fIsSingleComponent = false; | 234 inout.fIsSingleComponent = false; |
210 if (!this->hasColorVertexAttribute()) { | 235 if (!this->hasColorVertexAttribute()) { |
211 inout.fColor = ds.getColor(); | 236 inout.fColor = ds.getColor(); |
212 inout.fValidFlags = kRGBA_GrColorComponentFlags; | 237 inout.fValidFlags = kRGBA_GrColorComponentFlags; |
213 } else { | 238 } else { |
214 if (ds.vertexColorsAreOpaque()) { | 239 if (ds.vertexColorsAreOpaque()) { |
215 inout.fColor = 0xFF << GrColor_SHIFT_A; | 240 inout.fColor = 0xFF << GrColor_SHIFT_A; |
216 inout.fValidFlags = kA_GrColorComponentFlag; | 241 inout.fValidFlags = kA_GrColorComponentFlag; |
217 } else { | 242 } else { |
218 inout.fValidFlags = 0; | 243 inout.fValidFlags = 0; |
219 // not strictly necessary but we get false alarms from tools about u
ninit. | 244 // not strictly necessary but we get false alarms from tools about u
ninit. |
220 inout.fColor = 0; | 245 inout.fColor = 0; |
221 } | 246 } |
222 } | 247 } |
223 | 248 |
224 for (int i = 0; i < ds.numColorStages(); ++i) { | 249 for (int i = 0; i < ds.numColorStages(); ++i) { |
225 const GrFragmentProcessor* fp = ds.getColorStage(i).getProcessor(); | 250 const GrFragmentProcessor* fp = ds.getColorStage(i).getProcessor(); |
226 if (!fp->willUseInputColor()) { | 251 if (!fp->willUseInputColor()) { |
227 firstColorStage = i; | 252 *firstColorStageIdx = i; |
228 fInputColorIsUsed = false; | 253 fInputColorIsUsed = false; |
229 } | 254 } |
230 fp->computeInvariantOutput(&inout); | 255 fp->computeInvariantOutput(&inout); |
231 if (kRGBA_GrColorComponentFlags == inout.fValidFlags) { | 256 if (kRGBA_GrColorComponentFlags == inout.fValidFlags) { |
232 firstColorStage = i + 1; | 257 *firstColorStageIdx = i + 1; |
233 fColor = inout.fColor; | 258 fColor = inout.fColor; |
234 fInputColorIsUsed = true; | 259 fInputColorIsUsed = true; |
235 this->removeFixedFunctionVertexAttribs(0x1 << kColor_GrVertexAttribB
inding); | 260 *fixedFunctionVAToRemove |= 0x1 << kColor_GrVertexAttribBinding; |
236 } | 261 } |
237 } | 262 } |
238 if (firstColorStage < ds.numColorStages()) { | |
239 fColorStages.reset(&ds.getColorStage(firstColorStage), | |
240 ds.numColorStages() - firstColorStage); | |
241 } else { | |
242 fColorStages.reset(); | |
243 } | |
244 } | 263 } |
245 | 264 |
246 void GrOptDrawState::copyEffectiveCoverageStages(const GrDrawState& ds) { | 265 void GrOptDrawState::computeEffectiveCoverageStages(const GrDrawState& ds, |
247 int firstCoverageStage = 0; | 266 int* firstCoverageStageIdx)
{ |
248 | |
249 // We do not try to optimize out constantColor coverage effects here. It is
extremely rare | 267 // We do not try to optimize out constantColor coverage effects here. It is
extremely rare |
250 // to have a coverage effect that returns a constant value for all four chan
nels. Thus we | 268 // to have a coverage effect that returns a constant value for all four chan
nels. Thus we |
251 // save having to make extra virtual calls by not checking for it. | 269 // save having to make extra virtual calls by not checking for it. |
252 | 270 |
253 // Don't do any optimizations on coverage stages. It should not be the case
where we do not use | 271 // Don't do any optimizations on coverage stages. It should not be the case
where we do not use |
254 // input coverage in an effect | 272 // input coverage in an effect |
255 #ifdef OptCoverageStages | 273 #ifdef OptCoverageStages |
256 for (int i = 0; i < ds.numCoverageStages(); ++i) { | 274 for (int i = 0; i < ds.numCoverageStages(); ++i) { |
257 const GrProcessor* processor = ds.getCoverageStage(i).getProcessor(); | 275 const GrProcessor* processor = ds.getCoverageStage(i).getProcessor(); |
258 if (!processor->willUseInputColor()) { | 276 if (!processor->willUseInputColor()) { |
259 firstCoverageStage = i; | 277 *firstCoverageStageIdx = i; |
260 fInputCoverageIsUsed = false; | 278 fInputCoverageIsUsed = false; |
261 } | 279 } |
262 } | 280 } |
263 #endif | 281 #endif |
264 if (ds.numCoverageStages() > 0) { | |
265 fCoverageStages.reset(&ds.getCoverageStage(firstCoverageStage), | |
266 ds.numCoverageStages() - firstCoverageStage); | |
267 } else { | |
268 fCoverageStages.reset(); | |
269 } | |
270 } | 282 } |
271 | 283 |
272 static void get_stage_stats(const GrFragmentStage& stage, bool* readsDst, bool*
readsFragPosition) { | 284 static void get_stage_stats(const GrFragmentStage& stage, bool* readsDst, bool*
readsFragPosition) { |
273 if (stage.getProcessor()->willReadDstColor()) { | 285 if (stage.getProcessor()->willReadDstColor()) { |
274 *readsDst = true; | 286 *readsDst = true; |
275 } | 287 } |
276 if (stage.getProcessor()->willReadFragmentPosition()) { | 288 if (stage.getProcessor()->willReadFragmentPosition()) { |
277 *readsFragPosition = true; | 289 *readsFragPosition = true; |
278 } | 290 } |
279 } | 291 } |
280 | 292 |
281 void GrOptDrawState::getStageStats() { | 293 void GrOptDrawState::getStageStats(const GrDrawState& ds, int firstColorStageIdx
, |
| 294 int firstCoverageStageIdx) { |
282 // We will need a local coord attrib if there is one currently set on the op
tState and we are | 295 // We will need a local coord attrib if there is one currently set on the op
tState and we are |
283 // actually generating some effect code | 296 // actually generating some effect code |
284 fRequiresLocalCoordAttrib = this->hasLocalCoordAttribute() && this->numTotal
Stages() > 0; | 297 fRequiresLocalCoordAttrib = this->hasLocalCoordAttribute() && |
| 298 ds.numTotalStages() - firstColorStageIdx - firstCoverageStageIdx > 0; |
285 | 299 |
286 fReadsDst = false; | 300 fReadsDst = false; |
287 fReadsFragPosition = false; | 301 fReadsFragPosition = false; |
288 | 302 |
289 for (int s = 0; s < this->numColorStages(); ++s) { | 303 for (int s = firstColorStageIdx; s < ds.numColorStages(); ++s) { |
290 const GrFragmentStage& stage = this->getColorStage(s); | 304 const GrFragmentStage& stage = ds.getColorStage(s); |
291 get_stage_stats(stage, &fReadsDst, &fReadsFragPosition); | 305 get_stage_stats(stage, &fReadsDst, &fReadsFragPosition); |
292 } | 306 } |
293 for (int s = 0; s < this->numCoverageStages(); ++s) { | 307 for (int s = firstCoverageStageIdx; s < ds.numCoverageStages(); ++s) { |
294 const GrFragmentStage& stage = this->getCoverageStage(s); | 308 const GrFragmentStage& stage = ds.getCoverageStage(s); |
295 get_stage_stats(stage, &fReadsDst, &fReadsFragPosition); | 309 get_stage_stats(stage, &fReadsDst, &fReadsFragPosition); |
296 } | 310 } |
297 if (this->hasGeometryProcessor()) { | 311 if (ds.hasGeometryProcessor()) { |
298 const GrGeometryStage& stage = *this->getGeometryProcessor(); | 312 const GrGeometryStage& stage = *ds.getGeometryProcessor(); |
299 fReadsFragPosition = fReadsFragPosition || stage.getProcessor()->willRea
dFragmentPosition(); | 313 fReadsFragPosition = fReadsFragPosition || stage.getProcessor()->willRea
dFragmentPosition(); |
300 } | 314 } |
301 } | 315 } |
302 | 316 |
303 //////////////////////////////////////////////////////////////////////////////// | 317 //////////////////////////////////////////////////////////////////////////////// |
304 | 318 |
305 bool GrOptDrawState::operator== (const GrOptDrawState& that) const { | 319 bool GrOptDrawState::operator== (const GrOptDrawState& that) const { |
306 return this->isEqual(that); | 320 return this->isEqual(that); |
307 } | 321 } |
308 | 322 |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
366 } | 380 } |
367 } | 381 } |
368 | 382 |
369 SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices, | 383 SkASSERT(0 == memcmp(this->fFixedFunctionVertexAttribIndices, |
370 that.fFixedFunctionVertexAttribIndices, | 384 that.fFixedFunctionVertexAttribIndices, |
371 sizeof(this->fFixedFunctionVertexAttribIndices))); | 385 sizeof(this->fFixedFunctionVertexAttribIndices))); |
372 | 386 |
373 return true; | 387 return true; |
374 } | 388 } |
375 | 389 |
OLD | NEW |