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 GrGLShaderVar_DEFINED | 8 #ifndef GrGLShaderVar_DEFINED |
9 #define GrGLShaderVar_DEFINED | 9 #define GrGLShaderVar_DEFINED |
10 | 10 |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
62 fType = kFloat_GrSLType; | 62 fType = kFloat_GrSLType; |
63 fTypeModifier = kNone_TypeModifier; | 63 fTypeModifier = kNone_TypeModifier; |
64 fCount = kNonArray; | 64 fCount = kNonArray; |
65 fPrecision = kDefault_Precision; | 65 fPrecision = kDefault_Precision; |
66 fOrigin = kDefault_Origin; | 66 fOrigin = kDefault_Origin; |
67 fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS; | 67 fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS; |
68 } | 68 } |
69 | 69 |
70 GrGLShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray, | 70 GrGLShaderVar(const char* name, GrSLType type, int arrayCount = kNonArray, |
71 Precision precision = kDefault_Precision) { | 71 Precision precision = kDefault_Precision) { |
72 GrAssert(kVoid_GrSLType != type); | 72 SkASSERT(kVoid_GrSLType != type); |
73 fType = type; | 73 fType = type; |
74 fTypeModifier = kNone_TypeModifier; | 74 fTypeModifier = kNone_TypeModifier; |
75 fCount = arrayCount; | 75 fCount = arrayCount; |
76 fPrecision = precision; | 76 fPrecision = precision; |
77 fOrigin = kDefault_Origin; | 77 fOrigin = kDefault_Origin; |
78 fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS; | 78 fUseUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS; |
79 fName = name; | 79 fName = name; |
80 } | 80 } |
81 | 81 |
82 GrGLShaderVar(const GrGLShaderVar& var) | 82 GrGLShaderVar(const GrGLShaderVar& var) |
83 : fType(var.fType) | 83 : fType(var.fType) |
84 , fTypeModifier(var.fTypeModifier) | 84 , fTypeModifier(var.fTypeModifier) |
85 , fName(var.fName) | 85 , fName(var.fName) |
86 , fCount(var.fCount) | 86 , fCount(var.fCount) |
87 , fPrecision(var.fPrecision) | 87 , fPrecision(var.fPrecision) |
88 , fOrigin(var.fOrigin) | 88 , fOrigin(var.fOrigin) |
89 , fUseUniformFloatArrays(var.fUseUniformFloatArrays) { | 89 , fUseUniformFloatArrays(var.fUseUniformFloatArrays) { |
90 GrAssert(kVoid_GrSLType != var.fType); | 90 SkASSERT(kVoid_GrSLType != var.fType); |
91 } | 91 } |
92 | 92 |
93 /** | 93 /** |
94 * Values for array count that have special meaning. We allow 1-sized arrays
. | 94 * Values for array count that have special meaning. We allow 1-sized arrays
. |
95 */ | 95 */ |
96 enum { | 96 enum { |
97 kNonArray = 0, // not an array | 97 kNonArray = 0, // not an array |
98 kUnsizedArray = -1, // an unsized array (declared with []) | 98 kUnsizedArray = -1, // an unsized array (declared with []) |
99 }; | 99 }; |
100 | 100 |
101 /** | 101 /** |
102 * Sets as a non-array. | 102 * Sets as a non-array. |
103 */ | 103 */ |
104 void set(GrSLType type, | 104 void set(GrSLType type, |
105 TypeModifier typeModifier, | 105 TypeModifier typeModifier, |
106 const SkString& name, | 106 const SkString& name, |
107 Precision precision = kDefault_Precision, | 107 Precision precision = kDefault_Precision, |
108 Origin origin = kDefault_Origin, | 108 Origin origin = kDefault_Origin, |
109 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 109 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
110 GrAssert(kVoid_GrSLType != type); | 110 SkASSERT(kVoid_GrSLType != type); |
111 fType = type; | 111 fType = type; |
112 fTypeModifier = typeModifier; | 112 fTypeModifier = typeModifier; |
113 fName = name; | 113 fName = name; |
114 fCount = kNonArray; | 114 fCount = kNonArray; |
115 fPrecision = precision; | 115 fPrecision = precision; |
116 fOrigin = origin; | 116 fOrigin = origin; |
117 fUseUniformFloatArrays = useUniformFloatArrays; | 117 fUseUniformFloatArrays = useUniformFloatArrays; |
118 } | 118 } |
119 | 119 |
120 /** | 120 /** |
121 * Sets as a non-array. | 121 * Sets as a non-array. |
122 */ | 122 */ |
123 void set(GrSLType type, | 123 void set(GrSLType type, |
124 TypeModifier typeModifier, | 124 TypeModifier typeModifier, |
125 const char* name, | 125 const char* name, |
126 Precision precision = kDefault_Precision, | 126 Precision precision = kDefault_Precision, |
127 Origin origin = kDefault_Origin, | 127 Origin origin = kDefault_Origin, |
128 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 128 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
129 GrAssert(kVoid_GrSLType != type); | 129 SkASSERT(kVoid_GrSLType != type); |
130 fType = type; | 130 fType = type; |
131 fTypeModifier = typeModifier; | 131 fTypeModifier = typeModifier; |
132 fName = name; | 132 fName = name; |
133 fCount = kNonArray; | 133 fCount = kNonArray; |
134 fPrecision = precision; | 134 fPrecision = precision; |
135 fOrigin = origin; | 135 fOrigin = origin; |
136 fUseUniformFloatArrays = useUniformFloatArrays; | 136 fUseUniformFloatArrays = useUniformFloatArrays; |
137 } | 137 } |
138 | 138 |
139 /** | 139 /** |
140 * Set all var options | 140 * Set all var options |
141 */ | 141 */ |
142 void set(GrSLType type, | 142 void set(GrSLType type, |
143 TypeModifier typeModifier, | 143 TypeModifier typeModifier, |
144 const SkString& name, | 144 const SkString& name, |
145 int count, | 145 int count, |
146 Precision precision = kDefault_Precision, | 146 Precision precision = kDefault_Precision, |
147 Origin origin = kDefault_Origin, | 147 Origin origin = kDefault_Origin, |
148 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 148 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
149 GrAssert(kVoid_GrSLType != type); | 149 SkASSERT(kVoid_GrSLType != type); |
150 fType = type; | 150 fType = type; |
151 fTypeModifier = typeModifier; | 151 fTypeModifier = typeModifier; |
152 fName = name; | 152 fName = name; |
153 fCount = count; | 153 fCount = count; |
154 fPrecision = precision; | 154 fPrecision = precision; |
155 fOrigin = origin; | 155 fOrigin = origin; |
156 fUseUniformFloatArrays = useUniformFloatArrays; | 156 fUseUniformFloatArrays = useUniformFloatArrays; |
157 } | 157 } |
158 | 158 |
159 /** | 159 /** |
160 * Set all var options | 160 * Set all var options |
161 */ | 161 */ |
162 void set(GrSLType type, | 162 void set(GrSLType type, |
163 TypeModifier typeModifier, | 163 TypeModifier typeModifier, |
164 const char* name, | 164 const char* name, |
165 int count, | 165 int count, |
166 Precision precision = kDefault_Precision, | 166 Precision precision = kDefault_Precision, |
167 Origin origin = kDefault_Origin, | 167 Origin origin = kDefault_Origin, |
168 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { | 168 bool useUniformFloatArrays = USE_UNIFORM_FLOAT_ARRAYS) { |
169 GrAssert(kVoid_GrSLType != type); | 169 SkASSERT(kVoid_GrSLType != type); |
170 fType = type; | 170 fType = type; |
171 fTypeModifier = typeModifier; | 171 fTypeModifier = typeModifier; |
172 fName = name; | 172 fName = name; |
173 fCount = count; | 173 fCount = count; |
174 fPrecision = precision; | 174 fPrecision = precision; |
175 fOrigin = origin; | 175 fOrigin = origin; |
176 fUseUniformFloatArrays = useUniformFloatArrays; | 176 fUseUniformFloatArrays = useUniformFloatArrays; |
177 } | 177 } |
178 | 178 |
179 /** | 179 /** |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
268 out->append(" "); | 268 out->append(" "); |
269 } | 269 } |
270 out->append(PrecisionString(fPrecision, ctxInfo.binding())); | 270 out->append(PrecisionString(fPrecision, ctxInfo.binding())); |
271 GrSLType effectiveType = this->getType(); | 271 GrSLType effectiveType = this->getType(); |
272 if (this->isArray()) { | 272 if (this->isArray()) { |
273 if (this->isUnsizedArray()) { | 273 if (this->isUnsizedArray()) { |
274 out->appendf("%s %s[]", | 274 out->appendf("%s %s[]", |
275 GrGLSLTypeString(effectiveType), | 275 GrGLSLTypeString(effectiveType), |
276 this->getName().c_str()); | 276 this->getName().c_str()); |
277 } else { | 277 } else { |
278 GrAssert(this->getArrayCount() > 0); | 278 SkASSERT(this->getArrayCount() > 0); |
279 out->appendf("%s %s[%d]", | 279 out->appendf("%s %s[%d]", |
280 GrGLSLTypeString(effectiveType), | 280 GrGLSLTypeString(effectiveType), |
281 this->getName().c_str(), | 281 this->getName().c_str(), |
282 this->getArrayCount()); | 282 this->getArrayCount()); |
283 } | 283 } |
284 } else { | 284 } else { |
285 out->appendf("%s %s", | 285 out->appendf("%s %s", |
286 GrGLSLTypeString(effectiveType), | 286 GrGLSLTypeString(effectiveType), |
287 this->getName().c_str()); | 287 this->getName().c_str()); |
288 } | 288 } |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
351 SkString fName; | 351 SkString fName; |
352 int fCount; | 352 int fCount; |
353 Precision fPrecision; | 353 Precision fPrecision; |
354 Origin fOrigin; | 354 Origin fOrigin; |
355 /// Work around driver bugs on some hardware that don't correctly | 355 /// Work around driver bugs on some hardware that don't correctly |
356 /// support uniform float [] | 356 /// support uniform float [] |
357 bool fUseUniformFloatArrays; | 357 bool fUseUniformFloatArrays; |
358 }; | 358 }; |
359 | 359 |
360 #endif | 360 #endif |
OLD | NEW |