OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2015 Google Inc. | 2 * Copyright 2015 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 "GrPipeline.h" | 8 #include "GrPipeline.h" |
9 | 9 |
10 #include "GrCaps.h" | 10 #include "GrCaps.h" |
(...skipping 11 matching lines...) Expand all Loading... |
22 // Create XferProcessor from DS's XPFactory | 22 // Create XferProcessor from DS's XPFactory |
23 SkAutoTUnref<GrXferProcessor> xferProcessor( | 23 SkAutoTUnref<GrXferProcessor> xferProcessor( |
24 builder.getXPFactory()->createXferProcessor(args.fColorPOI, args.fCovera
gePOI, | 24 builder.getXPFactory()->createXferProcessor(args.fColorPOI, args.fCovera
gePOI, |
25 builder.hasMixedSamples(), &
args.fDstTexture, | 25 builder.hasMixedSamples(), &
args.fDstTexture, |
26 *args.fCaps)); | 26 *args.fCaps)); |
27 if (!xferProcessor) { | 27 if (!xferProcessor) { |
28 return nullptr; | 28 return nullptr; |
29 } | 29 } |
30 | 30 |
31 GrColor overrideColor = GrColor_ILLEGAL; | 31 GrColor overrideColor = GrColor_ILLEGAL; |
32 if (args.fColorPOI.firstEffectiveProcessorIndex() != 0) { | 32 if (args.fColorPOI.firstEffectiveStageIndex() != 0) { |
33 overrideColor = args.fColorPOI.inputColorToFirstEffectiveProccesor(); | 33 overrideColor = args.fColorPOI.inputColorToEffectiveStage(); |
34 } | 34 } |
35 | 35 |
36 GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags; | 36 GrXferProcessor::OptFlags optFlags = GrXferProcessor::kNone_OptFlags; |
37 | 37 |
38 optFlags = xferProcessor->getOptimizations(args.fColorPOI, | 38 optFlags = xferProcessor->getOptimizations(args.fColorPOI, |
39 args.fCoveragePOI, | 39 args.fCoveragePOI, |
40 builder.getStencil().doesWrite()
, | 40 builder.getStencil().doesWrite()
, |
41 &overrideColor, | 41 &overrideColor, |
42 *args.fCaps); | 42 *args.fCaps); |
43 | 43 |
(...skipping 22 matching lines...) Expand all Loading... |
66 if (builder.isHWAntialias()) { | 66 if (builder.isHWAntialias()) { |
67 pipeline->fFlags |= kHWAA_Flag; | 67 pipeline->fFlags |= kHWAA_Flag; |
68 } | 68 } |
69 if (builder.isDither()) { | 69 if (builder.isDither()) { |
70 pipeline->fFlags |= kDither_Flag; | 70 pipeline->fFlags |= kDither_Flag; |
71 } | 71 } |
72 if (builder.snapVerticesToPixelCenters()) { | 72 if (builder.snapVerticesToPixelCenters()) { |
73 pipeline->fFlags |= kSnapVertices_Flag; | 73 pipeline->fFlags |= kSnapVertices_Flag; |
74 } | 74 } |
75 | 75 |
76 int firstColorProcessorIdx = args.fColorPOI.firstEffectiveProcessorIndex(); | 76 int firstColorStageIdx = args.fColorPOI.firstEffectiveStageIndex(); |
77 | 77 |
78 // TODO: Once we can handle single or four channel input into coverage GrFra
gmentProcessors | 78 // TODO: Once we can handle single or four channel input into coverage stage
s then we can use |
79 // then we can use GrPipelineBuilder's coverageProcInfo (like color above) t
o set this initial | 79 // GrPipelineBuilder's coverageProcInfo (like color above) to set this initi
al information. |
80 // information. | 80 int firstCoverageStageIdx = 0; |
81 int firstCoverageProcessorIdx = 0; | |
82 | 81 |
83 pipeline->adjustProgramFromOptimizations(builder, optFlags, args.fColorPOI,
args.fCoveragePOI, | 82 pipeline->adjustProgramFromOptimizations(builder, optFlags, args.fColorPOI,
args.fCoveragePOI, |
84 &firstColorProcessorIdx, &firstCove
rageProcessorIdx); | 83 &firstColorStageIdx, &firstCoverage
StageIdx); |
85 | 84 |
86 bool usesLocalCoords = false; | 85 bool usesLocalCoords = false; |
87 | 86 |
88 // Copy GrFragmentProcessors from GrPipelineBuilder to Pipeline | 87 // Copy Stages from PipelineBuilder to Pipeline |
89 pipeline->fNumColorProcessors = builder.numColorFragmentProcessors() - first
ColorProcessorIdx; | 88 for (int i = firstColorStageIdx; i < builder.numColorFragmentStages(); ++i)
{ |
90 int numTotalProcessors = pipeline->fNumColorProcessors + | 89 const GrFragmentStage& fps = builder.fColorStages[i]; |
91 builder.numCoverageFragmentProcessors() - firstCove
rageProcessorIdx; | 90 const GrFragmentProcessor* fp = fps.processor(); |
92 pipeline->fFragmentProcessors.reset(numTotalProcessors); | 91 SkNEW_APPEND_TO_TARRAY(&pipeline->fFragmentStages, GrPendingFragmentStag
e, (fps)); |
93 int currFPIdx = 0; | |
94 for (int i = firstColorProcessorIdx; i < builder.numColorFragmentProcessors(
); | |
95 ++i, ++currFPIdx) { | |
96 const GrFragmentProcessor* fp = builder.getColorFragmentProcessor(i); | |
97 pipeline->fFragmentProcessors[currFPIdx].reset(fp); | |
98 usesLocalCoords = usesLocalCoords || fp->usesLocalCoords(); | 92 usesLocalCoords = usesLocalCoords || fp->usesLocalCoords(); |
99 fp->gatherCoordTransforms(&pipeline->fCoordTransforms); | 93 fp->gatherCoordTransforms(&pipeline->fCoordTransforms); |
100 } | 94 } |
101 | 95 |
102 for (int i = firstCoverageProcessorIdx; i < builder.numCoverageFragmentProce
ssors(); | 96 pipeline->fNumColorStages = pipeline->fFragmentStages.count(); |
103 ++i, ++currFPIdx) { | 97 for (int i = firstCoverageStageIdx; i < builder.numCoverageFragmentStages();
++i) { |
104 const GrFragmentProcessor* fp = builder.getCoverageFragmentProcessor(i); | 98 const GrFragmentStage& fps = builder.fCoverageStages[i]; |
105 pipeline->fFragmentProcessors[currFPIdx].reset(fp); | 99 const GrFragmentProcessor* fp = fps.processor(); |
| 100 SkNEW_APPEND_TO_TARRAY(&pipeline->fFragmentStages, GrPendingFragmentStag
e, (fps)); |
106 usesLocalCoords = usesLocalCoords || fp->usesLocalCoords(); | 101 usesLocalCoords = usesLocalCoords || fp->usesLocalCoords(); |
107 fp->gatherCoordTransforms(&pipeline->fCoordTransforms); | 102 fp->gatherCoordTransforms(&pipeline->fCoordTransforms); |
108 } | 103 } |
109 | 104 |
110 // Setup info we need to pass to GrPrimitiveProcessors that are used with th
is GrPipeline. | 105 // Setup info we need to pass to GrPrimitiveProcessors that are used with th
is GrPipeline. |
111 opts->fFlags = 0; | 106 opts->fFlags = 0; |
112 if (!SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag)) { | 107 if (!SkToBool(optFlags & GrXferProcessor::kIgnoreColor_OptFlag)) { |
113 opts->fFlags |= GrPipelineOptimizations::kReadsColor_Flag; | 108 opts->fFlags |= GrPipelineOptimizations::kReadsColor_Flag; |
114 } | 109 } |
115 if (GrColor_ILLEGAL != overrideColor) { | 110 if (GrColor_ILLEGAL != overrideColor) { |
(...skipping 16 matching lines...) Expand all Loading... |
132 opts->fFlags |= GrPipelineOptimizations::kWillColorBlendWithDst_Flag; | 127 opts->fFlags |= GrPipelineOptimizations::kWillColorBlendWithDst_Flag; |
133 } | 128 } |
134 | 129 |
135 return pipeline; | 130 return pipeline; |
136 } | 131 } |
137 | 132 |
138 void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelin
eBuilder, | 133 void GrPipeline::adjustProgramFromOptimizations(const GrPipelineBuilder& pipelin
eBuilder, |
139 GrXferProcessor::OptFlags flags, | 134 GrXferProcessor::OptFlags flags, |
140 const GrProcOptInfo& colorPOI, | 135 const GrProcOptInfo& colorPOI, |
141 const GrProcOptInfo& coveragePOI
, | 136 const GrProcOptInfo& coveragePOI
, |
142 int* firstColorProcessorIdx, | 137 int* firstColorStageIdx, |
143 int* firstCoverageProcessorIdx)
{ | 138 int* firstCoverageStageIdx) { |
144 fReadsFragPosition = fXferProcessor->willReadFragmentPosition(); | 139 fReadsFragPosition = fXferProcessor->willReadFragmentPosition(); |
145 | 140 |
146 if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) || | 141 if ((flags & GrXferProcessor::kIgnoreColor_OptFlag) || |
147 (flags & GrXferProcessor::kOverrideColor_OptFlag)) { | 142 (flags & GrXferProcessor::kOverrideColor_OptFlag)) { |
148 *firstColorProcessorIdx = pipelineBuilder.numColorFragmentProcessors(); | 143 *firstColorStageIdx = pipelineBuilder.numColorFragmentStages(); |
149 } else { | 144 } else { |
150 if (coveragePOI.readsFragPosition()) { | 145 if (coveragePOI.readsFragPosition()) { |
151 fReadsFragPosition = true; | 146 fReadsFragPosition = true; |
152 } | 147 } |
153 } | 148 } |
154 | 149 |
155 if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) { | 150 if (flags & GrXferProcessor::kIgnoreCoverage_OptFlag) { |
156 *firstCoverageProcessorIdx = pipelineBuilder.numCoverageFragmentProcesso
rs(); | 151 *firstCoverageStageIdx = pipelineBuilder.numCoverageFragmentStages(); |
157 } else { | 152 } else { |
158 if (coveragePOI.readsFragPosition()) { | 153 if (coveragePOI.readsFragPosition()) { |
159 fReadsFragPosition = true; | 154 fReadsFragPosition = true; |
160 } | 155 } |
161 } | 156 } |
162 } | 157 } |
163 | 158 |
164 //////////////////////////////////////////////////////////////////////////////// | 159 //////////////////////////////////////////////////////////////////////////////// |
165 | 160 |
166 bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b, | 161 bool GrPipeline::AreEqual(const GrPipeline& a, const GrPipeline& b, |
167 bool ignoreCoordTransforms) { | 162 bool ignoreCoordTransforms) { |
168 SkASSERT(&a != &b); | 163 SkASSERT(&a != &b); |
169 | 164 |
170 if (a.getRenderTarget() != b.getRenderTarget() || | 165 if (a.getRenderTarget() != b.getRenderTarget() || |
171 a.fFragmentProcessors.count() != b.fFragmentProcessors.count() || | 166 a.fFragmentStages.count() != b.fFragmentStages.count() || |
172 a.fNumColorProcessors != b.fNumColorProcessors || | 167 a.fNumColorStages != b.fNumColorStages || |
173 a.fScissorState != b.fScissorState || | 168 a.fScissorState != b.fScissorState || |
174 a.fFlags != b.fFlags || | 169 a.fFlags != b.fFlags || |
175 a.fStencilSettings != b.fStencilSettings || | 170 a.fStencilSettings != b.fStencilSettings || |
176 a.fDrawFace != b.fDrawFace) { | 171 a.fDrawFace != b.fDrawFace) { |
177 return false; | 172 return false; |
178 } | 173 } |
179 | 174 |
180 if (!a.getXferProcessor()->isEqual(*b.getXferProcessor())) { | 175 if (!a.getXferProcessor()->isEqual(*b.getXferProcessor())) { |
181 return false; | 176 return false; |
182 } | 177 } |
183 | 178 |
184 for (int i = 0; i < a.numFragmentProcessors(); i++) { | 179 for (int i = 0; i < a.numFragmentStages(); i++) { |
185 if (!a.getFragmentProcessor(i).isEqual(b.getFragmentProcessor(i), ignore
CoordTransforms)) { | 180 if (!a.getFragmentStage(i).processor()->isEqual(*b.getFragmentStage(i).p
rocessor(), |
| 181 ignoreCoordTransform
s)) { |
186 return false; | 182 return false; |
187 } | 183 } |
188 } | 184 } |
189 return true; | 185 return true; |
190 } | 186 } |
191 | 187 |
OLD | NEW |