blob: 07a9dcd955ffd009680cda95fde201182fa749ad [file] [log] [blame]
alokp@chromium.org07620a52010-09-23 17:53:56 +00001//
shannonwoods@chromium.orge429ab72013-05-30 00:12:52 +00002// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
alokp@chromium.org07620a52010-09-23 17:53:56 +00003// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
Jamie Madill4667c452014-07-08 15:02:36 -04007#include "angle_gl.h"
Zhenyao Mo94ac7b72014-10-15 18:22:08 -07008#include "compiler/translator/SymbolTable.h"
Geoff Lang17732822013-08-29 13:46:49 -04009#include "compiler/translator/VariableInfo.h"
Jamie Madillaa72d782014-07-02 15:31:19 -040010#include "compiler/translator/util.h"
Jamie Madilld5512cd2014-07-10 17:50:08 -040011#include "common/utilities.h"
alokp@chromium.org07620a52010-09-23 17:53:56 +000012
Jamie Madilla2fbb842014-09-03 09:40:47 -040013namespace sh
14{
15
Jamie Madill54ad4f82014-09-03 09:40:46 -040016namespace
17{
Zhenyao Mod2d340b2013-09-23 14:57:05 -040018
Jamie Madill54ad4f82014-09-03 09:40:46 -040019TString InterfaceBlockFieldName(const TInterfaceBlock &interfaceBlock, const TField &field)
20{
21 if (interfaceBlock.hasInstanceName())
22 {
23 return interfaceBlock.name() + "." + field.name();
24 }
25 else
26 {
27 return field.name();
28 }
29}
30
Jamie Madilla2fbb842014-09-03 09:40:47 -040031BlockLayoutType GetBlockLayoutType(TLayoutBlockStorage blockStorage)
Jamie Madill54ad4f82014-09-03 09:40:46 -040032{
33 switch (blockStorage)
34 {
Jamie Madilla2fbb842014-09-03 09:40:47 -040035 case EbsPacked: return BLOCKLAYOUT_PACKED;
36 case EbsShared: return BLOCKLAYOUT_SHARED;
37 case EbsStd140: return BLOCKLAYOUT_STANDARD;
38 default: UNREACHABLE(); return BLOCKLAYOUT_SHARED;
Jamie Madill54ad4f82014-09-03 09:40:46 -040039 }
40}
41
Jamie Madilla2fbb842014-09-03 09:40:47 -040042void ExpandUserDefinedVariable(const ShaderVariable &variable,
Jamie Madill54ad4f82014-09-03 09:40:46 -040043 const std::string &name,
44 const std::string &mappedName,
45 bool markStaticUse,
Jamie Madilla2fbb842014-09-03 09:40:47 -040046 std::vector<ShaderVariable> *expanded);
Jamie Madill54ad4f82014-09-03 09:40:46 -040047
Jamie Madilla2fbb842014-09-03 09:40:47 -040048void ExpandVariable(const ShaderVariable &variable,
Jamie Madill54ad4f82014-09-03 09:40:46 -040049 const std::string &name,
50 const std::string &mappedName,
51 bool markStaticUse,
Jamie Madilla2fbb842014-09-03 09:40:47 -040052 std::vector<ShaderVariable> *expanded)
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +000053{
Jamie Madill23a8a432014-07-09 13:27:42 -040054 if (variable.isStruct())
Jamie Madill4667c452014-07-08 15:02:36 -040055 {
Jamie Madill23a8a432014-07-09 13:27:42 -040056 if (variable.isArray())
57 {
Cooper Partin4d61f7e2015-08-12 10:56:50 -070058 for (unsigned int elementIndex = 0; elementIndex < variable.elementCount();
59 elementIndex++)
Jamie Madill23a8a432014-07-09 13:27:42 -040060 {
Jamie Madilla2fbb842014-09-03 09:40:47 -040061 std::string lname = name + ::ArrayString(elementIndex);
62 std::string lmappedName = mappedName + ::ArrayString(elementIndex);
Jamie Madill23a8a432014-07-09 13:27:42 -040063 ExpandUserDefinedVariable(variable, lname, lmappedName, markStaticUse, expanded);
64 }
65 }
66 else
67 {
68 ExpandUserDefinedVariable(variable, name, mappedName, markStaticUse, expanded);
69 }
Jamie Madill4667c452014-07-08 15:02:36 -040070 }
71 else
72 {
Jamie Madilla2fbb842014-09-03 09:40:47 -040073 ShaderVariable expandedVar = variable;
Jamie Madill23a8a432014-07-09 13:27:42 -040074
75 expandedVar.name = name;
76 expandedVar.mappedName = mappedName;
77
78 // Mark all expanded fields as used if the parent is used
79 if (markStaticUse)
80 {
81 expandedVar.staticUse = true;
82 }
83
84 if (expandedVar.isArray())
85 {
86 expandedVar.name += "[0]";
87 expandedVar.mappedName += "[0]";
88 }
89
90 expanded->push_back(expandedVar);
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +000091 }
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +000092}
93
Jamie Madilla2fbb842014-09-03 09:40:47 -040094void ExpandUserDefinedVariable(const ShaderVariable &variable,
Jamie Madill54ad4f82014-09-03 09:40:46 -040095 const std::string &name,
96 const std::string &mappedName,
97 bool markStaticUse,
Jamie Madilla2fbb842014-09-03 09:40:47 -040098 std::vector<ShaderVariable> *expanded)
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +000099{
Jamie Madill23a8a432014-07-09 13:27:42 -0400100 ASSERT(variable.isStruct());
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000101
Jamie Madilla2fbb842014-09-03 09:40:47 -0400102 const std::vector<ShaderVariable> &fields = variable.fields;
Jamie Madill23a8a432014-07-09 13:27:42 -0400103
104 for (size_t fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
Jamie Madill4667c452014-07-08 15:02:36 -0400105 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400106 const ShaderVariable &field = fields[fieldIndex];
Jamie Madill23a8a432014-07-09 13:27:42 -0400107 ExpandVariable(field,
108 name + "." + field.name,
109 mappedName + "." + field.mappedName,
110 markStaticUse,
111 expanded);
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000112 }
113}
114
Jamie Madilla718c1e2014-07-02 15:31:22 -0400115template <class VarT>
Jamie Madill54ad4f82014-09-03 09:40:46 -0400116VarT *FindVariable(const TString &name,
117 std::vector<VarT> *infoList)
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400118{
119 // TODO(zmo): optimize this function.
Jamie Madilla718c1e2014-07-02 15:31:22 -0400120 for (size_t ii = 0; ii < infoList->size(); ++ii)
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400121 {
Jamie Madill23a8a432014-07-09 13:27:42 -0400122 if ((*infoList)[ii].name.c_str() == name)
Jamie Madilla718c1e2014-07-02 15:31:22 -0400123 return &((*infoList)[ii]);
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400124 }
Jamie Madilld5512cd2014-07-10 17:50:08 -0400125
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400126 return NULL;
127}
128
Jamie Madill54ad4f82014-09-03 09:40:46 -0400129}
130
Jamie Madilla718c1e2014-07-02 15:31:22 -0400131CollectVariables::CollectVariables(std::vector<sh::Attribute> *attribs,
Jamie Madilla0a9e122015-09-02 15:54:30 -0400132 std::vector<sh::OutputVariable> *outputVariables,
Jamie Madilla718c1e2014-07-02 15:31:22 -0400133 std::vector<sh::Uniform> *uniforms,
134 std::vector<sh::Varying> *varyings,
Jamie Madilld5512cd2014-07-10 17:50:08 -0400135 std::vector<sh::InterfaceBlock> *interfaceBlocks,
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700136 ShHashFunction64 hashFunction,
137 const TSymbolTable &symbolTable)
Olli Etuaho3d0d9a42015-06-01 12:16:36 +0300138 : TIntermTraverser(true, false, false),
139 mAttribs(attribs),
Jamie Madilld5512cd2014-07-10 17:50:08 -0400140 mOutputVariables(outputVariables),
daniel@transgaming.com0aa3b5a2012-11-28 19:43:24 +0000141 mUniforms(uniforms),
Zhenyao Mo74da9f22013-09-23 14:57:01 -0400142 mVaryings(varyings),
Jamie Madilld5512cd2014-07-10 17:50:08 -0400143 mInterfaceBlocks(interfaceBlocks),
Jamie Madill55def582015-05-04 11:24:57 -0400144 mDepthRangeAdded(false),
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400145 mPointCoordAdded(false),
146 mFrontFacingAdded(false),
147 mFragCoordAdded(false),
Gregoire Payen de La Garanderieb3dced22015-01-12 14:54:55 +0000148 mInstanceIDAdded(false),
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700149 mPositionAdded(false),
150 mPointSizeAdded(false),
Erik Dahlströmea7a2122014-11-17 16:15:57 +0100151 mLastFragDataAdded(false),
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300152 mFragColorAdded(false),
153 mFragDataAdded(false),
154 mFragDepthAdded(false),
Kimmo Kinnunenb18609b2015-07-16 14:13:11 +0300155 mSecondaryFragColorEXTAdded(false),
156 mSecondaryFragDataEXTAdded(false),
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700157 mHashFunction(hashFunction),
158 mSymbolTable(symbolTable)
alokp@chromium.org07620a52010-09-23 17:53:56 +0000159{
160}
161
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400162// We want to check whether a uniform/varying is statically used
163// because we only count the used ones in packing computing.
164// Also, gl_FragCoord, gl_PointCoord, and gl_FrontFacing count
165// toward varying counting if they are statically used in a fragment
166// shader.
Jamie Madill4667c452014-07-08 15:02:36 -0400167void CollectVariables::visitSymbol(TIntermSymbol *symbol)
alokp@chromium.org07620a52010-09-23 17:53:56 +0000168{
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400169 ASSERT(symbol != NULL);
Jamie Madilla2fbb842014-09-03 09:40:47 -0400170 ShaderVariable *var = NULL;
Jamie Madilld5512cd2014-07-10 17:50:08 -0400171 const TString &symbolName = symbol->getSymbol();
Jamie Madill4667c452014-07-08 15:02:36 -0400172
Jamie Madilla2fbb842014-09-03 09:40:47 -0400173 if (IsVarying(symbol->getQualifier()))
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400174 {
Jamie Madilld5512cd2014-07-10 17:50:08 -0400175 var = FindVariable(symbolName, mVaryings);
Jamie Madill4667c452014-07-08 15:02:36 -0400176 }
Jamie Madillb547ddf2014-08-25 16:20:46 -0400177 else if (symbol->getType().getBasicType() == EbtInterfaceBlock)
178 {
179 UNREACHABLE();
180 }
Jamie Madill55def582015-05-04 11:24:57 -0400181 else if (symbolName == "gl_DepthRange")
182 {
183 ASSERT(symbol->getQualifier() == EvqUniform);
184
185 if (!mDepthRangeAdded)
186 {
187 Uniform info;
188 const char kName[] = "gl_DepthRange";
189 info.name = kName;
190 info.mappedName = kName;
191 info.type = GL_STRUCT_ANGLEX;
192 info.arraySize = 0;
193 info.precision = GL_NONE;
194 info.staticUse = true;
195
196 ShaderVariable nearInfo;
197 const char kNearName[] = "near";
198 nearInfo.name = kNearName;
199 nearInfo.mappedName = kNearName;
200 nearInfo.type = GL_FLOAT;
201 nearInfo.arraySize = 0;
202 nearInfo.precision = GL_HIGH_FLOAT;
203 nearInfo.staticUse = true;
204
205 ShaderVariable farInfo;
206 const char kFarName[] = "far";
207 farInfo.name = kFarName;
208 farInfo.mappedName = kFarName;
209 farInfo.type = GL_FLOAT;
210 farInfo.arraySize = 0;
211 farInfo.precision = GL_HIGH_FLOAT;
212 farInfo.staticUse = true;
213
214 ShaderVariable diffInfo;
215 const char kDiffName[] = "diff";
216 diffInfo.name = kDiffName;
217 diffInfo.mappedName = kDiffName;
218 diffInfo.type = GL_FLOAT;
219 diffInfo.arraySize = 0;
220 diffInfo.precision = GL_HIGH_FLOAT;
221 diffInfo.staticUse = true;
222
223 info.fields.push_back(nearInfo);
224 info.fields.push_back(farInfo);
225 info.fields.push_back(diffInfo);
226
227 mUniforms->push_back(info);
228 mDepthRangeAdded = true;
229 }
230 }
Jamie Madillb547ddf2014-08-25 16:20:46 -0400231 else
Jamie Madill4667c452014-07-08 15:02:36 -0400232 {
233 switch (symbol->getQualifier())
Jamie Madilla718c1e2014-07-02 15:31:22 -0400234 {
Jamie Madilld5512cd2014-07-10 17:50:08 -0400235 case EvqAttribute:
236 case EvqVertexIn:
237 var = FindVariable(symbolName, mAttribs);
238 break;
239 case EvqFragmentOut:
240 var = FindVariable(symbolName, mOutputVariables);
241 break;
Jamie Madill4667c452014-07-08 15:02:36 -0400242 case EvqUniform:
Jamie Madilld5512cd2014-07-10 17:50:08 -0400243 {
244 const TInterfaceBlock *interfaceBlock = symbol->getType().getInterfaceBlock();
245 if (interfaceBlock)
246 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400247 InterfaceBlock *namedBlock = FindVariable(interfaceBlock->name(), mInterfaceBlocks);
Jamie Madilld5512cd2014-07-10 17:50:08 -0400248 ASSERT(namedBlock);
249 var = FindVariable(symbolName, &namedBlock->fields);
250
251 // Set static use on the parent interface block here
252 namedBlock->staticUse = true;
253 }
254 else
255 {
256 var = FindVariable(symbolName, mUniforms);
257 }
258
259 // It's an internal error to reference an undefined user uniform
Jamie Madill55def582015-05-04 11:24:57 -0400260 ASSERT(symbolName.compare(0, 3, "gl_") != 0 || var);
Jamie Madilld5512cd2014-07-10 17:50:08 -0400261 }
Jamie Madill4667c452014-07-08 15:02:36 -0400262 break;
263 case EvqFragCoord:
264 if (!mFragCoordAdded)
265 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400266 Varying info;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700267 const char kName[] = "gl_FragCoord";
268 info.name = kName;
269 info.mappedName = kName;
Jamie Madill4667c452014-07-08 15:02:36 -0400270 info.type = GL_FLOAT_VEC4;
271 info.arraySize = 0;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700272 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
Jamie Madill4667c452014-07-08 15:02:36 -0400273 info.staticUse = true;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700274 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
Jamie Madill4667c452014-07-08 15:02:36 -0400275 mVaryings->push_back(info);
276 mFragCoordAdded = true;
277 }
278 return;
279 case EvqFrontFacing:
280 if (!mFrontFacingAdded)
281 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400282 Varying info;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700283 const char kName[] = "gl_FrontFacing";
284 info.name = kName;
285 info.mappedName = kName;
Jamie Madill4667c452014-07-08 15:02:36 -0400286 info.type = GL_BOOL;
287 info.arraySize = 0;
288 info.precision = GL_NONE;
289 info.staticUse = true;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700290 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
Jamie Madill4667c452014-07-08 15:02:36 -0400291 mVaryings->push_back(info);
292 mFrontFacingAdded = true;
293 }
294 return;
295 case EvqPointCoord:
296 if (!mPointCoordAdded)
297 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400298 Varying info;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700299 const char kName[] = "gl_PointCoord";
300 info.name = kName;
301 info.mappedName = kName;
Jamie Madill4667c452014-07-08 15:02:36 -0400302 info.type = GL_FLOAT_VEC2;
303 info.arraySize = 0;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700304 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
Jamie Madill4667c452014-07-08 15:02:36 -0400305 info.staticUse = true;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700306 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
Jamie Madill4667c452014-07-08 15:02:36 -0400307 mVaryings->push_back(info);
308 mPointCoordAdded = true;
309 }
310 return;
Gregoire Payen de La Garanderieb3dced22015-01-12 14:54:55 +0000311 case EvqInstanceID:
312 if (!mInstanceIDAdded)
313 {
314 Attribute info;
315 const char kName[] = "gl_InstanceID";
316 info.name = kName;
317 info.mappedName = kName;
318 info.type = GL_INT;
319 info.arraySize = 0;
320 info.precision = GL_HIGH_INT; // Defined by spec.
321 info.staticUse = true;
322 info.location = -1;
323 mAttribs->push_back(info);
324 mInstanceIDAdded = true;
325 }
326 return;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700327 case EvqPosition:
328 if (!mPositionAdded)
329 {
330 Varying info;
331 const char kName[] = "gl_Position";
332 info.name = kName;
333 info.mappedName = kName;
334 info.type = GL_FLOAT_VEC4;
335 info.arraySize = 0;
336 info.precision = GL_HIGH_FLOAT; // Defined by spec.
337 info.staticUse = true;
338 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
339 mVaryings->push_back(info);
340 mPositionAdded = true;
341 }
342 return;
343 case EvqPointSize:
344 if (!mPointSizeAdded)
345 {
346 Varying info;
347 const char kName[] = "gl_PointSize";
348 info.name = kName;
349 info.mappedName = kName;
350 info.type = GL_FLOAT;
351 info.arraySize = 0;
352 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
353 info.staticUse = true;
354 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
355 mVaryings->push_back(info);
356 mPointSizeAdded = true;
357 }
358 return;
Erik Dahlströmea7a2122014-11-17 16:15:57 +0100359 case EvqLastFragData:
360 if (!mLastFragDataAdded)
361 {
362 Varying info;
363 const char kName[] = "gl_LastFragData";
364 info.name = kName;
365 info.mappedName = kName;
366 info.type = GL_FLOAT_VEC4;
367 info.arraySize = static_cast<const TVariable*>(mSymbolTable.findBuiltIn("gl_MaxDrawBuffers", 100))->getConstPointer()->getIConst();
368 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
369 info.staticUse = true;
370 info.isInvariant = mSymbolTable.isVaryingInvariant(kName);
371 mVaryings->push_back(info);
372 mLastFragDataAdded = true;
373 }
374 return;
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300375 case EvqFragColor:
376 if (!mFragColorAdded)
377 {
Jamie Madilla0a9e122015-09-02 15:54:30 -0400378 OutputVariable info;
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300379 const char kName[] = "gl_FragColor";
380 info.name = kName;
381 info.mappedName = kName;
382 info.type = GL_FLOAT_VEC4;
383 info.arraySize = 0;
384 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
385 info.staticUse = true;
386 mOutputVariables->push_back(info);
387 mFragColorAdded = true;
388 }
389 return;
390 case EvqFragData:
391 if (!mFragDataAdded)
392 {
Jamie Madilla0a9e122015-09-02 15:54:30 -0400393 OutputVariable info;
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300394 const char kName[] = "gl_FragData";
395 info.name = kName;
396 info.mappedName = kName;
397 info.type = GL_FLOAT_VEC4;
398 info.arraySize = static_cast<const TVariable *>(
399 mSymbolTable.findBuiltIn("gl_MaxDrawBuffers", 100))
400 ->getConstPointer()
401 ->getIConst();
402 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
403 info.staticUse = true;
404 mOutputVariables->push_back(info);
405 mFragDataAdded = true;
406 }
407 return;
Geoff Lange2bfe2c2015-07-23 21:25:45 +0000408 case EvqFragDepth:
409 if (!mFragDepthAdded)
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300410 {
Jamie Madilla0a9e122015-09-02 15:54:30 -0400411 OutputVariable info;
Kimmo Kinnunen0932df62015-07-21 14:35:11 +0300412 const char kName[] = "gl_FragDepthEXT";
413 info.name = kName;
414 info.mappedName = kName;
415 info.type = GL_FLOAT;
416 info.arraySize = 0;
417 info.precision =
418 GLVariablePrecision(static_cast<const TVariable *>(
419 mSymbolTable.findBuiltIn("gl_FragDepthEXT", 100))
420 ->getType());
421 info.staticUse = true;
422 mOutputVariables->push_back(info);
423 mFragDepthAdded = true;
424 }
425 return;
Kimmo Kinnunenb18609b2015-07-16 14:13:11 +0300426 case EvqSecondaryFragColorEXT:
427 if (!mSecondaryFragColorEXTAdded)
428 {
Jamie Madilla0a9e122015-09-02 15:54:30 -0400429 OutputVariable info;
Kimmo Kinnunenb18609b2015-07-16 14:13:11 +0300430 const char kName[] = "gl_SecondaryFragColorEXT";
431 info.name = kName;
432 info.mappedName = kName;
433 info.type = GL_FLOAT_VEC4;
434 info.arraySize = 0;
435 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
436 info.staticUse = true;
437 mOutputVariables->push_back(info);
438 mSecondaryFragColorEXTAdded = true;
439 }
440 return;
441 case EvqSecondaryFragDataEXT:
442 if (!mSecondaryFragDataEXTAdded)
443 {
Jamie Madilla0a9e122015-09-02 15:54:30 -0400444 OutputVariable info;
Kimmo Kinnunenb18609b2015-07-16 14:13:11 +0300445 const char kName[] = "gl_SecondaryFragDataEXT";
446 info.name = kName;
447 info.mappedName = kName;
448 info.type = GL_FLOAT_VEC4;
449
450 const TVariable *maxDualSourceDrawBuffersVar = static_cast<const TVariable *>(
451 mSymbolTable.findBuiltIn("gl_MaxDualSourceDrawBuffersEXT", 100));
452 info.arraySize = maxDualSourceDrawBuffersVar->getConstPointer()->getIConst();
453 info.precision = GL_MEDIUM_FLOAT; // Defined by spec.
454 info.staticUse = true;
455 mOutputVariables->push_back(info);
456 mSecondaryFragDataEXTAdded = true;
457 }
458 return;
Jamie Madill4667c452014-07-08 15:02:36 -0400459 default:
460 break;
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400461 }
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400462 }
463 if (var)
Jamie Madilla718c1e2014-07-02 15:31:22 -0400464 {
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400465 var->staticUse = true;
Jamie Madilla718c1e2014-07-02 15:31:22 -0400466 }
467}
468
Jamie Madilla2fbb842014-09-03 09:40:47 -0400469class NameHashingTraverser : public GetVariableTraverser
Jamie Madill23a8a432014-07-09 13:27:42 -0400470{
471 public:
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700472 NameHashingTraverser(ShHashFunction64 hashFunction,
473 const TSymbolTable &symbolTable)
474 : GetVariableTraverser(symbolTable),
475 mHashFunction(hashFunction)
Jamie Madill23a8a432014-07-09 13:27:42 -0400476 {}
477
478 private:
Corentin Walleze5a1f272015-08-21 02:58:25 +0200479 void visitVariable(ShaderVariable *variable) override
Jamie Madill23a8a432014-07-09 13:27:42 -0400480 {
481 TString stringName = TString(variable->name.c_str());
482 variable->mappedName = TIntermTraverser::hash(stringName, mHashFunction).c_str();
483 }
484
485 ShHashFunction64 mHashFunction;
486};
487
488// Attributes, which cannot have struct fields, are a special case
489template <>
490void CollectVariables::visitVariable(const TIntermSymbol *variable,
Jamie Madilla2fbb842014-09-03 09:40:47 -0400491 std::vector<Attribute> *infoList) const
Jamie Madill23a8a432014-07-09 13:27:42 -0400492{
493 ASSERT(variable);
494 const TType &type = variable->getType();
495 ASSERT(!type.getStruct());
496
Jamie Madilla2fbb842014-09-03 09:40:47 -0400497 Attribute attribute;
Jamie Madill23a8a432014-07-09 13:27:42 -0400498
Jamie Madilla2fbb842014-09-03 09:40:47 -0400499 attribute.type = GLVariableType(type);
500 attribute.precision = GLVariablePrecision(type);
Jamie Madill23a8a432014-07-09 13:27:42 -0400501 attribute.name = variable->getSymbol().c_str();
502 attribute.arraySize = static_cast<unsigned int>(type.getArraySize());
503 attribute.mappedName = TIntermTraverser::hash(variable->getSymbol(), mHashFunction).c_str();
504 attribute.location = variable->getType().getLayoutQualifier().location;
505
506 infoList->push_back(attribute);
507}
508
Jamie Madilld5512cd2014-07-10 17:50:08 -0400509template <>
510void CollectVariables::visitVariable(const TIntermSymbol *variable,
Jamie Madilla0a9e122015-09-02 15:54:30 -0400511 std::vector<OutputVariable> *infoList) const
512{
513 ASSERT(variable);
514 const TType &type = variable->getType();
515 ASSERT(!type.getStruct());
516
517 OutputVariable attribute;
518
519 attribute.type = GLVariableType(type);
520 attribute.precision = GLVariablePrecision(type);
521 attribute.name = variable->getSymbol().c_str();
522 attribute.arraySize = static_cast<unsigned int>(type.getArraySize());
523 attribute.mappedName = TIntermTraverser::hash(variable->getSymbol(), mHashFunction).c_str();
524 attribute.location = variable->getType().getLayoutQualifier().location;
525
526 infoList->push_back(attribute);
527}
528
529template <>
530void CollectVariables::visitVariable(const TIntermSymbol *variable,
Jamie Madilla2fbb842014-09-03 09:40:47 -0400531 std::vector<InterfaceBlock> *infoList) const
Jamie Madilld5512cd2014-07-10 17:50:08 -0400532{
Jamie Madilla2fbb842014-09-03 09:40:47 -0400533 InterfaceBlock interfaceBlock;
Jamie Madilld5512cd2014-07-10 17:50:08 -0400534 const TInterfaceBlock *blockType = variable->getType().getInterfaceBlock();
Jamie Madill42bcf322014-08-25 16:20:46 -0400535 ASSERT(blockType);
Jamie Madilld5512cd2014-07-10 17:50:08 -0400536
537 interfaceBlock.name = blockType->name().c_str();
538 interfaceBlock.mappedName = TIntermTraverser::hash(variable->getSymbol(), mHashFunction).c_str();
Jamie Madill42bcf322014-08-25 16:20:46 -0400539 interfaceBlock.instanceName = (blockType->hasInstanceName() ? blockType->instanceName().c_str() : "");
Jamie Madilld5512cd2014-07-10 17:50:08 -0400540 interfaceBlock.arraySize = variable->getArraySize();
Jamie Madill42bcf322014-08-25 16:20:46 -0400541 interfaceBlock.isRowMajorLayout = (blockType->matrixPacking() == EmpRowMajor);
Jamie Madill54ad4f82014-09-03 09:40:46 -0400542 interfaceBlock.layout = GetBlockLayoutType(blockType->blockStorage());
Jamie Madilld5512cd2014-07-10 17:50:08 -0400543
Jamie Madilla6f267f2014-08-27 11:44:15 -0400544 // Gather field information
Jamie Madill54ad4f82014-09-03 09:40:46 -0400545 const TFieldList &fieldList = blockType->fields();
546
547 for (size_t fieldIndex = 0; fieldIndex < fieldList.size(); ++fieldIndex)
548 {
549 const TField &field = *fieldList[fieldIndex];
550 const TString &fullFieldName = InterfaceBlockFieldName(*blockType, field);
551 const TType &fieldType = *field.type();
552
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700553 GetVariableTraverser traverser(mSymbolTable);
Jamie Madill54ad4f82014-09-03 09:40:46 -0400554 traverser.traverse(fieldType, fullFieldName, &interfaceBlock.fields);
555
556 interfaceBlock.fields.back().isRowMajorLayout = (fieldType.getLayoutQualifier().matrixPacking == EmpRowMajor);
557 }
Jamie Madilld5512cd2014-07-10 17:50:08 -0400558
559 infoList->push_back(interfaceBlock);
560}
561
Jamie Madill23a8a432014-07-09 13:27:42 -0400562template <typename VarT>
Jamie Madill4667c452014-07-08 15:02:36 -0400563void CollectVariables::visitVariable(const TIntermSymbol *variable,
564 std::vector<VarT> *infoList) const
565{
Zhenyao Mo94ac7b72014-10-15 18:22:08 -0700566 NameHashingTraverser traverser(mHashFunction, mSymbolTable);
Jamie Madill42bcf322014-08-25 16:20:46 -0400567 traverser.traverse(variable->getType(), variable->getSymbol(), infoList);
Jamie Madill4667c452014-07-08 15:02:36 -0400568}
569
570template <typename VarT>
571void CollectVariables::visitInfoList(const TIntermSequence &sequence,
572 std::vector<VarT> *infoList) const
Jamie Madilla718c1e2014-07-02 15:31:22 -0400573{
574 for (size_t seqIndex = 0; seqIndex < sequence.size(); seqIndex++)
575 {
Jamie Madill4667c452014-07-08 15:02:36 -0400576 const TIntermSymbol *variable = sequence[seqIndex]->getAsSymbolNode();
Jamie Madilla718c1e2014-07-02 15:31:22 -0400577 // The only case in which the sequence will not contain a
578 // TIntermSymbol node is initialization. It will contain a
579 // TInterBinary node in that case. Since attributes, uniforms,
580 // and varyings cannot be initialized in a shader, we must have
581 // only TIntermSymbol nodes in the sequence.
582 ASSERT(variable != NULL);
Jamie Madill4667c452014-07-08 15:02:36 -0400583 visitVariable(variable, infoList);
Jamie Madilla718c1e2014-07-02 15:31:22 -0400584 }
alokp@chromium.org07620a52010-09-23 17:53:56 +0000585}
586
Jamie Madill4667c452014-07-08 15:02:36 -0400587bool CollectVariables::visitAggregate(Visit, TIntermAggregate *node)
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000588{
Zhenyao Mod2d340b2013-09-23 14:57:05 -0400589 bool visitChildren = true;
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000590
591 switch (node->getOp())
592 {
Jamie Madill4667c452014-07-08 15:02:36 -0400593 case EOpDeclaration:
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000594 {
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700595 const TIntermSequence &sequence = *(node->getSequence());
Jamie Madill1c28e1f2014-08-04 11:37:54 -0400596 ASSERT(!sequence.empty());
597
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700598 const TIntermTyped &typedNode = *(sequence.front()->getAsTyped());
Jamie Madilld5512cd2014-07-10 17:50:08 -0400599 TQualifier qualifier = typedNode.getQualifier();
600
601 if (typedNode.getBasicType() == EbtInterfaceBlock)
602 {
603 visitInfoList(sequence, mInterfaceBlocks);
Jamie Madillb547ddf2014-08-25 16:20:46 -0400604 visitChildren = false;
Jamie Madilld5512cd2014-07-10 17:50:08 -0400605 }
606 else if (qualifier == EvqAttribute || qualifier == EvqVertexIn ||
607 qualifier == EvqFragmentOut || qualifier == EvqUniform ||
Jamie Madilla2fbb842014-09-03 09:40:47 -0400608 IsVarying(qualifier))
Zhenyao Mo74da9f22013-09-23 14:57:01 -0400609 {
Jamie Madill4667c452014-07-08 15:02:36 -0400610 switch (qualifier)
611 {
612 case EvqAttribute:
613 case EvqVertexIn:
614 visitInfoList(sequence, mAttribs);
615 break;
Jamie Madilld5512cd2014-07-10 17:50:08 -0400616 case EvqFragmentOut:
617 visitInfoList(sequence, mOutputVariables);
618 break;
Jamie Madill4667c452014-07-08 15:02:36 -0400619 case EvqUniform:
620 visitInfoList(sequence, mUniforms);
621 break;
622 default:
Jamie Madill3b5c2da2014-08-19 15:23:32 -0400623 visitInfoList(sequence, mVaryings);
Jamie Madill4667c452014-07-08 15:02:36 -0400624 break;
625 }
Zhenyao Mo74da9f22013-09-23 14:57:01 -0400626
Jamie Madill1c28e1f2014-08-04 11:37:54 -0400627 visitChildren = false;
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000628 }
Jamie Madill4667c452014-07-08 15:02:36 -0400629 break;
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000630 }
Jamie Madill4667c452014-07-08 15:02:36 -0400631 default: break;
alokp@chromium.orgee76f6a2010-09-27 19:28:55 +0000632 }
633
634 return visitChildren;
635}
Jamie Madill23a8a432014-07-09 13:27:42 -0400636
Jamie Madillb547ddf2014-08-25 16:20:46 -0400637bool CollectVariables::visitBinary(Visit, TIntermBinary *binaryNode)
638{
639 if (binaryNode->getOp() == EOpIndexDirectInterfaceBlock)
640 {
Jamie Madilla6f267f2014-08-27 11:44:15 -0400641 // NOTE: we do not determine static use for individual blocks of an array
642 TIntermTyped *blockNode = binaryNode->getLeft()->getAsTyped();
643 ASSERT(blockNode);
Jamie Madillb547ddf2014-08-25 16:20:46 -0400644
645 TIntermConstantUnion *constantUnion = binaryNode->getRight()->getAsConstantUnion();
646 ASSERT(constantUnion);
647
Jamie Madilla6f267f2014-08-27 11:44:15 -0400648 const TInterfaceBlock *interfaceBlock = blockNode->getType().getInterfaceBlock();
Jamie Madilla2fbb842014-09-03 09:40:47 -0400649 InterfaceBlock *namedBlock = FindVariable(interfaceBlock->name(), mInterfaceBlocks);
Jamie Madillb547ddf2014-08-25 16:20:46 -0400650 ASSERT(namedBlock);
651 namedBlock->staticUse = true;
652
653 unsigned int fieldIndex = constantUnion->getUConst(0);
654 ASSERT(fieldIndex < namedBlock->fields.size());
655 namedBlock->fields[fieldIndex].staticUse = true;
656 return false;
657 }
658
659 return true;
660}
661
Zhenyao Mo409078f2014-10-28 13:23:18 -0700662void ExpandUniforms(const std::vector<Uniform> &compact,
663 std::vector<ShaderVariable> *expanded)
Jamie Madill23a8a432014-07-09 13:27:42 -0400664{
665 for (size_t variableIndex = 0; variableIndex < compact.size(); variableIndex++)
666 {
Jamie Madilla2fbb842014-09-03 09:40:47 -0400667 const ShaderVariable &variable = compact[variableIndex];
Jamie Madill23a8a432014-07-09 13:27:42 -0400668 ExpandVariable(variable, variable.name, variable.mappedName, variable.staticUse, expanded);
669 }
670}
671
Jamie Madilla2fbb842014-09-03 09:40:47 -0400672}