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 "GrPipelineBuilder.h" | 8 #include "GrPipelineBuilder.h" |
9 | 9 |
10 #include "GrBlend.h" | 10 #include "GrBlend.h" |
11 #include "GrPaint.h" | 11 #include "GrPaint.h" |
12 #include "GrPipeline.h" | 12 #include "GrPipeline.h" |
13 #include "GrProcOptInfo.h" | 13 #include "GrProcOptInfo.h" |
14 #include "GrXferProcessor.h" | 14 #include "GrXferProcessor.h" |
15 #include "batches/GrBatch.h" | 15 #include "batches/GrBatch.h" |
16 #include "effects/GrPorterDuffXferProcessor.h" | 16 #include "effects/GrPorterDuffXferProcessor.h" |
17 | 17 |
18 GrPipelineBuilder::GrPipelineBuilder() | 18 GrPipelineBuilder::GrPipelineBuilder() |
19 : fProcDataManager(SkNEW(GrProcessorDataManager)) | 19 : fProcDataManager(SkNEW(GrProcessorDataManager)) |
20 , fFlags(0x0) | 20 , fFlags(0x0) |
21 , fDrawFace(kBoth_DrawFace) { | 21 , fDrawFace(kBoth_DrawFace) { |
22 SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) | 22 SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) |
23 } | 23 } |
24 | 24 |
| 25 GrPipelineBuilder& GrPipelineBuilder::operator=(const GrPipelineBuilder& that) { |
| 26 fProcDataManager.reset(SkNEW_ARGS(GrProcessorDataManager, (*that.processorDa
taManager()))); |
| 27 fRenderTarget.reset(SkSafeRef(that.fRenderTarget.get())); |
| 28 fFlags = that.fFlags; |
| 29 fStencilSettings = that.fStencilSettings; |
| 30 fDrawFace = that.fDrawFace; |
| 31 fXPFactory.reset(SkRef(that.getXPFactory())); |
| 32 fColorStages = that.fColorStages; |
| 33 fCoverageStages = that.fCoverageStages; |
| 34 fClip = that.fClip; |
| 35 |
| 36 return *this; |
| 37 } |
| 38 |
25 GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, c
onst GrClip& clip) { | 39 GrPipelineBuilder::GrPipelineBuilder(const GrPaint& paint, GrRenderTarget* rt, c
onst GrClip& clip) { |
26 SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) | 40 SkDEBUGCODE(fBlockEffectRemovalCnt = 0;) |
27 | 41 |
28 // TODO keep this logically const using an AutoReset | 42 // TODO keep this logically const using an AutoReset |
29 fProcDataManager.reset( | 43 fProcDataManager.reset( |
30 const_cast<GrProcessorDataManager*>(SkRef(paint.processorDataManager())
)); | 44 const_cast<GrProcessorDataManager*>(SkRef(paint.processorDataManager())
)); |
31 | 45 |
32 for (int i = 0; i < paint.numColorFragmentProcessors(); ++i) { | 46 fColorStages.reset(); |
33 fColorFragmentProcessors.push_back(SkRef(paint.getColorFragmentProcessor
(i))); | 47 fCoverageStages.reset(); |
| 48 |
| 49 for (int i = 0; i < paint.numColorStages(); ++i) { |
| 50 fColorStages.push_back(paint.getColorStage(i)); |
34 } | 51 } |
35 | 52 |
36 for (int i = 0; i < paint.numCoverageFragmentProcessors(); ++i) { | 53 for (int i = 0; i < paint.numCoverageStages(); ++i) { |
37 fCoverageFragmentProcessors.push_back(SkRef(paint.getCoverageFragmentPro
cessor(i))); | 54 fCoverageStages.push_back(paint.getCoverageStage(i)); |
38 } | 55 } |
39 | 56 |
40 fXPFactory.reset(SkRef(paint.getXPFactory())); | 57 fXPFactory.reset(SkRef(paint.getXPFactory())); |
41 | 58 |
42 this->setRenderTarget(rt); | 59 this->setRenderTarget(rt); |
43 | 60 |
44 // These have no equivalent in GrPaint, set them to defaults | 61 // These have no equivalent in GrPaint, set them to defaults |
45 fDrawFace = kBoth_DrawFace; | 62 fDrawFace = kBoth_DrawFace; |
46 fStencilSettings.setDisabled(); | 63 fStencilSettings.setDisabled(); |
47 fFlags = 0; | 64 fFlags = 0; |
(...skipping 10 matching lines...) Expand all Loading... |
58 bool GrPipelineBuilder::willXPNeedDstTexture(const GrCaps& caps, | 75 bool GrPipelineBuilder::willXPNeedDstTexture(const GrCaps& caps, |
59 const GrProcOptInfo& colorPOI, | 76 const GrProcOptInfo& colorPOI, |
60 const GrProcOptInfo& coveragePOI) c
onst { | 77 const GrProcOptInfo& coveragePOI) c
onst { |
61 return this->getXPFactory()->willNeedDstTexture(caps, colorPOI, coveragePOI, | 78 return this->getXPFactory()->willNeedDstTexture(caps, colorPOI, coveragePOI, |
62 this->hasMixedSamples()); | 79 this->hasMixedSamples()); |
63 } | 80 } |
64 | 81 |
65 void GrPipelineBuilder::AutoRestoreFragmentProcessorState::set( | 82 void GrPipelineBuilder::AutoRestoreFragmentProcessorState::set( |
66 const GrPipelineBuilder
* pipelineBuilder) { | 83 const GrPipelineBuilder
* pipelineBuilder) { |
67 if (fPipelineBuilder) { | 84 if (fPipelineBuilder) { |
68 int m = fPipelineBuilder->numColorFragmentProcessors() - fColorEffectCnt
; | 85 int m = fPipelineBuilder->numColorFragmentStages() - fColorEffectCnt; |
69 SkASSERT(m >= 0); | 86 SkASSERT(m >= 0); |
70 for (int i = 0; i < m; ++i) { | 87 fPipelineBuilder->fColorStages.pop_back_n(m); |
71 fPipelineBuilder->fColorFragmentProcessors.fromBack(i)->unref(); | |
72 } | |
73 fPipelineBuilder->fColorFragmentProcessors.pop_back_n(m); | |
74 | 88 |
75 int n = fPipelineBuilder->numCoverageFragmentProcessors() - fCoverageEff
ectCnt; | 89 int n = fPipelineBuilder->numCoverageFragmentStages() - fCoverageEffectC
nt; |
76 SkASSERT(n >= 0); | 90 SkASSERT(n >= 0); |
77 for (int i = 0; i < n; ++i) { | 91 fPipelineBuilder->fCoverageStages.pop_back_n(n); |
78 fPipelineBuilder->fCoverageFragmentProcessors.fromBack(i)->unref(); | 92 |
79 } | |
80 fPipelineBuilder->fCoverageFragmentProcessors.pop_back_n(n); | |
81 SkDEBUGCODE(--fPipelineBuilder->fBlockEffectRemovalCnt;) | 93 SkDEBUGCODE(--fPipelineBuilder->fBlockEffectRemovalCnt;) |
82 fPipelineBuilder->getProcessorDataManager()->restoreToSaveMarker(/*fSave
Marker*/); | 94 fPipelineBuilder->getProcessorDataManager()->restoreToSaveMarker(/*fSave
Marker*/); |
83 } | 95 } |
84 fPipelineBuilder = const_cast<GrPipelineBuilder*>(pipelineBuilder); | 96 fPipelineBuilder = const_cast<GrPipelineBuilder*>(pipelineBuilder); |
85 if (NULL != pipelineBuilder) { | 97 if (NULL != pipelineBuilder) { |
86 fColorEffectCnt = pipelineBuilder->numColorFragmentProcessors(); | 98 fColorEffectCnt = pipelineBuilder->numColorFragmentStages(); |
87 fCoverageEffectCnt = pipelineBuilder->numCoverageFragmentProcessors(); | 99 fCoverageEffectCnt = pipelineBuilder->numCoverageFragmentStages(); |
88 SkDEBUGCODE(++pipelineBuilder->fBlockEffectRemovalCnt;) | 100 SkDEBUGCODE(++pipelineBuilder->fBlockEffectRemovalCnt;) |
89 fSaveMarker = pipelineBuilder->processorDataManager()->currentSaveMarker
(); | 101 fSaveMarker = pipelineBuilder->processorDataManager()->currentSaveMarker
(); |
90 } | 102 } |
91 } | 103 } |
92 | 104 |
93 //////////////////////////////////////////////////////////////////////////////// | 105 //////////////////////////////////////////////////////////////////////////////// |
94 | 106 |
95 GrPipelineBuilder::~GrPipelineBuilder() { | 107 GrPipelineBuilder::~GrPipelineBuilder() { |
96 SkASSERT(0 == fBlockEffectRemovalCnt); | 108 SkASSERT(0 == fBlockEffectRemovalCnt); |
97 for (int i = 0; i < fColorFragmentProcessors.count(); ++i) { | |
98 fColorFragmentProcessors[i]->unref(); | |
99 } | |
100 for (int i = 0; i < fCoverageFragmentProcessors.count(); ++i) { | |
101 fCoverageFragmentProcessors[i]->unref(); | |
102 } | |
103 } | 109 } |
104 | 110 |
105 //////////////////////////////////////////////////////////////////////////////// | 111 //////////////////////////////////////////////////////////////////////////////// |
106 | 112 |
107 void GrPipelineBuilder::calcColorInvariantOutput(const GrPrimitiveProcessor* pp)
const { | 113 void GrPipelineBuilder::calcColorInvariantOutput(const GrPrimitiveProcessor* pp)
const { |
108 fColorProcInfo.calcColorWithPrimProc(pp, fColorFragmentProcessors.begin(), | 114 fColorProcInfo.calcColorWithPrimProc(pp, fColorStages.begin(), this->numColo
rFragmentStages()); |
109 this->numColorFragmentProcessors()); | |
110 | |
111 } | 115 } |
112 | 116 |
113 void GrPipelineBuilder::calcCoverageInvariantOutput(const GrPrimitiveProcessor*
pp) const { | 117 void GrPipelineBuilder::calcCoverageInvariantOutput(const GrPrimitiveProcessor*
pp) const { |
114 fCoverageProcInfo.calcCoverageWithPrimProc(pp, fCoverageFragmentProcessors.b
egin(), | 118 fCoverageProcInfo.calcCoverageWithPrimProc(pp, fCoverageStages.begin(), |
115 this->numCoverageFragmentProcesso
rs()); | 119 this->numCoverageFragmentStages()); |
116 } | 120 } |
117 | 121 |
118 void GrPipelineBuilder::calcColorInvariantOutput(const GrDrawBatch* batch) const
{ | 122 void GrPipelineBuilder::calcColorInvariantOutput(const GrDrawBatch* batch) const
{ |
119 fColorProcInfo.calcColorWithBatch(batch, fColorFragmentProcessors.begin(), | 123 fColorProcInfo.calcColorWithBatch(batch, fColorStages.begin(), this->numColo
rFragmentStages()); |
120 this->numColorFragmentProcessors()); | |
121 } | 124 } |
122 | 125 |
123 void GrPipelineBuilder::calcCoverageInvariantOutput(const GrDrawBatch* batch) co
nst { | 126 void GrPipelineBuilder::calcCoverageInvariantOutput(const GrDrawBatch* batch) co
nst { |
124 fCoverageProcInfo.calcCoverageWithBatch(batch, fCoverageFragmentProcessors.b
egin(), | 127 fCoverageProcInfo.calcCoverageWithBatch(batch, fCoverageStages.begin(), |
125 this->numCoverageFragmentProcessors(
)); | 128 this->numCoverageFragmentStages()); |
126 } | 129 } |
| 130 |
OLD | NEW |