OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 Google Inc. | 2 * Copyright 2011 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 GrGLSLShaderVar_DEFINED | 8 #ifndef GrGLSLShaderVar_DEFINED |
9 #define GrGLSLShaderVar_DEFINED | 9 #define GrGLSLShaderVar_DEFINED |
10 | 10 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
44 | 44 |
45 GrGLSLShaderVar(const GrShaderVar& var) | 45 GrGLSLShaderVar(const GrShaderVar& var) |
46 : GrShaderVar(var) | 46 : GrShaderVar(var) |
47 , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) { | 47 , fUseUniformFloatArrays(USE_UNIFORM_FLOAT_ARRAYS) { |
48 SkASSERT(kVoid_GrSLType != var.getType()); | 48 SkASSERT(kVoid_GrSLType != var.getType()); |
49 } | 49 } |
50 | 50 |
51 GrGLSLShaderVar(const GrGLSLShaderVar& var) | 51 GrGLSLShaderVar(const GrGLSLShaderVar& var) |
52 : GrShaderVar(var.c_str(), var.getType(), var.getTypeModifier(), | 52 : GrShaderVar(var.c_str(), var.getType(), var.getTypeModifier(), |
53 var.getArrayCount(), var.getPrecision()) | 53 var.getArrayCount(), var.getPrecision()) |
54 , fUseUniformFloatArrays(var.fUseUniformFloatArrays) { | 54 , fUseUniformFloatArrays(var.fUseUniformFloatArrays) |
| 55 , fLayoutQualifier(var.fLayoutQualifier) |
| 56 , fExtraModifiers(var.fExtraModifiers) { |
55 SkASSERT(kVoid_GrSLType != var.getType()); | 57 SkASSERT(kVoid_GrSLType != var.getType()); |
56 } | 58 } |
57 | 59 |
58 /** | 60 /** |
59 * Values for array count that have special meaning. We allow 1-sized arrays
. | 61 * Values for array count that have special meaning. We allow 1-sized arrays
. |
60 */ | 62 */ |
61 enum { | 63 enum { |
62 kNonArray = 0, // not an array | 64 kNonArray = 0, // not an array |
63 kUnsizedArray = -1, // an unsized array (declared with []) | 65 kUnsizedArray = -1, // an unsized array (declared with []) |
64 }; | 66 }; |
65 | 67 |
66 /** | 68 /** |
67 * Sets as a non-array. | 69 * Sets as a non-array. |
68 */ | 70 */ |
69 void set(GrSLType type, | 71 void set(GrSLType type, |
70 TypeModifier typeModifier, | 72 TypeModifier typeModifier, |
71 const SkString& name, | 73 const SkString& name, |
72 GrSLPrecision precision = kDefault_GrSLPrecision, | 74 GrSLPrecision precision = kDefault_GrSLPrecision, |
73 const char* layoutQualifier = nullptr, | 75 const char* layoutQualifier = nullptr, |
| 76 const char* extraModifiers = nullptr, |
74 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 77 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
75 SkASSERT(kVoid_GrSLType != type); | 78 SkASSERT(kVoid_GrSLType != type); |
76 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; | 79 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; |
77 INHERITED::set(type, name, typeModifier, precision); | 80 INHERITED::set(type, name, typeModifier, precision); |
78 fLayoutQualifier = layoutQualifier; | 81 fLayoutQualifier = layoutQualifier; |
| 82 if (extraModifiers) { |
| 83 fExtraModifiers.printf("%s ", extraModifiers); |
| 84 } |
79 fUseUniformFloatArrays = useUniformFloatArrays; | 85 fUseUniformFloatArrays = useUniformFloatArrays; |
80 } | 86 } |
81 | 87 |
82 /** | 88 /** |
83 * Sets as a non-array. | 89 * Sets as a non-array. |
84 */ | 90 */ |
85 void set(GrSLType type, | 91 void set(GrSLType type, |
86 TypeModifier typeModifier, | 92 TypeModifier typeModifier, |
87 const char* name, | 93 const char* name, |
88 GrSLPrecision precision = kDefault_GrSLPrecision, | 94 GrSLPrecision precision = kDefault_GrSLPrecision, |
89 const char* layoutQualifier = nullptr, | 95 const char* layoutQualifier = nullptr, |
| 96 const char* extraModifiers = nullptr, |
90 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 97 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
91 SkASSERT(kVoid_GrSLType != type); | 98 SkASSERT(kVoid_GrSLType != type); |
92 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; | 99 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; |
93 INHERITED::set(type, name, typeModifier, precision); | 100 INHERITED::set(type, name, typeModifier, precision); |
94 fLayoutQualifier = layoutQualifier; | 101 fLayoutQualifier = layoutQualifier; |
| 102 if (extraModifiers) { |
| 103 fExtraModifiers.printf("%s ", extraModifiers); |
| 104 } |
95 fUseUniformFloatArrays = useUniformFloatArrays; | 105 fUseUniformFloatArrays = useUniformFloatArrays; |
96 } | 106 } |
97 | 107 |
98 /** | 108 /** |
99 * Set all var options | 109 * Set all var options |
100 */ | 110 */ |
101 void set(GrSLType type, | 111 void set(GrSLType type, |
102 TypeModifier typeModifier, | 112 TypeModifier typeModifier, |
103 const SkString& name, | 113 const SkString& name, |
104 int count, | 114 int count, |
105 GrSLPrecision precision = kDefault_GrSLPrecision, | 115 GrSLPrecision precision = kDefault_GrSLPrecision, |
106 const char* layoutQualifier = nullptr, | 116 const char* layoutQualifier = nullptr, |
| 117 const char* extraModifiers = nullptr, |
107 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 118 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
108 SkASSERT(kVoid_GrSLType != type); | 119 SkASSERT(kVoid_GrSLType != type); |
109 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; | 120 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; |
110 INHERITED::set(type, name, typeModifier, precision, count); | 121 INHERITED::set(type, name, typeModifier, precision, count); |
111 fLayoutQualifier = layoutQualifier; | 122 fLayoutQualifier = layoutQualifier; |
| 123 if (extraModifiers) { |
| 124 fExtraModifiers.printf("%s ", extraModifiers); |
| 125 } |
112 fUseUniformFloatArrays = useUniformFloatArrays; | 126 fUseUniformFloatArrays = useUniformFloatArrays; |
113 } | 127 } |
114 | 128 |
115 /** | 129 /** |
116 * Set all var options | 130 * Set all var options |
117 */ | 131 */ |
118 void set(GrSLType type, | 132 void set(GrSLType type, |
119 TypeModifier typeModifier, | 133 TypeModifier typeModifier, |
120 const char* name, | 134 const char* name, |
121 int count, | 135 int count, |
122 GrSLPrecision precision = kDefault_GrSLPrecision, | 136 GrSLPrecision precision = kDefault_GrSLPrecision, |
123 const char* layoutQualifier = nullptr, | 137 const char* layoutQualifier = nullptr, |
| 138 const char* extraModifiers = nullptr, |
124 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 139 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
125 SkASSERT(kVoid_GrSLType != type); | 140 SkASSERT(kVoid_GrSLType != type); |
126 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; | 141 SkASSERT(kDefault_GrSLPrecision == precision || GrSLTypeIsNumeric(type))
; |
127 INHERITED::set(type, name, typeModifier, precision, count); | 142 INHERITED::set(type, name, typeModifier, precision, count); |
128 fLayoutQualifier = layoutQualifier; | 143 fLayoutQualifier = layoutQualifier; |
| 144 if (extraModifiers) { |
| 145 fExtraModifiers.printf("%s ", extraModifiers); |
| 146 } |
129 fUseUniformFloatArrays = useUniformFloatArrays; | 147 fUseUniformFloatArrays = useUniformFloatArrays; |
130 } | 148 } |
131 | 149 |
132 /** | 150 /** |
133 * Set the layout qualifier | 151 * Set the layout qualifier |
134 */ | 152 */ |
135 void setLayoutQualifier(const char* layoutQualifier) { | 153 void setLayoutQualifier(const char* layoutQualifier) { |
136 fLayoutQualifier = layoutQualifier; | 154 fLayoutQualifier = layoutQualifier; |
137 } | 155 } |
138 | 156 |
| 157 void addModifier(const char* modifier) { |
| 158 if (modifier) { |
| 159 fExtraModifiers.appendf("%s ", modifier); |
| 160 } |
| 161 } |
| 162 |
139 /** | 163 /** |
140 * Write a declaration of this variable to out. | 164 * Write a declaration of this variable to out. |
141 */ | 165 */ |
142 void appendDecl(const GrGLSLCaps* glslCaps, SkString* out) const { | 166 void appendDecl(const GrGLSLCaps* glslCaps, SkString* out) const { |
143 SkASSERT(kDefault_GrSLPrecision == fPrecision || GrSLTypeIsNumeric(fType
)); | 167 SkASSERT(kDefault_GrSLPrecision == fPrecision || GrSLTypeIsNumeric(fType
)); |
144 if (!fLayoutQualifier.isEmpty()) { | 168 if (!fLayoutQualifier.isEmpty()) { |
145 out->appendf("layout(%s) ", fLayoutQualifier.c_str()); | 169 out->appendf("layout(%s) ", fLayoutQualifier.c_str()); |
146 } | 170 } |
| 171 out->append(fExtraModifiers); |
147 if (this->getTypeModifier() != kNone_TypeModifier) { | 172 if (this->getTypeModifier() != kNone_TypeModifier) { |
148 if (GrSLTypeIsIntType(fType) && (this->getTypeModifier() == kVarying
In_TypeModifier || | |
149 this->getTypeModifier() == kVarying
Out_TypeModifier)) { | |
150 out->append("flat "); | |
151 } | |
152 out->append(TypeModifierString(glslCaps, this->getTypeModifier())); | 173 out->append(TypeModifierString(glslCaps, this->getTypeModifier())); |
153 out->append(" "); | 174 out->append(" "); |
154 } | 175 } |
155 GrSLType effectiveType = this->getType(); | 176 GrSLType effectiveType = this->getType(); |
156 if (effectiveType != kBool_GrSLType) { | 177 if (effectiveType != kBool_GrSLType) { |
157 out->append(PrecisionString(glslCaps, fPrecision)); | 178 out->append(PrecisionString(glslCaps, fPrecision)); |
158 } | 179 } |
159 if (this->isArray()) { | 180 if (this->isArray()) { |
160 if (this->isUnsizedArray()) { | 181 if (this->isUnsizedArray()) { |
161 out->appendf("%s %s[]", | 182 out->appendf("%s %s[]", |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
227 case kVaryingOut_TypeModifier: | 248 case kVaryingOut_TypeModifier: |
228 return k110_GrGLSLGeneration == gen ? "varying" : "out"; | 249 return k110_GrGLSLGeneration == gen ? "varying" : "out"; |
229 default: | 250 default: |
230 SkFAIL("Unknown shader variable type modifier."); | 251 SkFAIL("Unknown shader variable type modifier."); |
231 return ""; // suppress warning | 252 return ""; // suppress warning |
232 } | 253 } |
233 } | 254 } |
234 | 255 |
235 /// Work around driver bugs on some hardware that don't correctly | 256 /// Work around driver bugs on some hardware that don't correctly |
236 /// support uniform float [] | 257 /// support uniform float [] |
237 bool fUseUniformFloatArrays; | 258 bool fUseUniformFloatArrays; |
238 | 259 |
239 SkString fLayoutQualifier; | 260 SkString fLayoutQualifier; |
| 261 SkString fExtraModifiers; |
240 | 262 |
241 typedef GrShaderVar INHERITED; | 263 typedef GrShaderVar INHERITED; |
242 }; | 264 }; |
243 | 265 |
244 #endif | 266 #endif |
OLD | NEW |