1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef GrGLSLVarying_DEFINED
#define GrGLSLVarying_DEFINED
#include "GrAllocator.h"
#include "GrGeometryProcessor.h"
#include "GrShaderVar.h"
#include "GrTypesPriv.h"
#include "glsl/GrGLSLProgramDataManager.h"
class GrGLSLProgramBuilder;
class GrGLSLVarying {
public:
enum class Scope {
kVertToFrag,
kVertToGeo,
kGeoToFrag
};
GrGLSLVarying() = default;
GrGLSLVarying(GrSLType type, Scope scope = Scope::kVertToFrag) : fType(type), fScope(scope) {}
void reset(GrSLType type, Scope scope = Scope::kVertToFrag) {
*this = GrGLSLVarying();
fType = type;
fScope = scope;
}
GrSLType type() const { return fType; }
Scope scope() const { return fScope; }
bool isInVertexShader() const { return Scope::kGeoToFrag != fScope; }
bool isInFragmentShader() const { return Scope::kVertToGeo != fScope; }
const char* vsOut() const { SkASSERT(this->isInVertexShader()); return fVsOut; }
const char* gsIn() const { return fGsIn; }
const char* gsOut() const { return fGsOut; }
const char* fsIn() const { SkASSERT(this->isInFragmentShader()); return fFsIn; }
private:
GrSLType fType = kVoid_GrSLType;
Scope fScope = Scope::kVertToFrag;
const char* fVsOut = nullptr;
const char* fGsIn = nullptr;
const char* fGsOut = nullptr;
const char* fFsIn = nullptr;
friend class GrGLSLVaryingHandler;
};
static const int kVaryingsPerBlock = 8;
class GrGLSLVaryingHandler {
public:
explicit GrGLSLVaryingHandler(GrGLSLProgramBuilder* program)
: fVaryings(kVaryingsPerBlock)
, fVertexInputs(kVaryingsPerBlock)
, fVertexOutputs(kVaryingsPerBlock)
, fGeomInputs(kVaryingsPerBlock)
, fGeomOutputs(kVaryingsPerBlock)
, fFragInputs(kVaryingsPerBlock)
, fFragOutputs(kVaryingsPerBlock)
, fProgramBuilder(program)
, fDefaultInterpolationModifier(nullptr) {}
virtual ~GrGLSLVaryingHandler() {}
/*
* Notifies the varying handler that this shader will never emit geometry in perspective and
* therefore does not require perspective-correct interpolation. When supported, this allows
* varyings to use the "noperspective" keyword, which means the GPU can use cheaper math for
* interpolation.
*/
void setNoPerspective();
enum class Interpolation {
kInterpolated,
kCanBeFlat, // Use "flat" if it will be faster.
kMustBeFlat // Use "flat" even if it is known to be slow.
};
/*
* addVarying allows fine grained control for setting up varyings between stages. Calling this
* function will make sure all necessary decls are setup for the client. The client however is
* responsible for setting up all shader code (e.g "vOut = vIn;") If you just need to take an
* attribute and pass it through to an output value in a fragment shader, use
* addPassThroughAttribute.
* TODO convert most uses of addVarying to addPassThroughAttribute
*/
void addVarying(const char* name, GrGLSLVarying* varying,
Interpolation = Interpolation::kInterpolated);
/*
* The GP can use these calls to pass an attribute through all shaders directly to 'output' in
* the fragment shader. Though these calls affect both the vertex shader and fragment shader,
* they expect 'output' to be defined in the fragment shader before the call is made. If there
* is a geometry shader, we will simply take the value of the varying from the first vertex and
* that will be set as the output varying for all emitted vertices.
* TODO it might be nicer behavior to have a flag to declare output inside these calls
*/
void addPassThroughAttribute(const GrGeometryProcessor::Attribute&, const char* output,
Interpolation = Interpolation::kInterpolated);
void emitAttributes(const GrGeometryProcessor& gp);
// This should be called once all attributes and varyings have been added to the
// GrGLSLVaryingHanlder and before getting/adding any of the declarations to the shaders.
void finalize();
void getVertexDecls(SkString* inputDecls, SkString* outputDecls) const;
void getGeomDecls(SkString* inputDecls, SkString* outputDecls) const;
void getFragDecls(SkString* inputDecls, SkString* outputDecls) const;
protected:
struct VaryingInfo {
GrSLType fType;
bool fIsFlat;
SkString fVsOut;
SkString fGsOut;
GrShaderFlags fVisibility;
};
typedef GrTAllocator<VaryingInfo> VaryingList;
typedef GrTAllocator<GrShaderVar> VarArray;
typedef GrGLSLProgramDataManager::VaryingHandle VaryingHandle;
VaryingList fVaryings;
VarArray fVertexInputs;
VarArray fVertexOutputs;
VarArray fGeomInputs;
VarArray fGeomOutputs;
VarArray fFragInputs;
VarArray fFragOutputs;
// This is not owned by the class
GrGLSLProgramBuilder* fProgramBuilder;
private:
void addAttribute(const GrShaderVar& var);
virtual void onFinalize() = 0;
// helper function for get*Decls
void appendDecls(const VarArray& vars, SkString* out) const;
const char* fDefaultInterpolationModifier;
friend class GrGLSLProgramBuilder;
};
#endif
|
