OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 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 #ifndef GrGLSLPrimitiveProcessor_DEFINED | 8 #ifndef GrGLSLPrimitiveProcessor_DEFINED |
9 #define GrGLSLPrimitiveProcessor_DEFINED | 9 #define GrGLSLPrimitiveProcessor_DEFINED |
10 | 10 |
| 11 #include "GrFragmentProcessor.h" |
11 #include "GrPrimitiveProcessor.h" | 12 #include "GrPrimitiveProcessor.h" |
12 #include "glsl/GrGLSLProgramDataManager.h" | 13 #include "glsl/GrGLSLProgramDataManager.h" |
13 #include "glsl/GrGLSLSampler.h" | 14 #include "glsl/GrGLSLSampler.h" |
14 | 15 |
15 class GrBatchTracker; | 16 class GrBatchTracker; |
16 class GrPrimitiveProcessor; | 17 class GrPrimitiveProcessor; |
17 class GrGLSLCaps; | 18 class GrGLSLCaps; |
18 class GrGLSLPPFragmentBuilder; | 19 class GrGLSLPPFragmentBuilder; |
19 class GrGLSLGPBuilder; | 20 class GrGLSLGPBuilder; |
20 class GrGLSLUniformHandler; | 21 class GrGLSLUniformHandler; |
21 class GrGLSLVaryingHandler; | 22 class GrGLSLVaryingHandler; |
22 class GrGLSLVertexBuilder; | 23 class GrGLSLVertexBuilder; |
23 | 24 |
24 class GrGLSLPrimitiveProcessor { | 25 class GrGLSLPrimitiveProcessor { |
25 public: | 26 public: |
| 27 using FPCoordTransformIter = GrFragmentProcessor::CoordTransformIter; |
| 28 |
26 virtual ~GrGLSLPrimitiveProcessor() {} | 29 virtual ~GrGLSLPrimitiveProcessor() {} |
27 | 30 |
28 typedef GrGLSLProgramDataManager::UniformHandle UniformHandle; | 31 typedef GrGLSLProgramDataManager::UniformHandle UniformHandle; |
29 typedef GrGLSLProgramDataManager::UniformHandle SamplerHandle; | 32 typedef GrGLSLProgramDataManager::UniformHandle SamplerHandle; |
30 | 33 |
31 typedef SkSTArray<2, const GrCoordTransform*, true> ProcCoords; | 34 /** |
32 typedef SkSTArray<8, ProcCoords> TransformsIn; | 35 * This class provides access to the GrCoordTransforms across all GrFragment
Processors in a |
33 typedef SkSTArray<8, SkTArray<GrShaderVar>> TransformsOut; | 36 * GrPipeline. It is also used by the primitive processor to specify the fra
gment shader |
| 37 * variable that will hold the transformed coords for each GrCoordTransform.
It is required that |
| 38 * the primitive processor iterate over each coord transform and insert a sh
ader var result for |
| 39 * each. The GrGLSLFragmentProcessors will reference these variables in thei
r fragment code. |
| 40 */ |
| 41 class FPCoordTransformHandler : public SkNoncopyable { |
| 42 public: |
| 43 FPCoordTransformHandler(const GrPipeline& pipeline, |
| 44 SkTArray<GrShaderVar>* transformedCoordVars) |
| 45 : fIter(pipeline) |
| 46 , fTransformedCoordVars(transformedCoordVars) {} |
| 47 |
| 48 ~FPCoordTransformHandler() { SkASSERT(!this->nextCoordTransform());} |
| 49 |
| 50 const GrCoordTransform* nextCoordTransform(); |
| 51 |
| 52 // 'args' are constructor params to GrShaderVar. |
| 53 template<typename... Args> |
| 54 void specifyCoordsForCurrCoordTransform(Args&&... args) { |
| 55 SkASSERT(!fAddedCoord); |
| 56 fTransformedCoordVars->emplace_back(std::forward<Args>(args)...); |
| 57 SkDEBUGCODE(fAddedCoord = true;) |
| 58 } |
| 59 |
| 60 private: |
| 61 GrFragmentProcessor::CoordTransformIter fIter; |
| 62 SkDEBUGCODE(bool fAddedCoord = false;) |
| 63 SkDEBUGCODE(const GrCoordTransform* fCurr = nullptr;) |
| 64 SkTArray<GrShaderVar>* fTransformedCoordVars; |
| 65 }; |
34 | 66 |
35 struct EmitArgs { | 67 struct EmitArgs { |
36 EmitArgs(GrGLSLVertexBuilder* vertBuilder, | 68 EmitArgs(GrGLSLVertexBuilder* vertBuilder, |
37 GrGLSLPPFragmentBuilder* fragBuilder, | 69 GrGLSLPPFragmentBuilder* fragBuilder, |
38 GrGLSLVaryingHandler* varyingHandler, | 70 GrGLSLVaryingHandler* varyingHandler, |
39 GrGLSLUniformHandler* uniformHandler, | 71 GrGLSLUniformHandler* uniformHandler, |
40 const GrGLSLCaps* caps, | 72 const GrGLSLCaps* caps, |
41 const GrPrimitiveProcessor& gp, | 73 const GrPrimitiveProcessor& gp, |
42 const char* outputColor, | 74 const char* outputColor, |
43 const char* outputCoverage, | 75 const char* outputCoverage, |
44 const char* distanceVectorName, | 76 const char* distanceVectorName, |
45 const SamplerHandle* texSamplers, | 77 const SamplerHandle* texSamplers, |
46 const SamplerHandle* bufferSamplers, | 78 const SamplerHandle* bufferSamplers, |
47 const TransformsIn& transformsIn, | 79 FPCoordTransformHandler* transformHandler) |
48 TransformsOut* transformsOut) | |
49 : fVertBuilder(vertBuilder) | 80 : fVertBuilder(vertBuilder) |
50 , fFragBuilder(fragBuilder) | 81 , fFragBuilder(fragBuilder) |
51 , fVaryingHandler(varyingHandler) | 82 , fVaryingHandler(varyingHandler) |
52 , fUniformHandler(uniformHandler) | 83 , fUniformHandler(uniformHandler) |
53 , fGLSLCaps(caps) | 84 , fGLSLCaps(caps) |
54 , fGP(gp) | 85 , fGP(gp) |
55 , fOutputColor(outputColor) | 86 , fOutputColor(outputColor) |
56 , fOutputCoverage(outputCoverage) | 87 , fOutputCoverage(outputCoverage) |
57 , fDistanceVectorName(distanceVectorName) | 88 , fDistanceVectorName(distanceVectorName) |
58 , fTexSamplers(texSamplers) | 89 , fTexSamplers(texSamplers) |
59 , fBufferSamplers(bufferSamplers) | 90 , fBufferSamplers(bufferSamplers) |
60 , fTransformsIn(transformsIn) | 91 , fFPCoordTransformHandler(transformHandler) {} |
61 , fTransformsOut(transformsOut) {} | |
62 GrGLSLVertexBuilder* fVertBuilder; | 92 GrGLSLVertexBuilder* fVertBuilder; |
63 GrGLSLPPFragmentBuilder* fFragBuilder; | 93 GrGLSLPPFragmentBuilder* fFragBuilder; |
64 GrGLSLVaryingHandler* fVaryingHandler; | 94 GrGLSLVaryingHandler* fVaryingHandler; |
65 GrGLSLUniformHandler* fUniformHandler; | 95 GrGLSLUniformHandler* fUniformHandler; |
66 const GrGLSLCaps* fGLSLCaps; | 96 const GrGLSLCaps* fGLSLCaps; |
67 const GrPrimitiveProcessor& fGP; | 97 const GrPrimitiveProcessor& fGP; |
68 const char* fOutputColor; | 98 const char* fOutputColor; |
69 const char* fOutputCoverage; | 99 const char* fOutputCoverage; |
70 const char* fDistanceVectorName; | 100 const char* fDistanceVectorName; |
71 const SamplerHandle* fTexSamplers; | 101 const SamplerHandle* fTexSamplers; |
72 const SamplerHandle* fBufferSamplers; | 102 const SamplerHandle* fBufferSamplers; |
73 const TransformsIn& fTransformsIn; | 103 FPCoordTransformHandler* fFPCoordTransformHandler; |
74 TransformsOut* fTransformsOut; | |
75 }; | 104 }; |
76 | 105 |
77 /** | 106 /** |
78 * This is similar to emitCode() in the base class, except it takes a full s
hader builder. | 107 * This is similar to emitCode() in the base class, except it takes a full s
hader builder. |
79 * This allows the effect subclass to emit vertex code. | 108 * This allows the effect subclass to emit vertex code. |
80 */ | 109 */ |
81 virtual void emitCode(EmitArgs&) = 0; | 110 virtual void emitCode(EmitArgs&) = 0; |
82 | 111 |
83 /** A GrGLSLPrimitiveProcessor instance can be reused with any GrGLSLPrimiti
veProcessor that | 112 /** |
84 produces the same stage key; this function reads data from a GrGLSLPrimi
tiveProcessor and | 113 * A GrGLSLPrimitiveProcessor instance can be reused with any GrGLSLPrimitiv
eProcessor that |
85 uploads any uniform variables required by the shaders created in emitCo
de(). The | 114 * produces the same stage key; this function reads data from a GrGLSLPrimit
iveProcessor and |
86 GrPrimitiveProcessor parameter is guaranteed to be of the same type that
created this | 115 * uploads any uniform variables required by the shaders created in emitCod
e(). The |
87 GrGLSLPrimitiveProcessor and to have an identical processor key as the o
ne that created this | 116 * GrPrimitiveProcessor parameter is guaranteed to be of the same type and t
o have an |
88 GrGLSLPrimitiveProcessor. */ | 117 * identical processor key as the GrPrimitiveProcessor that created this |
89 virtual void setData(const GrGLSLProgramDataManager&, const GrPrimitiveProce
ssor&) = 0; | 118 * GrGLSLPrimitiveProcessor. |
| 119 * The subclass may use the transform iterator to perform any setup required
for the particular |
| 120 * set of fp transform matrices, such as uploading via uniforms. The iterato
r will iterate over |
| 121 * the transforms in the same order as the TransformHandler passed to emitCo
de. |
| 122 */ |
| 123 virtual void setData(const GrGLSLProgramDataManager&, const GrPrimitiveProce
ssor&, |
| 124 FPCoordTransformIter&&) = 0; |
90 | 125 |
91 static SkMatrix GetTransformMatrix(const SkMatrix& localMatrix, const GrCoor
dTransform&); | 126 static SkMatrix GetTransformMatrix(const SkMatrix& localMatrix, const GrCoor
dTransform&); |
92 | 127 |
93 virtual void setTransformData(const GrPrimitiveProcessor&, | |
94 const GrGLSLProgramDataManager& pdman, | |
95 int index, | |
96 const SkTArray<const GrCoordTransform*, true>&
transforms) = 0; | |
97 | |
98 protected: | 128 protected: |
99 void setupUniformColor(GrGLSLPPFragmentBuilder* fragBuilder, | 129 void setupUniformColor(GrGLSLPPFragmentBuilder* fragBuilder, |
100 GrGLSLUniformHandler* uniformHandler, | 130 GrGLSLUniformHandler* uniformHandler, |
101 const char* outputName, | 131 const char* outputName, |
102 UniformHandle* colorUniform); | 132 UniformHandle* colorUniform); |
103 }; | 133 }; |
104 | 134 |
105 #endif | 135 #endif |
OLD | NEW |